fs_mgr_overlayfs: Remove support for physical scratch (9032c008) · Commits · e / os / android_system_core

fs_mgr/fs_mgr_overlayfs.cpp

+7 −39

Original line number	Diff line number	Diff line
		@@ -850,28 +850,6 @@ bool MountScratch(const std::string& device_path, bool readonly = false) {
		const std::string kMkF2fs("/system/bin/make_f2fs");
		const std::string kMkExt4("/system/bin/mke2fs");

		// Note: we do not check access() here except for the super partition, since
		// in first-stage init we wouldn't have registed by-name symlinks for "other"
		// partitions that won't be mounted.
		static std::string GetPhysicalScratchDevice() {
		auto slot_number = fs_mgr_overlayfs_slot_number();
		auto super_device = fs_mgr_overlayfs_super_device(slot_number);
		auto path = fs_mgr_overlayfs_super_device(slot_number == 0);
		if (super_device != path) {
		return path;
		}
		if (fs_mgr_access(super_device)) {
		// Do not try to use system_other on a DAP device.
		return "";
		}

		auto other_slot = fs_mgr_get_other_slot_suffix();
		if (!other_slot.empty()) {
		return kPhysicalDevice + "system" + other_slot;
		}
		return "";
		}

		// Note: The scratch partition of DSU is managed by gsid, and should be initialized during
		// first-stage-mount. Just check if the DM device for DSU scratch partition is created or not.
		static std::string GetDsuScratchDevice() {
		@@ -908,8 +886,7 @@ static std::string GetBootScratchDevice() {
		return device;
		}

		// There is no dynamic scratch, so try and find a physical one.
		return GetPhysicalScratchDevice();
		return "";
		}

		bool MakeScratchFilesystem(const std::string& scratch_device) {
		@@ -1112,7 +1089,7 @@ static bool CreateScratchOnData(std::string* scratch_device, bool* partition_exi
		return true;
		}

		static bool CanUseSuperPartition(const Fstab& fstab, bool* is_virtual_ab) {
		static bool CanUseSuperPartition(const Fstab& fstab) {
		auto slot_number = fs_mgr_overlayfs_slot_number();
		auto super_device = fs_mgr_overlayfs_super_device(slot_number);
		if (!fs_mgr_rw_access(super_device) \|\| !fs_mgr_overlayfs_has_logical(fstab)) {
		@@ -1122,7 +1099,6 @@ static bool CanUseSuperPartition(const Fstab& fstab, bool* is_virtual_ab) {
		if (!metadata) {
		return false;
		}
		*is_virtual_ab = !!(metadata->header.flags & LP_HEADER_FLAG_VIRTUAL_AB_DEVICE);
		return true;
		}

		@@ -1135,23 +1111,15 @@ bool fs_mgr_overlayfs_create_scratch(const Fstab& fstab, std::string* scratch_de
		return *partition_exists;
		}

		// Try a physical partition first.
		*scratch_device = GetPhysicalScratchDevice();
		if (!scratch_device->empty() && fs_mgr_rw_access(*scratch_device)) {
		*partition_exists = true;
		return true;
		}

		// If that fails, see if we can land on super.
		bool is_virtual_ab;
		if (CanUseSuperPartition(fstab, &is_virtual_ab)) {
		// Try ImageManager on /data first.
		bool can_use_data = false;
		if (is_virtual_ab && FilesystemHasReliablePinning("/data", &can_use_data) && can_use_data) {
		if (FilesystemHasReliablePinning("/data", &can_use_data) && can_use_data) {
		return CreateScratchOnData(scratch_device, partition_exists);
		}
		// If that fails, see if we can land on super.
		if (CanUseSuperPartition(fstab)) {
		return CreateDynamicScratch(scratch_device, partition_exists);
		}

		return false;
		}

fs_mgr/tests/adb-remount-test.sh

+53 −61

Original line number	Diff line number	Diff line
		@@ -1241,40 +1241,45 @@ adb_sh grep -qE " (/system\|/) [^ ]* rw," /proc/mounts </dev/null \|\|
		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 \|\| die -t "${T}" "expected overlay takeover"
		else
		is_overlayfs_mounted && die -t "${T}" "unexpected overlay takeover"
		fi
		is_overlayfs_mounted /system \|\|
		die -t "${T}" "expected overlay to takeover /system after remount"

		# If scratch_partition && uses_dynamic_scratch, then scratch is on super.
		# If scratch_partition && !uses_dynamic_scratch, then scratch is super_other, system_other.
		# If !scratch_partition, then scratch is on /data via image_manager.
		uses_dynamic_scratch=false
		scratch_partition=
		virtual_ab=$(get_property ro.virtual_ab.enabled)
		if ${overlayfs_needed}; then
		# 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 }')
		[ -z "${M}" ] && die "cannot find any scratch device mounted on /mnt/scratch"

		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})"

		if [ -n "${virtual_ab}" ]; then
		LOG INFO "using dynamic scratch partition on /data (VAB device)"
		elif [[ "${scratch_device}" == /dev/block/by-name/* ]]; then
		scratch_partition="${scratch_device##/dev/block/by-name/}"
		LOG INFO "using physical scratch partition ${scratch_partition}"
		else
		uses_dynamic_scratch=true
		scratch_partition=scratch
		# 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
		@@ -1283,8 +1288,6 @@ if ${overlayfs_needed}; then
		done

		data_device=$(adb_sh awk '$2 == "/data" { print $1; exit }' /proc/mounts)
		is_overlayfs_mounted /system 2>/dev/null \|\|
		die -t "${T}" "expected overlay to takeover /system after remount"
		# 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)/[^ ]" \|
		@@ -1312,6 +1315,8 @@ if ${overlayfs_needed}; 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"
		@@ -1455,31 +1460,18 @@ else

		fastboot_getvar is-userspace yes &&
		is_userspace_fastboot=true
		# check ${scratch_partition} via fastboot
		if [ -n "${scratch_partition}" ]; then
		fastboot_getvar partition-type:${scratch_partition} raw \|\|
		( fastboot reboot && false) \|\|
		die "fastboot can not see ${scratch_partition} parameters"
		if ${uses_dynamic_scratch}; then
		fastboot_getvar has-slot:${scratch_partition} no &&
		fastboot_getvar is-logical:${scratch_partition} yes \|\|
		( fastboot reboot && false) \|\|
		die "fastboot can not see ${scratch_partition} parameters"
		LOG INFO "expect fastboot erase ${scratch_partition} to fail"
		fastboot erase ${scratch_partition} &&
		( fastboot reboot \|\| true) &&
		die "fastboot can erase ${scratch_partition}"
		else
		fastboot_getvar is-logical:${scratch_partition} no \|\|
		( fastboot reboot && false) \|\|
		die "fastboot can not see ${scratch_partition} parameters"
		fastboot reboot-bootloader \|\|
		die "fastboot reboot bootloader"
		fi
		LOG INFO "expect fastboot format ${scratch_partition} to fail"
		fastboot format ${scratch_partition} &&
		( fastboot reboot \|\| true) &&
		die "fastboot can format ${scratch_partition}"

		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"
		@@ -1539,9 +1531,9 @@ for i in ${MOUNTS} /system/priv-app; do
		done

		################################################################################
		if ${is_bootloader_fastboot} && [ -n "${scratch_partition}" ]; then
		if ${is_bootloader_fastboot} && ${scratch_on_super}; then

		LOG RUN "test fastboot flash to ${scratch_partition} recovery"
		LOG RUN "test fastboot flash to scratch recovery"

		avc_check
		adb reboot fastboot </dev/null \|\|
		@@ -1550,15 +1542,15 @@ if ${is_bootloader_fastboot} && [ -n "${scratch_partition}" ]; then
		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_partition} ${img}
		fastboot flash --force scratch ${img}
		err=${?}
		fastboot reboot \|\|
		die "can not reboot out of fastboot"
		[ 0 -eq ${err} ] \|\|
		die "fastboot flash ${scratch_partition}"
		die "fastboot flash scratch"
		adb_wait ${ADB_WAIT} &&
		adb_root \|\|
		die "did not reboot after flashing empty ${scratch_partition} `usb_status`"
		die "did not reboot after flashing empty scratch $(usb_status)"
		T=`adb_date`
		D=`adb disable-verity 2>&1`
		err=${?}
		@@ -1578,7 +1570,7 @@ if ${is_bootloader_fastboot} && [ -n "${scratch_partition}" ]; then
		[ ${err} = 0 ] &&
		[ X"${D}" = X"${D##*setup failed}" ] &&
		[ X"${D}" != X"${D##*[Uu]sing overlayfs}" ] &&
		LOG OK "${scratch_partition} recreated" \|\|
		LOG OK "recreated scratch" \|\|
		die -t ${T} "setup for overlayfs"
		adb remount >&2 \|\|
		die -t ${T} "remount failed"