Merge changes I7a2dd830,I6ce43725,I5fc2f370,Ibc2e14bd,Idf213800, ... am: c620f4a1b8 am: 38ab1b9ec0 (9a4276e4) · Commits · e / os / android_system_core

fs_mgr/Android.bp

+32 −0

Original line number	Diff line number	Diff line
		@@ -111,3 +111,35 @@ cc_library_static {
		"libgsi_headers",
		],
		}

		cc_binary {
		name: "remount",
		defaults: ["fs_mgr_defaults"],
		static_libs: [
		"libavb_user",
		],
		shared_libs: [
		"libbootloader_message",
		"libbase",
		"libcrypto",
		"libfec",
		"libfs_mgr",
		],
		header_libs: [
		"libcutils_headers",
		],
		srcs: [
		"fs_mgr_remount.cpp",
		],
		cppflags: [
		"-DALLOW_ADBD_DISABLE_VERITY=0",
		],
		product_variables: {
		debuggable: {
		cppflags: [
		"-UALLOW_ADBD_DISABLE_VERITY",
		"-DALLOW_ADBD_DISABLE_VERITY=1",
		],
		},
		},
		}

fs_mgr/fs_mgr_remount.cpp

0 → 100644

+348 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#include <errno.h>
		#include <getopt.h>
		#include <libavb_user/libavb_user.h>
		#include <stdio.h>
		#include <sys/mount.h>
		#include <sys/types.h>
		#include <sys/vfs.h>
		#include <unistd.h>

		#include <string>
		#include <utility>
		#include <vector>

		#include <android-base/file.h>
		#include <android-base/logging.h>
		#include <android-base/properties.h>
		#include <android-base/strings.h>
		#include <bootloader_message/bootloader_message.h>
		#include <cutils/android_reboot.h>
		#include <fec/io.h>
		#include <fs_mgr_overlayfs.h>
		#include <fs_mgr_priv.h>
		#include <fstab/fstab.h>

		namespace {

		[[noreturn]] void usage(int exit_status) {
		LOG(INFO) << getprogname()
		<< " [-h] [-R] [-T fstab_file]\n"
		"\t-h --help\tthis help\n"
		"\t-R --reboot\tdisable verity & reboot to facilitate remount\n"
		"\t-T --fstab\tcustom fstab file location\n"
		"\n"
		"Remount all partitions read-write.\n"
		"-R notwithstanding, verity must be disabled.";

		::exit(exit_status);
		}

		bool remountable_partition(const android::fs_mgr::FstabEntry& entry) {
		if (entry.fs_mgr_flags.vold_managed) return false;
		if (entry.fs_mgr_flags.recovery_only) return false;
		if (entry.fs_mgr_flags.slot_select_other) return false;
		if (!(entry.flags & MS_RDONLY)) return false;
		if (entry.fs_type == "vfat") return false;
		return true;
		}

		const std::string system_mount_point(const android::fs_mgr::FstabEntry& entry) {
		if (entry.mount_point == "/") return "/system";
		return entry.mount_point;
		}

		const android::fs_mgr::FstabEntry* is_wrapped(const android::fs_mgr::Fstab& overlayfs_candidates,
		const android::fs_mgr::FstabEntry& entry) {
		auto mount_point = system_mount_point(entry);
		auto it = std::find_if(overlayfs_candidates.begin(), overlayfs_candidates.end(),
		[&mount_point](const auto& entry) {
		return android::base::StartsWith(mount_point,
		system_mount_point(entry) + "/");
		});
		if (it == overlayfs_candidates.end()) return nullptr;
		return &(*it);
		}

		void try_unmount_bionic(android::fs_mgr::Fstab* mounts) {
		static constexpr const char* kBionic = "/bionic";

		auto entry = GetEntryForMountPoint(mounts, kBionic);
		if (!entry) return;

		struct statfs buf;
		if (::statfs(kBionic, &buf) == -1) {
		PLOG(ERROR) << "statfs of " << kBionic;
		return;
		}
		if (buf.f_flags & MS_RDONLY) {
		// /bionic is on a read-only partition; can happen for
		// non-system-as-root-devices. Don' try to unmount.
		return;
		}
		fs_mgr_set_blk_ro(entry->blk_device, false);
		if (::mount(entry->blk_device.c_str(), entry->mount_point.c_str(), entry->fs_type.c_str(),
		MS_REMOUNT, nullptr) == -1) {
		PLOG(ERROR) << "remount of " << kBionic;
		}
		}

		void MyLogger(android::base::LogId id, android::base::LogSeverity severity, const char* tag,
		const char* file, unsigned int line, const char* message) {
		static const char log_characters[] = "VD\0WEFF";
		if (severity < sizeof(log_characters)) {
		auto severity_char = log_characters[severity];
		if (severity_char) fprintf(stderr, "%c ", severity_char);
		}
		fprintf(stderr, "%s\n", message);

		static auto logd = android::base::LogdLogger();
		logd(id, severity, tag, file, line, message);
		}

		[[noreturn]] void reboot(bool dedupe) {
		if (dedupe) {
		LOG(INFO) << "The device will now reboot to recovery and attempt un-deduplication.";
		} else {
		LOG(INFO) << "Successfully disabled verity\nrebooting device";
		}
		::sync();
		android::base::SetProperty(ANDROID_RB_PROPERTY, dedupe ? "reboot,recovery" : "reboot,remount");
		::sleep(60);
		::exit(0); // SUCCESS
		}

		} // namespace

		int main(int argc, char* argv[]) {
		android::base::InitLogging(argv, MyLogger);

		enum {
		SUCCESS,
		NOT_USERDEBUG,
		BADARG,
		NOT_ROOT,
		NO_FSTAB,
		VERITY_PARTITION,
		BAD_OVERLAY,
		NO_MOUNTS,
		REMOUNT_FAILED,
		} retval = SUCCESS;

		// If somehow this executable is delivered on a "user" build, it can
		// not function, so providing a clear message to the caller rather than
		// letting if fall through and provide a lot of confusing failure messages.
		if (!ALLOW_ADBD_DISABLE_VERITY \|\| (android::base::GetProperty("ro.debuggable", "0") != "1")) {
		LOG(ERROR) << "only functions on userdebug or eng builds";
		return NOT_USERDEBUG;
		}

		const char* fstab_file = nullptr;
		auto can_reboot = false;

		struct option longopts[] = {
		{"fstab", required_argument, nullptr, 'T'},
		{"help", no_argument, nullptr, 'h'},
		{"reboot", no_argument, nullptr, 'R'},
		{0, 0, nullptr, 0},
		};
		for (int opt; (opt = ::getopt_long(argc, argv, "hRT:", longopts, nullptr)) != -1;) {
		switch (opt) {
		case 'R':
		can_reboot = true;
		break;
		case 'T':
		if (fstab_file) {
		LOG(ERROR) << "Cannot supply two fstabs: -T " << fstab_file << " -T" << optarg;
		usage(BADARG);
		}
		fstab_file = optarg;
		break;
		default:
		LOG(ERROR) << "Bad Argument -" << char(opt);
		usage(BADARG);
		break;
		case 'h':
		usage(SUCCESS);
		break;
		}
		}

		if (argc > optind) {
		LOG(ERROR) << "Bad Argument " << argv[optind];
		usage(BADARG);
		}

		// Make sure we are root.
		if (::getuid() != 0) {
		LOG(ERROR) << "must be run as root";
		return NOT_ROOT;
		}

		// Read the selected fstab.
		android::fs_mgr::Fstab fstab;
		auto fstab_read = false;
		if (fstab_file) {
		fstab_read = android::fs_mgr::ReadFstabFromFile(fstab_file, &fstab);
		} else {
		fstab_read = android::fs_mgr::ReadDefaultFstab(&fstab);
		}
		if (!fstab_read \|\| fstab.empty()) {
		PLOG(ERROR) << "Failed to read fstab";
		return NO_FSTAB;
		}

		// Generate the list of supported overlayfs mount points.
		auto overlayfs_candidates = fs_mgr_overlayfs_candidate_list(fstab);

		// Generate the all remountable partitions sub-list
		android::fs_mgr::Fstab partitions;
		for (auto const& entry : fstab) {
		if (!remountable_partition(entry)) continue;
		if (overlayfs_candidates.empty() \|\|
		GetEntryForMountPoint(&overlayfs_candidates, entry.mount_point) \|\|
		(is_wrapped(overlayfs_candidates, entry) == nullptr)) {
		partitions.emplace_back(entry);
		}
		}

		// Check verity and optionally setup overlayfs backing.
		auto reboot_later = false;
		for (auto it = partitions.begin(); it != partitions.end();) {
		auto& entry = *it;
		auto& mount_point = entry.mount_point;
		if (fs_mgr_is_verity_enabled(entry)) {
		LOG(WARNING) << "Verity enabled on " << mount_point;
		if (can_reboot &&
		(android::base::GetProperty("ro.boot.vbmeta.devices_state", "") != "locked")) {
		if (AvbOps* ops = avb_ops_user_new()) {
		auto ret = avb_user_verity_set(
		ops, android::base::GetProperty("ro.boot.slot_suffix", "").c_str(),
		false);
		avb_ops_user_free(ops);
		if (ret) {
		if (fs_mgr_overlayfs_valid() == OverlayfsValidResult::kNotSupported) {
		retval = VERITY_PARTITION;
		// w/o overlayfs available, also check for dedupe
		reboot_later = true;
		++it;
		continue;
		}
		reboot(false);
		} else if (fs_mgr_set_blk_ro(entry.blk_device, false)) {
		fec::io fh(entry.blk_device.c_str(), O_RDWR);
		if (fh && fh.set_verity_status(false)) reboot_later = true;
		}
		}
		}
		LOG(ERROR) << "Skipping " << mount_point;
		retval = VERITY_PARTITION;
		it = partitions.erase(it);
		continue;
		}

		auto change = false;
		errno = 0;
		if (fs_mgr_overlayfs_setup(nullptr, mount_point.c_str(), &change)) {
		if (change) {
		LOG(INFO) << "Using overlayfs for " << mount_point;
		}
		} else if (errno) {
		PLOG(ERROR) << "Overlayfs setup for " << mount_point << " failed, skipping";
		retval = BAD_OVERLAY;
		it = partitions.erase(it);
		continue;
		}
		++it;
		}

		if (partitions.empty()) {
		if (reboot_later) reboot(false);
		LOG(WARNING) << "No partitions to remount";
		return retval;
		}

		// Mount overlayfs.
		if (!fs_mgr_overlayfs_mount_all(&partitions)) {
		retval = BAD_OVERLAY;
		PLOG(ERROR) << "Can not mount overlayfs for partitions";
		}

		// Get actual mounts _after_ overlayfs has been added.
		android::fs_mgr::Fstab mounts;
		if (!android::fs_mgr::ReadFstabFromFile("/proc/mounts", &mounts) \|\| mounts.empty()) {
		PLOG(ERROR) << "Failed to read /proc/mounts";
		retval = NO_MOUNTS;
		}

		// Remount selected partitions.
		for (auto& entry : partitions) {
		// unlock the r/o key for the mount point device
		if (entry.fs_mgr_flags.logical) {
		fs_mgr_update_logical_partition(&entry);
		}
		auto blk_device = entry.blk_device;
		auto mount_point = entry.mount_point;

		for (auto it = mounts.rbegin(); it != mounts.rend(); ++it) {
		auto& rentry = *it;
		if (mount_point == rentry.mount_point) {
		blk_device = rentry.blk_device;
		break;
		}
		if ((mount_point == "/") && (rentry.mount_point == "/system")) {
		if (blk_device != "/dev/root") blk_device = rentry.blk_device;
		mount_point = "/system";
		break;
		}
		}
		fs_mgr_set_blk_ro(blk_device, false);

		// Now remount!
		if (::mount(blk_device.c_str(), mount_point.c_str(), entry.fs_type.c_str(), MS_REMOUNT,
		nullptr) == 0) {
		continue;
		}
		if ((errno == EINVAL) && (mount_point != entry.mount_point)) {
		mount_point = entry.mount_point;
		if (::mount(blk_device.c_str(), mount_point.c_str(), entry.fs_type.c_str(), MS_REMOUNT,
		nullptr) == 0) {
		continue;
		}
		}
		PLOG(WARNING) << "failed to remount partition dev:" << blk_device << " mnt:" << mount_point;
		// If errno = EROFS at this point, we are dealing with r/o
		// filesystem types like squashfs, erofs or ext4 dedupe. We will
		// consider such a device that does not have CONFIG_OVERLAY_FS
		// in the kernel as a misconfigured; except for ext4 dedupe.
		if ((errno == EROFS) && can_reboot) {
		const std::vector<std::string> msg = {"--fsck_unshare_blocks"};
		std::string err;
		if (write_bootloader_message(msg, &err)) reboot(true);
		LOG(ERROR) << "Failed to set bootloader message: " << err;
		errno = EROFS;
		}
		retval = REMOUNT_FAILED;
		}

		if (reboot_later) reboot(false);

		try_unmount_bionic(&mounts);

		return retval;
		}

fs_mgr/tests/adb-remount-test.sh

+173 −54

File changed.

Preview size limit exceeded, changes collapsed.