Merge "Switch root to /system in first stage mount" (7b02605b) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+2 −1

Original line number	Diff line number	Diff line
		@@ -853,7 +853,8 @@ int fs_mgr_mount_all(struct fstab *fstab, int mount_mode)
		}

		/* Skip mounting the root partition, as it will already have been mounted */
		if (!strcmp(fstab->recs[i].mount_point, "/")) {
		if (!strcmp(fstab->recs[i].mount_point, "/") \|\|
		!strcmp(fstab->recs[i].mount_point, "/system")) {
		if ((fstab->recs[i].fs_mgr_flags & MS_RDONLY) != 0) {
		fs_mgr_set_blk_ro(fstab->recs[i].blk_device);
		}

init/Android.mk

+10 −2

Original line number	Diff line number	Diff line
		@@ -47,6 +47,7 @@ LOCAL_SRC_FILES := \
		init_first_stage.cpp \
		reboot_utils.cpp \
		selinux.cpp \
		switch_root.cpp \
		uevent_listener.cpp \
		util.cpp \

		@@ -54,8 +55,15 @@ LOCAL_MODULE := init

		LOCAL_FORCE_STATIC_EXECUTABLE := true

		LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT)
		LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_UNSTRIPPED)
		LOCAL_MODULE_PATH := $(TARGET_RAMDISK_OUT)
		LOCAL_UNSTRIPPED_PATH := $(TARGET_RAMDISK_OUT_UNSTRIPPED)

		# Set up the same mount points on the ramdisk that system-as-root contains.
		LOCAL_POST_INSTALL_CMD := \
		mkdir -p $(TARGET_RAMDISK_OUT)/dev \
		mkdir -p $(TARGET_RAMDISK_OUT)/mnt \
		mkdir -p $(TARGET_RAMDISK_OUT)/proc \
		mkdir -p $(TARGET_RAMDISK_OUT)/sys \

		LOCAL_STATIC_LIBRARIES := \
		libfs_mgr \

init/first_stage_mount.cpp

+46 −17

