pa-fazil
/
android_system_core
mirror of https://github.com/fazilsheik96/android_system_core.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
android_system_core/fs_mgr/tests/adb-remount-test.sh

1584 lines
45 KiB
Bash
Executable File
Raw Blame History

#! /bin/bash
#
# Divided into four section:
#
## USAGE
## Helper Variables
## Helper Functions
## MAINLINE
##
## USAGE
##
USAGE="USAGE: `basename ${0}` [--help] [--serial <SerialNumber>] [options]
adb remount tests
-c --color Dress output with highlighting colors
-h --help This help
-D --no-wait-screen Do not wait for display screen to settle
-t --print-time Report the test duration
-s --serial Specify device (must if multiple are present)"
if [ -n "`which timeout`" ]; then
USAGE="${USAGE}
-a --wait-adb <duration> adb wait timeout
-f --wait-fastboot <duration> fastboot wait timeout"
fi
USAGE="${USAGE}
Conditions:
- Must be a userdebug build.
- Must be in adb mode.
- Also tests overlayfs
- Kernel must have overlayfs enabled and patched to support override_creds.
- Must have either erofs, squashfs, ext4-dedupe or full partitions.
- Minimum expectation system and vender are overlayfs covered partitions.
"
##
## Helper Variables
##
EMPTY=""
SPACE=" "
# Line up wrap to [ XXXXXXX ] messages.
INDENT=" "
# A _real_ embedded tab character
TAB="`echo | tr '\n' '\t'`"
# A _real_ embedded escape character
ESCAPE="`echo | tr '\n' '\033'`"
# A _real_ embedded carriage return character
CR="`echo | tr '\n' '\r'`"
RED=
GREEN=
YELLOW=
BLUE=
NORMAL=
color=false
# Assume support color if stdout is terminal.
[ -t 1 ] && color=true
print_time=true
start_time=`date +%s`
ACTIVE_SLOT=
OVERLAYFS_BACKING="cache mnt/scratch"
ADB_WAIT=4m
FASTBOOT_WAIT=2m
screen_wait=true
##
## Helper Functions
##
[ "USAGE: LOG [RUN|OK|PASSED|WARNING|ERROR|FAILED|INFO] [message]..." ]
LOG() {
if ${print_time}; then
echo -n "$(date '+%m-%d %T') "
fi >&2
case "${1}" in
R*)
shift
echo "${GREEN}[ RUN ]${NORMAL}" "${@}"
;;
OK)
shift
echo "${GREEN}[ OK ]${NORMAL}" "${@}"
;;
P*)
shift
echo "${GREEN}[ PASSED ]${NORMAL}" "${@}"
;;
W*)
shift
echo "${YELLOW}[ WARNING ]${NORMAL}" "${@}"
;;
E*)
shift
echo "${RED}[ ERROR ]${NORMAL}" "${@}"
;;
F*)
shift
echo "${RED}[ FAILED ]${NORMAL}" "${@}"
;;
I*)
shift
echo "${BLUE}[ INFO ]${NORMAL}" "${@}"
;;
*)
echo "${BLUE}[ INFO ]${NORMAL}" "${@}"
;;
esac >&2
}
[ "USAGE: inFastboot
Returns: true if device is in fastboot mode" ]
inFastboot() {
fastboot devices |
if [ -n "${ANDROID_SERIAL}" ]; then
grep "^${ANDROID_SERIAL}[${SPACE}${TAB}]" > /dev/null
else
wc -l | grep "^[${SPACE}${TAB}]*1\$" >/dev/null
fi
}
[ "USAGE: inAdb
Returns: true if device is in adb mode" ]
inAdb() {
adb devices |
grep -v -e 'List of devices attached' -e '^$' -e "[${SPACE}${TAB}]recovery\$" |
if [ -n "${ANDROID_SERIAL}" ]; then
grep "^${ANDROID_SERIAL}[${SPACE}${TAB}]" > /dev/null
else
wc -l | grep "^[${SPACE}${TAB}]*1\$" >/dev/null
fi
}
[ "USAGE: inRecovery
Returns: true if device is in recovery mode" ]
inRecovery() {
local list="`adb devices |
grep -v -e 'List of devices attached' -e '^$'`"
if [ -n "${ANDROID_SERIAL}" ]; then
echo "${list}" |
grep "^${ANDROID_SERIAL}[${SPACE}${TAB}][${SPACE}${TAB}]*recovery\$" >/dev/null
return ${?}
fi
if echo "${list}" | wc -l | grep "^[${SPACE}${TAB}]*1\$" >/dev/null; then
echo "${list}" |
grep "[${SPACE}${TAB}]recovery\$" >/dev/null
return ${?}
fi
false
}
[ "USAGE: adb_sh <commands> </dev/stdin >/dev/stdout 2>/dev/stderr
Returns: true if the command succeeded" ]
adb_sh() {
local args=
for i in "${@}"; do
[ -z "${args}" ] || args="${args} "
if [ X"${i}" != X"${i#\'}" ]; then
args="${args}${i}"
elif [ X"${i}" != X"${i#* }" ]; then
args="${args}'${i}'"
elif [ X"${i}" != X"${i#*${TAB}}" ]; then
args="${args}'${i}'"
else
args="${args}${i}"
fi
done
adb shell "${args}"
}
[ "USAGE: adb_date >/dev/stdout
Returns: report device epoch time (suitable for logcat -t)" ]
adb_date() {
adb_sh date +%s.%N </dev/null
}
[ "USAGE: adb_logcat [arguments] >/dev/stdout
Returns: the logcat output" ]
adb_logcat() {
LOG INFO "logcat ${*}"
adb logcat "${@}" </dev/null |
tr -d '\r' |
grep -v 'logd : logdr: UID=' |
sed -e '${ /------- beginning of kernel/d }' -e 's/^[0-1][0-9]-[0-3][0-9] //'
}
[ "USAGE: avc_check >/dev/stderr
Returns: worrisome avc violations" ]
avc_check() {
if ! ${overlayfs_needed:-false}; then
return
fi
local L=`adb_logcat -b all -v brief -d \
-e 'context=u:object_r:unlabeled:s0' 2>/dev/null |
sed -n 's/.*avc: //p' |
sort -u`
if [ -z "${L}" ]; then
return
fi
LOG WARNING "unlabeled sepolicy violations:"
echo "${L}" | sed "s/^/${INDENT}/" >&2
}
[ "USAGE: get_property <prop>
Returns the property value" ]
get_property() {
adb_sh getprop ${1} </dev/null
}
[ "USAGE: adb_su <commands> </dev/stdin >/dev/stdout 2>/dev/stderr
Returns: true if the command running as root succeeded" ]
adb_su() {
adb_sh su root "${@}"
}
[ "USAGE: adb_cat <file> >stdout
Returns: content of file to stdout with carriage returns skipped,
true if the file exists" ]
adb_cat() {
local OUTPUT="`adb_sh cat ${1} </dev/null 2>&1`"
local ret=${?}
echo "${OUTPUT}" | tr -d '\r'
return ${ret}
}
[ "USAGE: adb_test <expression>
Returns: exit status of the test expression" ]
adb_test() {
adb_sh test "${@}" </dev/null
}
[ "USAGE: adb_reboot
Returns: true if the reboot command succeeded" ]
adb_reboot() {
avc_check
adb reboot remount-test </dev/null || true
sleep 2
adb_wait "${ADB_WAIT}"
}
[ "USAGE: format_duration [<seconds>|<seconds>s|<minutes>m|<hours>h|<days>d]
human readable output whole seconds, whole minutes or mm:ss" ]
format_duration() {
if [ -z "${1}" ]; then
echo unknown
return
fi
local duration="${1}"
if [ X"${duration}" != X"${duration%s}" ]; then
duration=${duration%s}
elif [ X"${duration}" != X"${duration%m}" ]; then
duration=$(( ${duration%m} * 60 ))
elif [ X"${duration}" != X"${duration%h}" ]; then
duration=$(( ${duration%h} * 3600 ))
elif [ X"${duration}" != X"${duration%d}" ]; then
duration=$(( ${duration%d} * 86400 ))
fi
local seconds=$(( ${duration} % 60 ))
local minutes=$(( ( ${duration} / 60 ) % 60 ))
local hours=$(( ${duration} / 3600 ))
if [ 0 -eq ${minutes} -a 0 -eq ${hours} ]; then
if [ 1 -eq ${duration} ]; then
echo 1 second
return
fi
echo ${duration} seconds
return
elif [ 60 -eq ${duration} ]; then
echo 1 minute
return
elif [ 0 -eq ${seconds} -a 0 -eq ${hours} ]; then
echo ${minutes} minutes
return
fi
if [ 0 -eq ${hours} ]; then
echo ${minutes}:$(( ${seconds} / 10 ))$(( ${seconds} % 10 ))
return
fi
echo ${hours}:$(( ${minutes} / 10 ))$(( ${minutes} % 10 )):$(( ${seconds} / 10 ))$(( ${seconds} % 10))
}
[ "USAGE: USB_DEVICE=\`usb_devnum [--next]\`
USB_DEVICE contains cache. Update if system changes.
Returns: the devnum for the USB_SERIAL device" ]
usb_devnum() {
if [ -n "${USB_SERIAL}" ]; then
local usb_device=`cat ${USB_SERIAL%/serial}/devnum 2>/dev/null | tr -d ' \t\r\n'`
if [ -n "${usb_device}" ]; then
USB_DEVICE=dev${usb_device}
elif [ -n "${USB_DEVICE}" -a "${1}" ]; then
USB_DEVICE=dev$(( ${USB_DEVICE#dev} + 1 ))
fi
echo "${USB_DEVICE}"
fi
}
[ "USAGE: adb_wait [timeout]
Returns: waits until the device has returned for adb or optional timeout" ]
adb_wait() {
local start=`date +%s`
local duration=
local ret
if [ -n "${1}" -a -n "`which timeout`" ]; then
USB_DEVICE=`usb_devnum --next`
duration=`format_duration ${1}`
echo -n ". . . waiting ${duration}" ${ANDROID_SERIAL} ${USB_ADDRESS} ${USB_DEVICE} "${CR}" >&2
timeout --preserve-status --signal=KILL ${1} adb wait-for-device 2>/dev/null
ret=${?}
echo -n " ${CR}" >&2
else
adb wait-for-device
ret=${?}
fi
USB_DEVICE=`usb_devnum`
if [ 0 = ${ret} -a -n "${ACTIVE_SLOT}" ]; then
local active_slot=`get_active_slot`
if [ X"${ACTIVE_SLOT}" != X"${active_slot}" ]; then
LOG WARNING "Active slot changed from ${ACTIVE_SLOT} to ${active_slot}"
fi
fi
local end=`date +%s`
local diff_time=$(( ${end} - ${start} ))
local _print_time=${print_time}
if [ ${diff_time} -lt 15 ]; then
_print_time=false
fi
diff_time=`format_duration ${diff_time}`
if [ "${diff_time}" = "${duration}" ]; then
_print_time=false
fi
local reason=
if inAdb; then
reason=`get_property ro.boot.bootreason`
fi
case ${reason} in
reboot*)
reason=
;;
${EMPTY})
;;
*)
reason=" for boot reason ${reason}"
;;
esac
if ${_print_time} || [ -n "${reason}" ]; then
LOG INFO "adb wait duration ${diff_time}${reason}"
fi
return ${ret}
}
[ "USAGE: adb_user > /dev/stdout
Returns: the adb daemon user" ]
adb_user() {
adb_sh echo '${USER}' </dev/null
}
[ "USAGE: usb_status > stdout 2> stderr
Assumes referenced right after adb_wait or fastboot_wait failued.
If wait failed, check if device is in adb, recovery or fastboot mode
and report status strings like \"(USB stack borken?)\",
\"(In fastboot mode)\", \"(In recovery mode)\" or \"(in adb mode)\".
Additional diagnostics may be provided to the stderr output.
Returns: USB status string" ]
usb_status() {
if inFastboot; then
echo "(In fastboot mode)"
elif inRecovery; then
echo "(In recovery mode)"
elif inAdb; then
echo "(In adb mode `adb_user`)"
else
echo "(USB stack borken for ${USB_ADDRESS})"
if [ -n "`which usb_devnum`" ]; then
USB_DEVICE=`usb_devnum`
if [ -n "`which lsusb`" ]; then
if [ -n "${USB_DEVICE}" ]; then
echo "# lsusb -v -s ${USB_DEVICE#dev}"
local D=`lsusb -v -s ${USB_DEVICE#dev} 2>&1`
if [ -n "${D}" ]; then
echo "${D}"
else
lsusb -v
fi
else
echo "# lsusb -v (expected device missing)"
lsusb -v
fi
fi
fi >&2
fi
}
[ "USAGE: fastboot_wait [timeout]
Returns: waits until the device has returned for fastboot or optional timeout" ]
fastboot_wait() {
local ret
# fastboot has no wait-for-device, but it does an automatic
# wait and requires (even a nonsensical) command to do so.
if [ -n "${1}" -a -n "`which timeout`" ]; then
USB_DEVICE=`usb_devnum --next`
echo -n ". . . waiting `format_duration ${1}`" ${ANDROID_SERIAL} ${USB_ADDRESS} ${USB_DEVICE} "${CR}"
timeout --preserve-status --signal=KILL ${1} fastboot wait-for-device >/dev/null 2>/dev/null
ret=${?}
echo -n " ${CR}"
( exit ${ret} )
else
fastboot wait-for-device >/dev/null 2>/dev/null
fi ||
inFastboot
ret=${?}
USB_DEVICE=`usb_devnum`
if [ 0 = ${ret} -a -n "${ACTIVE_SLOT}" ]; then
local active_slot=`get_active_slot`
if [ X"${ACTIVE_SLOT}" != X"${active_slot}" ]; then
LOG WARNING "Active slot changed from ${ACTIVE_SLOT} to ${active_slot}"
fi
fi
return ${ret}
}
[ "USAGE: recovery_wait [timeout]
Returns: waits until the device has returned for recovery or optional timeout" ]
recovery_wait() {
local ret
if [ -n "${1}" -a -n "`which timeout`" ]; then
USB_DEVICE=`usb_devnum --next`
echo -n ". . . waiting `format_duration ${1}`" ${ANDROID_SERIAL} ${USB_ADDRESS} ${USB_DEVICE} "${CR}"
timeout --preserve-status --signal=KILL ${1} adb wait-for-recovery 2>/dev/null
ret=${?}
echo -n " ${CR}"
else
adb wait-for-recovery
ret=${?}
fi
USB_DEVICE=`usb_devnum`
if [ 0 = ${ret} -a -n "${ACTIVE_SLOT}" ]; then
local active_slot=`get_active_slot`
if [ X"${ACTIVE_SLOT}" != X"${active_slot}" ]; then
LOG WARNING "Active slot changed from ${ACTIVE_SLOT} to ${active_slot}"
fi
fi
return ${ret}
}
[ "any_wait [timeout]
Returns: waits until a device has returned or optional timeout" ]
any_wait() {
(
adb_wait ${1} &
adb_pid=${!}
fastboot_wait ${1} &
fastboot_pid=${!}
recovery_wait ${1} &
recovery_pid=${!}
wait -n
kill "${adb_pid}" "${fastboot_pid}" "${recovery_pid}"
) >/dev/null 2>/dev/null
inFastboot || inAdb || inRecovery
}
wait_for_screen_timeout=900
[ "USAGE: wait_for_screen [-n] [TIMEOUT]
-n - echo newline at exit
TIMEOUT - default `format_duration ${wait_for_screen_timeout}`" ]
wait_for_screen() {
if ! ${screen_wait}; then
adb_wait
return
fi
exit_function=true
if [ X"-n" = X"${1}" ]; then
exit_function=echo
shift
fi
timeout=${wait_for_screen_timeout}
if [ ${#} -gt 0 ]; then
timeout=${1}
shift
fi
counter=0
while true; do
if inFastboot; then
fastboot reboot
elif inAdb; then
if [ 0 != ${counter} ]; then
adb_wait
fi
if [ "1" = "`get_property sys.boot_completed`" ]; then
sleep 1
break
fi
fi
counter=$(( ${counter} + 1 ))
if [ ${counter} -gt ${timeout} ]; then
${exit_function}
LOG ERROR "wait_for_screen() timed out ($(format_duration ${timeout}))"
return 1
fi
sleep 1
done
${exit_function}
}
[ "USAGE: adb_root
NB: This can be flakey on devices due to USB state
Returns: true if device in root state" ]
adb_root() {
[ root != "`adb_user`" ] || return 0
adb root >/dev/null </dev/null 2>/dev/null
sleep 2
adb_wait ${ADB_WAIT} &&
[ root = "`adb_user`" ]
}
[ "USAGE: adb_unroot
NB: This can be flakey on devices due to USB state
Returns: true if device in un root state" ]
adb_unroot() {
[ root = "`adb_user`" ] || return 0
adb unroot >/dev/null </dev/null 2>/dev/null
sleep 2
adb_wait ${ADB_WAIT} &&
[ root != "`adb_user`" ]
}
[ "USAGE: fastboot_getvar var expected >/dev/stderr
Returns: true if var output matches expected" ]
fastboot_getvar() {
local O=`fastboot getvar ${1} 2>&1`
local ret=${?}
O="${O#< waiting for * >?}"
O="${O%%?Finished. Total time: *}"
if [ 0 -ne ${ret} ]; then
echo ${O} >&2
false
return
fi
if [ "${O}" != "${O#*FAILED}" ]; then
O="${1}: <empty>"
fi
if [ -n "${2}" -a "${1}: ${2}" != "${O}" ]; then
echo "${2} != ${O}"
false
return
fi >&2
echo ${O} >&2
}
[ "USAGE: get_active_slot >/dev/stdout
Returns: with a or b string reporting active slot" ]
get_active_slot() {
if inAdb || inRecovery; then
get_property ro.boot.slot_suffix | tr -d _
elif inFastboot; then
fastboot_getvar current-slot 2>&1 | sed -n 's/current-slot: //p'
else
false
fi
}
[ "USAGE: restore
Do nothing: should be redefined when necessary.
Returns: reverses configurations" ]
restore() {
true
}
[ "USAGE: test_duration >/dev/stderr
Prints the duration of the test
Returns: reports duration" ]
test_duration() {
if ${print_time}; then
LOG INFO "end $(date)"
[ -n "${start_time}" ] || return
end_time=`date +%s`
local diff_time=$(( ${end_time} - ${start_time} ))
LOG INFO "duration $(format_duration ${diff_time})"
fi
}
[ "USAGE: die [-d|-t <epoch>] [message] >/dev/stderr
If -d, or -t <epoch> argument is supplied, dump logcat.
Returns: exit failure, report status" ]
die() {
if [ X"-d" = X"${1}" ]; then
adb_logcat -b all -v nsec -d
shift
elif [ X"-t" = X"${1}" ]; then
if [ -n "${2}" ]; then
adb_logcat -b all -v nsec -t ${2}
else
adb_logcat -b all -v nsec -d
fi
shift 2
fi >&2
LOG FAILED "${@}"
exit 1
}
[ "USAGE: check_eq <lval> <rval> [--warning [message]]
Exits if (regex) lval mismatches rval.
Returns: true if lval matches rval" ]
check_eq() {
local lval="${1}"
local rval="${2}"
shift 2
if [[ "${rval}" =~ ^${lval}$ ]]; then
return 0
fi
local error=true
local logt=ERROR
if [ X"${1}" = X"--warning" ]; then
shift 1
error=false
logt=WARNING
fi
if [ $(( ${#lval} + ${#rval} )) -gt 40 ]; then
LOG "${logt}" "expected \"${lval}\"
${INDENT}got \"${rval}\""
else
LOG "${logt}" "expected \"${lval}\" got \"${rval}\""
fi
${error} && die "${*}"
[ -n "${*}" ] && LOG "${logt}" "${*}"
return 1
}
[ "USAGE: check_ne <lval> <rval> [--warning [message]]
Exits if (regex) lval matches rval.
Returns: true if lval mismatches rval" ]
check_ne() {
local lval="${1}"
local rval="${2}"
shift 2
if ! [[ "${rval}" =~ ^${lval}$ ]]; then
return 0
fi
local error=true
local logt=ERROR
if [ X"${1}" = X"--warning" ]; then
shift 1
error=false
logt=WARNING
fi
LOG "${logt}" "unexpected \"${rval}\""
${error} && die "${*}"
[ -n "${*}" ] && LOG "${logt}" "${*}"
return 1
}
[ "USAGE: join_with <delimiter> <strings>
Joins strings with delimiter" ]
join_with() {
if [ "${#}" -lt 2 ]; then
echo
return
fi
local delimiter="${1}"
local result="${2}"
shift 2
for element in "${@}"; do
result+="${delimiter}${element}"
done
echo "${result}"
}
[ "USAGE: skip_administrative_mounts < /proc/mounts
Filters out all administrative (eg: sysfs) mounts uninteresting to the test" ]
skip_administrative_mounts() {
local exclude_filesystems=(
"overlay" "tmpfs" "none" "sysfs" "proc" "selinuxfs" "debugfs" "bpf"
"binfmt_misc" "cg2_bpf" "pstore" "tracefs" "adb" "mtp" "ptp" "devpts"
"ramdumpfs" "binder" "securityfs" "functionfs" "rootfs" "fuse"
)
local exclude_devices=(
"\/sys\/kernel\/debug" "\/data\/media" "\/dev\/block\/loop[0-9]*"
"\/dev\/block\/vold\/[^ ]+"
"${exclude_filesystems[@]}"
)
local exclude_mount_points=(
"\/cache" "\/mnt\/scratch" "\/mnt\/vendor\/persist" "\/persist"
"\/metadata" "\/apex\/[^ ]+"
)
awk '$1 !~ /^('"$(join_with "|" "${exclude_devices[@]}")"')$/ &&
$2 !~ /^('"$(join_with "|" "${exclude_mount_points[@]}")"')$/ &&
$3 !~ /^('"$(join_with "|" "${exclude_filesystems[@]}")"')$/'
}
[ "USAGE: surgically_wipe_overlayfs
Surgically wipe any mounted overlayfs scratch files.
Returns: true if wiped anything" ]
surgically_wipe_overlayfs() {
local wiped_anything=false
for d in ${OVERLAYFS_BACKING}; do
if adb_su test -d "/${d}/overlay" </dev/null; then
LOG INFO "/${d}/overlay is setup, surgically wiping"
adb_su rm -rf "/${d}/overlay" </dev/null
wiped_anything=true
fi
done
${wiped_anything}
}
[ "USAGE: is_overlayfs_mounted [mountpoint]
Diagnostic output of overlayfs df lines to stderr.
Returns: true if overlayfs is mounted [on mountpoint]" ]
is_overlayfs_mounted() {
local df_output=$(adb_su df -k </dev/null)
local df_header_line=$(echo "${df_output}" | head -1)
# KISS (we do not support sub-mounts for system partitions currently)
local overlay_mounts=$(echo "${df_output}" | tail +2 |
grep -vE "[%] /(apex|system|vendor)/[^ ]+$" |
awk '$1 == "overlay" || $6 == "/mnt/scratch"')
if ! echo "${overlay_mounts}" | grep -q '^overlay '; then
return 1
fi >/dev/null 2>/dev/null
( echo "${df_header_line}"
echo "${overlay_mounts}"
) >&2
if [ "${#}" -gt 0 ] && ! ( echo "${overlay_mounts}" | grep -qE " ${1}\$" ); then
return 1
fi >/dev/null 2>/dev/null
return 0
}
##
## MAINLINE
##
HOSTOS=`uname`
GETOPTS="--alternative --unquoted
--longoptions help,serial:,colour,color,no-colour,no-color
--longoptions wait-adb:,wait-fastboot:
--longoptions wait-screen,wait-display
--longoptions no-wait-screen,no-wait-display
--longoptions gtest_print_time,print-time,no-print-time
--"
if [ "Darwin" = "${HOSTOS}" ]; then
GETOPTS=
USAGE="`echo \"${USAGE}\" |
sed 's/--color/ /g
1s/--help/-h/
s/--help/ /g
s/--no-wait-screen/ /g
s/--print-time/ /g
1s/--serial/-s/
s/--serial/ /g
s/--wait-adb/ /g
s/--wait-fastboot/ /g'`"
fi
OPTIONS=`getopt ${GETOPTS} "?a:cCdDf:hs:tT" ${*}` ||
( echo "${USAGE}" >&2 ; false ) ||
die "getopt failure"
set -- ${OPTIONS}
while [ ${#} -gt 0 ]; do
case ${1} in
-h | --help | -\?)
echo "${USAGE}" >&2
exit 0
;;
-s | --serial)
export ANDROID_SERIAL=${2}
shift
;;
-c | --color | --colour)
color=true
;;
-C | --no-color | --no-colour)
color=false
;;
-D | --no-wait-display | --no-wait-screen)
screen_wait=false
;;
-d | --wait-display | --wait-screen)
screen_wait=true
;;
-t | --print-time | --gtest_print_time)
print_time=true
;;
-T | --no-print-time)
print_time=false
;;
-a | --wait-adb)
ADB_WAIT=${2}
shift
;;
-f | --wait-fastboot)
FASTBOOT_WAIT=${2}
shift
;;
--)
shift
break
;;
-*)
echo "${USAGE}" >&2
die "${0}: error unknown option ${1}"
;;
*)
break
;;
esac
shift
done
if ${color}; then
RED="${ESCAPE}[31m"
GREEN="${ESCAPE}[32m"
YELLOW="${ESCAPE}[33m"
BLUE="${ESCAPE}[34m"
NORMAL="${ESCAPE}[0m"
fi
TMPDIR=
exit_handler() {
[ -n "${TMPDIR}" ] && rm -rf "${TMPDIR}"
local err=0
if ! restore; then
LOG ERROR "restore failed"
err=1
fi >&2
test_duration || true
if [ "${err}" != 0 ]; then
exit "${err}"
fi
}
trap 'exit_handler' EXIT
TMPDIR=$(mktemp -d)
if ${print_time}; then
LOG INFO "start $(date)"
fi
if [ -z "${ANDROID_SERIAL}" ]; then
inAdb || die "no device or more than one device in adb mode"
D=$(adb devices | awk '$2 == "device" { print $1; exit }')
[ -n "${D}" ] || die "cannot get device serial"
ANDROID_SERIAL="${D}"
fi
export ANDROID_SERIAL
inFastboot && die "device in fastboot mode"
inRecovery && die "device in recovery mode"
if ! inAdb; then
LOG WARNING "device not in adb mode"
adb_wait ${ADB_WAIT}
fi
inAdb || die "specified device not in adb mode"
[ "1" = "$(get_property ro.debuggable)" ] || die "device not a debug build"
[ "orange" = "$(get_property ro.boot.verifiedbootstate)" ] || die "device not bootloader unlocked"
################################################################################
# Collect characteristics of the device and report.
can_restore_verity=true
if [ "2" != "$(get_property partition.system.verified)" ]; then
LOG WARNING "device might not support verity"
can_restore_verity=false
fi
enforcing=true
if ! adb_su getenforce </dev/null | grep 'Enforcing' >/dev/null; then
LOG WARNING "device does not have sepolicy in enforcing mode"
enforcing=false
fi
USB_SERIAL=
if [ -n "${ANDROID_SERIAL}" -a "Darwin" != "${HOSTOS}" ]; then
USB_SERIAL="`find /sys/devices -name serial | grep usb || true`"
if [ -n "${USB_SERIAL}" ]; then
USB_SERIAL=`echo "${USB_SERIAL}" |
xargs grep -l ${ANDROID_SERIAL} || true`
fi
fi
USB_ADDRESS=
if [ -n "${USB_SERIAL}" ]; then
USB_ADDRESS=${USB_SERIAL%/serial}
USB_ADDRESS=usb${USB_ADDRESS##*/}
fi
USB_DEVICE=$(usb_devnum)
[ -z "${ANDROID_SERIAL}${USB_ADDRESS}${USB_DEVICE}" ] ||
LOG INFO "${ANDROID_SERIAL} ${USB_ADDRESS} ${USB_DEVICE}"
BUILD_DESCRIPTION=`get_property ro.build.description`
[ -z "${BUILD_DESCRIPTION}" ] ||
LOG INFO "${BUILD_DESCRIPTION}"
KERNEL_VERSION="`adb_su cat /proc/version </dev/null 2>/dev/null`"
[ -z "${KERNEL_VERSION}" ] ||
LOG INFO "${KERNEL_VERSION}"
ACTIVE_SLOT=`get_active_slot`
[ -z "${ACTIVE_SLOT}" ] ||
LOG INFO "active slot is ${ACTIVE_SLOT}"
# Acquire list of system partitions
FSTAB_SUFFIXES=(
"$(get_property ro.boot.fstab_suffix)"
"$(get_property ro.boot.hardware)"
"$(get_property ro.boot.hardware.platform)"
)
FSTAB_PATTERN='\.('"$(join_with "|" "${FSTAB_SUFFIXES[@]}")"')$'
FSTAB_FILE=$(adb_su ls -1 '/vendor/etc/fstab*' </dev/null |
grep -E "${FSTAB_PATTERN}" |
head -1)
# KISS (assume system partition mount point is "/<partition name>")
if [ -n "${FSTAB_FILE}" ]; then
PARTITIONS=$(adb_su grep -v "^[#${SPACE}${TAB}]" "${FSTAB_FILE}" |
skip_administrative_mounts |
awk '$1 ~ /^[^\/]+$/ && "/"$1 == $2 && $4 ~ /(^|,)ro(,|$)/ { print $1 }' |
sort -u |
tr '\n' ' ')
else
PARTITIONS="system vendor"
fi
# KISS (we do not support sub-mounts for system partitions currently)
# Ensure /system and /vendor mountpoints are in mounts list
MOUNTS=$(for i in system vendor ${PARTITIONS}; do
echo "/${i}"
done | sort -u | tr '\n' ' ')
LOG INFO "System Partitions list: ${PARTITIONS}"
# Report existing partition sizes
adb_sh ls -l /dev/block/by-name/ /dev/block/mapper/ </dev/null 2>/dev/null |
sed -n 's@.* \([^ ]*\) -> /dev/block/\([^ ]*\)$@\1 \2@p' |
while read name device; do
[ super = ${name} -o cache = ${name} ] ||
(
for i in ${PARTITIONS}; do
[ ${i} = ${name} -o ${i} = ${name%_[ab]} ] && exit
done
exit 1
) ||
continue
case ${device} in
sd*)
device=${device%%[0-9]*}/${device}
;;
esac
size=`adb_su cat /sys/block/${device}/size 2>/dev/null </dev/null` &&
size=$(( ${size} / 2 )) &&
LOG INFO "partition ${name} device ${device} size ${size}K"
done
restore() {
LOG INFO "restoring device"
inFastboot &&
fastboot reboot &&
adb_wait "${ADB_WAIT}" ||
true
if ! inAdb; then
LOG ERROR "expect adb device"
return 1
fi
adb_root || true
local reboot=false
if surgically_wipe_overlayfs; then
reboot=true
fi
if ${can_restore_verity}; then
if ! adb enable-verity; then
LOG ERROR "adb enable-verity"
return 1
fi
LOG INFO "restored verity"
reboot=true
fi >&2
if ${reboot}; then
adb_reboot
fi
}
# If reboot too soon after fresh flash, could trip device update failure logic
if ${screen_wait}; then
LOG INFO "waiting for screen to come up. Consider --no-wait-screen option"
fi
if ! wait_for_screen && ${screen_wait}; then
screen_wait=false
LOG WARNING "not healthy, no launcher, skipping wait for screen"
fi
################################################################################
LOG RUN "Checking current overlayfs status"
adb_wait || die "wait for device failed"
adb_root || die "adb root failed"
# We can not universally use adb enable-verity to ensure device is
# in a overlayfs disabled state since it can prevent reboot on
# devices that remount the physical content rather than overlayfs.
# So lets do our best to surgically wipe the overlayfs state without
# having to go through enable-verity transition.
if surgically_wipe_overlayfs; then
LOG WARNING "rebooting before test"
adb_reboot ||
die "lost device after reboot after overlay wipe $(usb_status)"
adb_root ||
die "lost device after elevation to root after wipe `usb_status`"
fi
is_overlayfs_mounted &&
die "overlay takeover unexpected at this phase"
overlayfs_needed=true
data_device=$(adb_sh awk '$2 == "/data" { print $1; exit }' /proc/mounts)
D=$(adb_sh grep " ro," /proc/mounts </dev/null |
grep -v "^${data_device}" |
skip_administrative_mounts |
awk '{ print $1 }' |
sed 's|/dev/root|/|' |
sort -u)
no_dedupe=true
for d in ${D}; do
adb_sh tune2fs -l $d </dev/null 2>&1 |
grep "Filesystem features:.*shared_blocks" >/dev/null &&
no_dedupe=false
done
D=$(adb_sh df -k ${D} </dev/null)
echo "${D}" >&2
if [ X"${D}" = X"${D##* 100[%] }" ] && ${no_dedupe} ; then
overlayfs_needed=false
# if device does not need overlays, then adb enable-verity will brick device
can_restore_verity=false
fi
LOG OK "no overlay present before setup"
################################################################################
# Precondition is overlayfs *not* setup.
LOG RUN "Testing adb disable-verity -R"
T=$(adb_date)
adb_su disable-verity -R >&2 ||
die -t "${T}" "disable-verity -R failed"
sleep 2
adb_wait "${ADB_WAIT}" ||
die "lost device after adb disable-verity -R $(usb_status)"
if [ "2" = "$(get_property partition.system.verified)" ]; then
LOG ERROR "partition.system.verified=$(get_property partition.system.verified)"
die "verity not disabled after adb disable-verity -R"
fi
if ${overlayfs_needed}; then
is_overlayfs_mounted ||
die -d "no overlay takeover after adb disable-verity -R"
LOG OK "overlay takeover after adb disable-verity -R"
fi
LOG OK "adb disable-verity -R"
################################################################################
LOG RUN "Checking kernel has overlayfs required patches"
adb_root || die "adb root"
if adb_test -d /sys/module/overlay ||
adb_sh grep -q "nodev${TAB}overlay" /proc/filesystems; then
LOG OK "overlay module present"
else
LOG INFO "overlay module not present"
fi
if is_overlayfs_mounted 2>/dev/null; then
if adb_test -f /sys/module/overlay/parameters/override_creds; then
LOG OK "overlay module supports override_creds"
else
case "$(adb_sh uname -r </dev/null)" in
4.[456789].* | 4.[1-9][0-9]* | [56789].*)
die "overlay module does not support override_creds"
;;
*)
LOG OK "overlay module uses caller's creds"
;;
esac
fi
fi
################################################################################
# Precondition is a verity-disabled device with overlayfs already setup.
LOG RUN "Testing raw remount commands"
adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null &&
die "/system is not RO"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null &&
die "/vendor is not RO"
T=$(adb_date)
adb_su mount -o remount,rw /vendor ||
die -t "${T}" "mount -o remount,rw /vendor"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null ||
die "/vendor is not RW after mount -o remount,rw"
LOG OK "mount -o remount,rw"
T=$(adb_date)
adb_su mount -o remount,ro /vendor ||
die -t "${T}" "mount -o remount,ro /vendor"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null &&
die "/vendor is not RO after mount -o remount,ro"
LOG OK "mount -o remount,ro"
T=$(adb_date)
adb_su remount vendor >&2 ||
die -t "${T}" "adb remount vendor"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null ||
die -t "${T}" "/vendor is not RW after adb remount vendor"
adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null &&
die -t "${T}" "/system is not RO after adb remount vendor"
LOG OK "adb remount vendor"
LOG INFO "Restoring device RO state and destroying overlayfs"
T=$(adb_date)
adb_su mount -o remount,ro /vendor ||
die -t "${T}" "mount -o remount,ro /vendor"
if surgically_wipe_overlayfs; then
adb_reboot ||
die "lost device after reboot after overlay wipe $(usb_status)"
fi
is_overlayfs_mounted &&
die "overlay takeover unexpected at this phase"
################################################################################
# Precondition is a verity-disabled device with overlayfs *not* setup.
LOG RUN "Testing adb remount performs overlayfs setup from scratch"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null &&
die "/vendor is not RO"
T=$(adb_date)
adb_su remount vendor >&2 ||
die -t "${T}" "adb remount vendor from scratch"
if ${overlayfs_needed}; then
is_overlayfs_mounted /vendor ||
die -t "${T}" "expected overlay takeover /vendor"
is_overlayfs_mounted /system 2>/dev/null &&
die -t "${T}" "unexpected overlay takeover /system"
fi
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null ||
die -t "${T}" "/vendor is not RW after adb remount vendor"
adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null &&
die -t "${T}" "/system is not RO after adb remount vendor"
LOG OK "adb remount from scratch"
################################################################################
# Precondition is overlayfs partially setup by previous test.
LOG RUN "Testing adb remount -R"
T=$(adb_date)
adb_su remount -R </dev/null >&2 ||
die -t "${T}" "adb remount -R failed"
sleep 2
adb_wait "${ADB_WAIT}" ||
die "lost device after adb remount -R $(usb_status)"
if [ "2" = "$(get_property partition.system.verified)" ]; then
LOG ERROR "partition.system.verified=$(get_property partition.system.verified)"
die "verity not disabled after adb remount -R"
fi
if ${overlayfs_needed}; then
is_overlayfs_mounted /system ||
die -d "expected overlay takeover /system"
is_overlayfs_mounted /vendor 2>/dev/null ||
die -d "expected overlay takeover /vendor"
LOG OK "overlay takeover after adb remount -R"
fi
LOG OK "adb remount -R"
# For devices using overlayfs, remount -R should reboot after overlayfs setup.
# For legacy device, manual reboot to ensure device clean state.
if ! ${overlayfs_needed}; then
LOG WARNING "Reboot to RO (device doesn't use overlayfs)"
adb_reboot ||
die "lost device after reboot to RO $(usb_status)"
fi
################################################################################
# Precondition is a verity-disabled device with overlayfs already setup.
LOG RUN "Testing adb remount RW"
# Feed log with selinux denials as baseline before overlays
adb_unroot
adb_sh find ${MOUNTS} </dev/null >/dev/null 2>/dev/null || true
adb_root
adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null &&
die "/system is not RO"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null &&
die "/vendor is not RO"
T=$(adb_date)
adb remount >&2 ||
die -t "${T}" "adb remount"
adb_sh grep -qE " (/system|/) [^ ]* rw," /proc/mounts </dev/null ||
die -t "${T}" "/system is not RW"
adb_sh grep -q " /vendor [^ ]* rw," /proc/mounts </dev/null ||
die -t "${T}" "/vendor is not RW"
scratch_on_super=false
if ${overlayfs_needed}; then
is_overlayfs_mounted /system ||
die -t "${T}" "expected overlay to takeover /system after remount"
# Collect information about the scratch device if we have one
M=$(adb_sh cat /proc/mounts </dev/null |
awk '$2 == "/mnt/scratch" { print $1, $3; exit }')
if [ -n "${M}" ]; then
scratch_device=$(echo "${M}" | awk '{ print $1 }')
scratch_filesystem=$(echo "${M}" | awk '{ print $2 }')
scratch_size=$(adb_sh df -k "${scratch_device}" </dev/null |
tail +2 | head -1 | awk '{ print $2 }')
[ -z "${scratch_size}" ] && die "cannot get size of scratch device (${scratch_device})"
# Detect scratch partition backed by super?
for b in "/dev/block/by-name/super"{,_${ACTIVE_SLOT}}; do
if adb_test -e "${b}"; then
device=$(adb_su realpath "${b}")
D=$(adb_su stat -c '0x%t 0x%T' "${device}")
major=$(echo "${D}" | awk '{ print $1 }')
minor=$(echo "${D}" | awk '{ print $2 }')
super_devt=$(( major )):$(( minor ))
if adb_su dmctl table scratch | tail +2 | grep -q -w "${super_devt}"; then
scratch_on_super=true
fi
break
fi
done
if ${scratch_on_super}; then
LOG INFO "using dynamic scratch partition on super"
else
LOG INFO "using dynamic scratch partition on /data (VAB device)"
fi
LOG INFO "scratch device ${scratch_device} filesystem ${scratch_filesystem} size ${scratch_size}KiB"
else
LOG INFO "cannot find any scratch device mounted on /mnt/scratch, using scratch on /cache"
fi
for d in ${OVERLAYFS_BACKING}; do
if adb_test -d /${d}/overlay/system/upper; then
LOG INFO "/${d}/overlay is setup"
fi
done
data_device=$(adb_sh awk '$2 == "/data" { print $1; exit }' /proc/mounts)
# KISS (we do not support sub-mounts for system partitions currently)
adb_sh grep "^overlay " /proc/mounts </dev/null |
grep -vE "^overlay.* /(apex|system|vendor)/[^ ]" |
grep " overlay ro," &&
die "expected overlay to be RW after remount"
adb_sh grep -v noatime /proc/mounts </dev/null |
grep -v "^${data_device}" |
skip_administrative_mounts |
grep -v ' ro,' &&
die "mounts are not noatime"
D=$(adb_sh grep " rw," /proc/mounts </dev/null |
grep -v "^${data_device}" |
skip_administrative_mounts |
awk '{ print $1 }' |
sed 's|/dev/root|/|' |
sort -u)
if [ -n "${D}" ]; then
adb_sh df -k ${D} </dev/null |
sed -e 's/^Filesystem /Filesystem (rw) /'
fi >&2
for d in ${D}; do
if adb_sh tune2fs -l "${d}" </dev/null 2>&1 | grep -q "Filesystem features:.*shared_blocks" ||
adb_sh df -k "${d}" | grep -q " 100% "; then
die "remount overlayfs missed a spot (rw)"
fi
done
else
is_overlayfs_mounted && die -t "${T}" "unexpected overlay takeover"
fi
LOG OK "adb remount RW"
################################################################################
LOG RUN "push content to ${MOUNTS}"
adb_root || die "adb root"
A="Hello World! $(date)"
for i in ${MOUNTS} /system/priv-app; do
echo "${A}" | adb_sh cat - ">${i}/hello"
B="`adb_cat ${i}/hello`" ||
die "${i#/} hello"
check_eq "${A}" "${B}" ${i} before reboot
done
SYSTEM_INO=`adb_sh stat --format=%i /system/hello </dev/null`
VENDOR_INO=`adb_sh stat --format=%i /vendor/hello </dev/null`
check_ne "${SYSTEM_INO}" "${VENDOR_INO}" vendor and system inode
# Edit build.prop and check if properties are updated.
system_build_prop_original="${TMPDIR}/system_build.prop.original"
system_build_prop_modified="${TMPDIR}/system_build.prop.modified"
system_build_prop_fromdevice="${TMPDIR}/system_build.prop.fromdevice"
adb pull /system/build.prop "${system_build_prop_original}" >/dev/null ||
die "adb pull /system/build.prop"
# Prepend with extra newline in case the original file doesn't end with a newline.
cat "${system_build_prop_original}" - <<EOF >"${system_build_prop_modified}"
# Properties added by adb remount test
test.adb.remount.system.build.prop=true
EOF
adb push "${system_build_prop_modified}" /system/build.prop >/dev/null ||
die "adb push /system/build.prop"
adb pull /system/build.prop "${system_build_prop_fromdevice}" >/dev/null ||
die "adb pull /system/build.prop"
diff "${system_build_prop_modified}" "${system_build_prop_fromdevice}" >/dev/null ||
die "/system/build.prop differs from pushed content"
################################################################################
LOG RUN "reboot to confirm content persistent"
fixup_from_recovery() {
inRecovery || return 1
LOG ERROR "Device in recovery"
adb reboot </dev/null
adb_wait ${ADB_WAIT}
}
adb_reboot ||
fixup_from_recovery ||
die "reboot after override content added failed `usb_status`"
if ${overlayfs_needed}; then
is_overlayfs_mounted ||
die -d "overlay takeover failed after reboot"
adb_su sed -n '1,/overlay \/system/p' /proc/mounts </dev/null |
skip_administrative_mounts |
grep -v ' \(erofs\|squashfs\|ext4\|f2fs\|vfat\) ' &&
LOG WARNING "overlay takeover after first stage init" ||
LOG OK "overlay takeover in first stage init"
fi
if ${enforcing}; then
adb_unroot ||
die "device not in unroot'd state"
B="`adb_cat /vendor/hello 2>&1`"
check_eq "cat: /vendor/hello: Permission denied" "${B}" vendor after reboot w/o root
LOG OK "/vendor content correct MAC after reboot"
# Feed unprivileged log with selinux denials as a result of overlays
wait_for_screen
adb_sh find ${MOUNTS} </dev/null >/dev/null 2>/dev/null || true
fi
# If overlayfs has a nested security problem, this will fail.
adb_sh ls /system >/dev/null || die "ls /system"
adb_test -d /system/priv-app || die "[ -d /system/priv-app ]"
B="`adb_cat /system/priv-app/hello`"
check_eq "${A}" "${B}" /system/priv-app after reboot
# Only root can read vendor if sepolicy permissions are as expected.
adb_root || die "adb root"
for i in ${MOUNTS}; do
B="`adb_cat ${i}/hello`"
check_eq "${A}" "${B}" ${i#/} after reboot
LOG OK "${i} content remains after reboot"
done
check_eq "${SYSTEM_INO}" "`adb_sh stat --format=%i /system/hello </dev/null`" system inode after reboot
check_eq "${VENDOR_INO}" "`adb_sh stat --format=%i /vendor/hello </dev/null`" vendor inode after reboot
# Feed log with selinux denials as a result of overlays
adb_sh find ${MOUNTS} </dev/null >/dev/null 2>/dev/null || true
# Check if the updated build.prop is persistent after reboot.
check_eq "true" "$(get_property 'test.adb.remount.system.build.prop')" "load modified build.prop"
adb pull /system/build.prop "${system_build_prop_fromdevice}" >/dev/null ||
die "adb pull /system/build.prop"
diff "${system_build_prop_modified}" "${system_build_prop_fromdevice}" >/dev/null ||
die "/system/build.prop differs from pushed content"
LOG OK "/system/build.prop content remains after reboot"
################################################################################
LOG RUN "flash vendor, and confirm vendor override disappears"
is_bootloader_fastboot=true
# virtual device?
case "$(get_property ro.product.vendor.device)" in
vsoc_* | emulator_* | emulator64_*)
is_bootloader_fastboot=false
;;
esac
is_userspace_fastboot=false
if ! ${is_bootloader_fastboot}; then
LOG WARNING "does not support fastboot flash, skipping"
else
wait_for_screen
adb_root || die "adb root"
VENDOR_DEVICE_CANDIDATES=(
"/dev/block/mapper/vendor"{_${ACTIVE_SLOT},}
"/dev/block/by-name/vendor"{_${ACTIVE_SLOT},}
)
for b in "${VENDOR_DEVICE_CANDIDATES[@]}"; do
if adb_test -e "${b}"; then
adb pull "${b}" "${TMPDIR}/vendor.img" || die "adb pull ${b}"
LOG INFO "pulled ${b} from device as vendor.img"
break
fi
done
[ -f "${TMPDIR}/vendor.img" ] ||
die "cannot find block device of vendor partition"
avc_check
adb reboot fastboot </dev/null ||
die "fastbootd not supported (wrong adb in path?)"
any_wait ${ADB_WAIT} &&
inFastboot ||
die "reboot into fastboot to flash vendor `usb_status` (bad bootloader?)"
fastboot flash vendor "${TMPDIR}/vendor.img" ||
( fastboot reboot && false) ||
die "fastboot flash vendor"
LOG OK "flashed vendor"
fastboot_getvar is-userspace yes &&
is_userspace_fastboot=true
if ${scratch_on_super}; then
fastboot_getvar partition-type:scratch raw ||
die "fastboot cannot see parameter partition-type:scratch"
fastboot_getvar has-slot:scratch no ||
die "fastboot cannot see parameter has-slot:scratch"
fastboot_getvar is-logical:scratch yes ||
die "fastboot cannot see parameter is-logical:scratch"
LOG INFO "expect fastboot erase scratch to fail"
fastboot erase scratch && die "fastboot can erase scratch"
LOG INFO "expect fastboot format scratch to fail"
fastboot format scratch && die "fastboot can format scratch"
fi
fastboot reboot || die "cannot reboot out of fastboot"
LOG INFO "reboot from fastboot"
adb_wait ${ADB_WAIT} ||
fixup_from_recovery ||
die "cannot reboot after flash vendor $(usb_status)"
if ${overlayfs_needed}; then
is_overlayfs_mounted /system ||
die "overlay /system takeover after flash vendor"
if is_overlayfs_mounted /vendor 2>/dev/null; then
if ${is_userspace_fastboot}; then
die "overlay supposed to be minus /vendor takeover after flash vendor"
else
LOG WARNING "fastbootd missing required to invalidate, ignoring a failure"
LOG WARNING "overlay supposed to be minus /vendor takeover after flash vendor"
fi
fi
fi
check_eq "${A}" "$(adb_cat /system/hello)" "/system content after flash vendor"
check_eq "${SYSTEM_INO}" "$(adb_sh stat --format=%i /system/hello </dev/null)" "system inode after flash vendor"
adb_sh ls /system >/dev/null || die "ls /system"
adb_test -d /system/priv-app || die "[ -d /system/priv-app ]"
check_eq "${A}" "$(adb_cat /system/priv-app/hello)" "/system/priv-app content after flash vendor"
adb_root || die "adb root"
if adb_test -e /vendor/hello; then
if ${is_userspace_fastboot} || ! ${overlayfs_needed}; then
die "vendor content after flash vendor"
else
LOG WARNING "fastbootd missing required to invalidate, ignoring a failure"
LOG WARNING "vendor content after flash vendor"
fi
fi
LOG OK "vendor override destroyed after flash verdor"
fi >&2
wait_for_screen
################################################################################
LOG RUN "Clean up test content"
adb_root || die "adb root"
T=$(adb_date)
D=$(adb remount 2>&1) ||
die -t "${T}" "adb remount"
echo "${D}" >&2
if [[ "${D}" =~ [Rr]eboot ]]; then
LOG OK "adb remount calls for a reboot after partial flash"
# but we don't really want to, since rebooting just recreates the already tore
# down vendor overlay.
fi
for i in ${MOUNTS} /system/priv-app; do
adb_sh rm "${i}/hello" 2>/dev/null || true
adb_test -e "${i}/hello" &&
die -t "${T}" "/${i}/hello lingers after rm"
done
################################################################################
if ${is_bootloader_fastboot} && ${scratch_on_super}; then
LOG RUN "test fastboot flash to scratch recovery"
avc_check
adb reboot fastboot </dev/null ||
die "Reboot into fastbootd"
img="${TMPDIR}/adb-remount-test-${$}.img"
dd if=/dev/zero of=${img} bs=4096 count=16 2>/dev/null &&
fastboot_wait ${FASTBOOT_WAIT} ||
die "reboot into fastboot to flash scratch `usb_status`"
fastboot flash --force scratch ${img}
err=${?}
fastboot reboot ||
die "can not reboot out of fastboot"
[ 0 -eq ${err} ] ||
die "fastboot flash scratch"
adb_wait ${ADB_WAIT} &&
adb_root ||
die "did not reboot after flashing empty scratch $(usb_status)"
T=`adb_date`
D=`adb disable-verity 2>&1`
err=${?}
if [ X"${D}" != "${D%?Now reboot your device for settings to take effect*}" ]
then
LOG WARNING "adb disable-verity requires a reboot after partial flash"
adb_reboot &&
adb_root ||
die "failed to reboot"
T=`adb_date`
D="${D}
`adb disable-verity 2>&1`"
err=${?}
fi
echo "${D}" >&2
[ ${err} = 0 ] &&
[ X"${D}" = X"${D##*setup failed}" ] &&
[ X"${D}" != X"${D##*[Uu]sing overlayfs}" ] &&
LOG OK "recreated scratch" ||
die -t ${T} "setup for overlayfs"
adb remount >&2 ||
die -t ${T} "remount failed"
fi
LOG PASSED "adb remount test"
Reference in New Issue View Git Blame Copy Permalink