Original line number	Diff line number	Diff line
		@@ -29,19 +29,22 @@
		#include <android-base/file.h>
		#include <android-base/logging.h>
		#include <android-base/strings.h>
		#include <fs_mgr.h>
		#include <fs_mgr_avb.h>
		#include <fs_mgr_dm_linear.h>
		#include <fs_mgr_overlayfs.h>
		#include <liblp/metadata_format.h>

		#include "devices.h"
		#include "fs_mgr.h"
		#include "fs_mgr_avb.h"
		#include "fs_mgr_dm_linear.h"
		#include "fs_mgr_overlayfs.h"
		#include "switch_root.h"
		#include "uevent.h"
		#include "uevent_listener.h"
		#include "util.h"

		using android::base::Timer;

		using namespace std::literals;

		namespace android {
		namespace init {

		@@ -63,6 +66,7 @@ class FirstStageMount {
		bool InitRequiredDevices();
		bool InitMappedDevice(const std::string& verity_device);
		bool CreateLogicalPartitions();
		bool MountPartition(fstab_rec* fstab_rec);
		bool MountPartitions();
		bool GetBackingDmLinearDevices();

		@@ -333,8 +337,7 @@ bool FirstStageMount::InitMappedDevice(const std::string& dm_device) {
		return true;
		}

		bool FirstStageMount::MountPartitions() {
		for (auto fstab_rec : mount_fstab_recs_) {
		bool FirstStageMount::MountPartition(fstab_rec* fstab_rec) {
		if (fs_mgr_is_logical(fstab_rec)) {
		if (!fs_mgr_update_logical_partition(fstab_rec)) {
		return false;
		@@ -351,8 +354,34 @@ bool FirstStageMount::MountPartitions() {
		PLOG(ERROR) << "Failed to mount '" << fstab_rec->mount_point << "'";
		return false;
		}
		return true;
		}

		bool FirstStageMount::MountPartitions() {
		// If system is in the fstab then we're not a system-as-root device, and in
		// this case, we mount system first then pivot to it. From that point on,
		// we are effectively identical to a system-as-root device.
		auto system_partition =
		std::find_if(mount_fstab_recs_.begin(), mount_fstab_recs_.end(),
		[](const auto& rec) { return rec->mount_point == "/system"s; });
		if (system_partition != mount_fstab_recs_.end()) {
		if (!MountPartition(*system_partition)) {
		return false;
		}

		SwitchRoot("/system");

		mount_fstab_recs_.erase(system_partition);
		}

		for (auto fstab_rec : mount_fstab_recs_) {
		if (!MountPartition(fstab_rec)) {
		return false;
		}
		}

		fs_mgr_overlayfs_mount_all();

		return true;
		}

init/switch_root.cpp

0 → 100644

+151 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 "switch_root.h"

		#include <dirent.h>
		#include <fcntl.h>
		#include <mntent.h>
		#include <sys/mount.h>
		#include <sys/stat.h>
		#include <unistd.h>

		#include <android-base/logging.h>
		#include <android-base/strings.h>

		using android::base::StartsWith;

		using namespace std::literals;

		namespace android {
		namespace init {

		namespace {

		void FreeRamdisk(DIR* dir, dev_t dev) {
		int dfd = dirfd(dir);

		dirent* de;
		while ((de = readdir(dir)) != nullptr) {
		if (de->d_name == "."s \|\| de->d_name == ".."s) {
		continue;
		}

		bool is_dir = false;

		if (de->d_type == DT_DIR \|\| de->d_type == DT_UNKNOWN) {
		struct stat info;
		if (fstatat(dfd, de->d_name, &info, AT_SYMLINK_NOFOLLOW) != 0) {
		continue;
		}

		if (info.st_dev != dev) {
		continue;
		}

		if (S_ISDIR(info.st_mode)) {
		is_dir = true;
		auto fd = openat(dfd, de->d_name, O_RDONLY \| O_DIRECTORY);
		if (fd >= 0) {
		auto subdir =
		std::unique_ptr<DIR, decltype(&closedir)>{fdopendir(fd), closedir};
		if (subdir) {
		FreeRamdisk(subdir.get(), dev);
		} else {
		close(fd);
		}
		}
		}
		}
		unlinkat(dfd, de->d_name, is_dir ? AT_REMOVEDIR : 0);
		}
		}

		std::vector<std::string> GetMounts(const std::string& new_root) {
		auto fp = std::unique_ptr<std::FILE, decltype(&endmntent)>{setmntent("/proc/mounts", "re"),
		endmntent};
		if (fp == nullptr) {
		PLOG(FATAL) << "Failed to open /proc/mounts";
		}

		std::vector<std::string> result;
		mntent* mentry;
		while ((mentry = getmntent(fp.get())) != nullptr) {
		// We won't try to move rootfs.
		if (mentry->mnt_dir == "/"s) {
		continue;
		}

		// The new root mount is handled separately.
		if (mentry->mnt_dir == new_root) {
		continue;
		}

		// Move operates on subtrees, so do not try to move children of other mounts.
		if (std::find_if(result.begin(), result.end(), [&mentry](const auto& older_mount) {
		return StartsWith(mentry->mnt_dir, older_mount);
		}) != result.end()) {
		continue;
		}

		result.emplace_back(mentry->mnt_dir);
		}

		return result;
		}

		} // namespace

		void SwitchRoot(const std::string& new_root) {
		auto mounts = GetMounts(new_root);

		for (const auto& mount_path : mounts) {
		auto new_mount_path = new_root + mount_path;
		if (mount(mount_path.c_str(), new_mount_path.c_str(), nullptr, MS_MOVE, nullptr) != 0) {
		PLOG(FATAL) << "Unable to move mount at '" << mount_path << "'";
		}
		}

		auto old_root_dir = std::unique_ptr<DIR, decltype(&closedir)>{opendir("/"), closedir};
		if (!old_root_dir) {
		PLOG(ERROR) << "Could not opendir(\"/\"), not freeing ramdisk";
		}

		struct stat old_root_info;
		if (stat("/", &old_root_info) != 0) {
		PLOG(ERROR) << "Could not stat(\"/\"), not freeing ramdisk";
		old_root_dir.reset();
		}

		if (chdir(new_root.c_str()) != 0) {
		PLOG(FATAL) << "Could not chdir to new_root, '" << new_root << "'";
		}

		if (mount(new_root.c_str(), "/", nullptr, MS_MOVE, nullptr) != 0) {
		PLOG(FATAL) << "Unable to move root mount to new_root, '" << new_root << "'";
		}

		if (chroot(".") != 0) {
		PLOG(FATAL) << "Unable to chroot to new root";
		}

		if (old_root_dir) {
		FreeRamdisk(old_root_dir.get(), old_root_info.st_dev);
		}
		}

		} // namespace init
		} // namespace android

init/switch_root.h

0 → 100644

+27 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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.
		*/

		#pragma once

		#include <string>

		namespace android {
		namespace init {

		void SwitchRoot(const std::string& new_root);

		} // namespace init
		} // namespace android