Merge "fs_mgr: use std::string in more places" (1fcf7f7d) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+75 −88

Original line number	Diff line number	Diff line
		@@ -91,6 +91,8 @@ using android::fs_mgr::AvbHandle;
		using android::fs_mgr::AvbHashtreeResult;
		using android::fs_mgr::AvbUniquePtr;

		using namespace std::literals;

		// record fs stat
		enum FsStatFlags {
		FS_STAT_IS_EXT4 = 0x0001,
		@@ -131,10 +133,10 @@ bool fs_mgr_wait_for_file(const std::string& filename,
		}
		}

		static void log_fs_stat(const char* blk_device, int fs_stat)
		{
		static void log_fs_stat(const std::string& blk_device, int fs_stat) {
		if ((fs_stat & FS_STAT_IS_EXT4) == 0) return; // only log ext4
		std::string msg = android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device, fs_stat);
		std::string msg =
		android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat);
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY \| O_CLOEXEC \|
		O_APPEND \| O_CREAT, 0664)));
		if (fd == -1 \|\| !android::base::WriteStringToFd(msg, fd)) {
		@@ -150,7 +152,7 @@ static bool is_f2fs(const std::string& fs_type) {
		return fs_type == "f2fs";
		}

		static std::string realpath(const char* blk_device) {
		static std::string realpath(const std::string& blk_device) {
		std::string real_path;
		if (!Realpath(blk_device, &real_path)) {
		real_path = blk_device;
		@@ -166,14 +168,14 @@ static bool should_force_check(int fs_stat) {
		FS_STAT_SET_RESERVED_BLOCKS_FAILED \| FS_STAT_ENABLE_ENCRYPTION_FAILED);
		}

		static void check_fs(const char blk_device, char fs_type, char target, int fs_stat)
		{
		static void check_fs(const std::string& blk_device, const std::string& fs_type,
		const std::string& target, int* fs_stat) {
		int status;
		int ret;
		long tmpmnt_flags = MS_NOATIME \| MS_NOEXEC \| MS_NOSUID;
		char tmpmnt_opts[64] = "errors=remount-ro";
		const char* e2fsck_argv[] = {E2FSCK_BIN, "-y", blk_device};
		const char* e2fsck_forced_argv[] = {E2FSCK_BIN, "-f", "-y", blk_device};
		auto tmpmnt_opts = "errors=remount-ro"s;
		const char* e2fsck_argv[] = {E2FSCK_BIN, "-y", blk_device.c_str()};
		const char* e2fsck_forced_argv[] = {E2FSCK_BIN, "-f", "-y", blk_device.c_str()};

		if (*fs_stat & FS_STAT_INVALID_MAGIC) { // will fail, so do not try
		return;
		@@ -196,18 +198,19 @@ static void check_fs(const char blk_device, char fs_type, char target, int f
		*/
		if (!(*fs_stat & FS_STAT_FULL_MOUNT_FAILED)) { // already tried if full mount failed
		errno = 0;
		if (!strcmp(fs_type, "ext4")) {
		if (fs_type == "ext4") {
		// This option is only valid with ext4
		strlcat(tmpmnt_opts, ",nomblk_io_submit", sizeof(tmpmnt_opts));
		tmpmnt_opts += ",nomblk_io_submit";
		}
		ret = mount(blk_device, target, fs_type, tmpmnt_flags, tmpmnt_opts);
		ret = mount(blk_device.c_str(), target.c_str(), fs_type.c_str(), tmpmnt_flags,
		tmpmnt_opts.c_str());
		PINFO << __FUNCTION__ << "(): mount(" << blk_device << "," << target << "," << fs_type
		<< ")=" << ret;
		if (!ret) {
		bool umounted = false;
		int retry_count = 5;
		while (retry_count-- > 0) {
		umounted = umount(target) == 0;
		umounted = umount(target.c_str()) == 0;
		if (umounted) {
		LINFO << __FUNCTION__ << "(): unmount(" << target << ") succeeded";
		break;
		@@ -254,7 +257,7 @@ static void check_fs(const char blk_device, char fs_type, char target, int f
		}
		}
		} else if (is_f2fs(fs_type)) {
		const char* f2fs_fsck_argv[] = {F2FS_FSCK_BIN, "-a", blk_device};
		const char* f2fs_fsck_argv[] = {F2FS_FSCK_BIN, "-a", blk_device.c_str()};
		LINFO << "Running " << F2FS_FSCK_BIN << " -a " << realpath(blk_device);

		ret = android_fork_execvp_ext(ARRAY_SIZE(f2fs_fsck_argv),
		@@ -290,8 +293,9 @@ static bool is_ext4_superblock_valid(const struct ext4_super_block* es) {

		// Read the primary superblock from an ext4 filesystem. On failure return
		// false. If it's not an ext4 filesystem, also set FS_STAT_INVALID_MAGIC.
		static bool read_ext4_superblock(const char* blk_device, struct ext4_super_block* sb, int* fs_stat) {
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device, O_RDONLY \| O_CLOEXEC)));
		static bool read_ext4_superblock(const std::string& blk_device, struct ext4_super_block* sb,
		int* fs_stat) {
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY \| O_CLOEXEC)));

		if (fd < 0) {
		PERROR << "Failed to open '" << blk_device << "'";
		@@ -332,7 +336,7 @@ static bool run_tune2fs(const char* argv[], int argc) {
		}

		// Enable/disable quota support on the filesystem if needed.
		static void tune_quota(const char* blk_device, const struct fstab_rec* rec,
		static void tune_quota(const std::string& blk_device, const struct fstab_rec* rec,
		const struct ext4_super_block* sb, int* fs_stat) {
		bool has_quota = (sb->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_RO_COMPAT_QUOTA)) != 0;
		bool want_quota = fs_mgr_is_quota(rec) != 0;
		@@ -347,7 +351,7 @@ static void tune_quota(const char* blk_device, const struct fstab_rec* rec,
		return;
		}

		const char* argv[] = {TUNE2FS_BIN, nullptr, nullptr, blk_device};
		const char* argv[] = {TUNE2FS_BIN, nullptr, nullptr, blk_device.c_str()};

		if (want_quota) {
		LINFO << "Enabling quotas on " << blk_device;
		@@ -368,7 +372,7 @@ static void tune_quota(const char* blk_device, const struct fstab_rec* rec,
		}

		// Set the number of reserved filesystem blocks if needed.
		static void tune_reserved_size(const char* blk_device, const struct fstab_rec* rec,
		static void tune_reserved_size(const std::string& blk_device, const struct fstab_rec* rec,
		const struct ext4_super_block* sb, int* fs_stat) {
		if (!(rec->fs_mgr_flags & MF_RESERVEDSIZE)) {
		return;
		@@ -400,7 +404,8 @@ static void tune_reserved_size(const char* blk_device, const struct fstab_rec* r
		auto reserved_blocks_str = std::to_string(reserved_blocks);
		auto reserved_gid_str = std::to_string(AID_RESERVED_DISK);
		const char* argv[] = {
		TUNE2FS_BIN, "-r", reserved_blocks_str.c_str(), "-g", reserved_gid_str.c_str(), blk_device};
		TUNE2FS_BIN, "-r", reserved_blocks_str.c_str(), "-g", reserved_gid_str.c_str(),
		blk_device.c_str()};
		if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to set the number of reserved blocks on "
		<< blk_device;
		@@ -409,7 +414,7 @@ static void tune_reserved_size(const char* blk_device, const struct fstab_rec* r
		}

		// Enable file-based encryption if needed.
		static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec,
		static void tune_encrypt(const std::string& blk_device, const struct fstab_rec* rec,
		const struct ext4_super_block* sb, int* fs_stat) {
		bool has_encrypt = (sb->s_feature_incompat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_ENCRYPT)) != 0;
		bool want_encrypt = fs_mgr_is_file_encrypted(rec) != 0;
		@@ -424,7 +429,7 @@ static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec,
		return;
		}

		const char* argv[] = {TUNE2FS_BIN, "-Oencrypt", blk_device};
		const char* argv[] = {TUNE2FS_BIN, "-Oencrypt", blk_device.c_str()};

		LINFO << "Enabling ext4 encryption on " << blk_device;
		if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
		@@ -438,8 +443,8 @@ static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec,
		// false. If it's not an f2fs filesystem, also set FS_STAT_INVALID_MAGIC.
		#define F2FS_BLKSIZE 4096
		#define F2FS_SUPER_OFFSET 1024
		static bool read_f2fs_superblock(const char* blk_device, int* fs_stat) {
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device, O_RDONLY \| O_CLOEXEC)));
		static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) {
		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY \| O_CLOEXEC)));
		__le32 sb1, sb2;

		if (fd < 0) {
		@@ -473,7 +478,7 @@ static bool read_f2fs_superblock(const char* blk_device, int* fs_stat) {
		// If needed, we'll also enable (or disable) filesystem features as specified by
		// the fstab record.
		//
		static int prepare_fs_for_mount(const char* blk_device, const struct fstab_rec* rec) {
		static int prepare_fs_for_mount(const std::string& blk_device, const struct fstab_rec* rec) {
		int fs_stat = 0;

		if (is_extfs(rec->fs_type)) {
		@@ -516,17 +521,6 @@ static int prepare_fs_for_mount(const char* blk_device, const struct fstab_rec*
		return fs_stat;
		}

		static void remove_trailing_slashes(char *n)
		{
		int len;

		len = strlen(n) - 1;
		while ((*(n + len) == '/') && len) {
		*(n + len) = '\0';
		len--;
		}
		}

		// Mark the given block device as read-only, using the BLKROSET ioctl.
		bool fs_mgr_set_blk_ro(const std::string& blockdev) {
		unique_fd fd(TEMP_FAILURE_RETRY(open(blockdev.c_str(), O_RDONLY \| O_CLOEXEC)));
		@@ -548,34 +542,28 @@ bool fs_mgr_is_device_unlocked() {
		return false;
		}

		/*
		* __mount(): wrapper around the mount() system call which also
		* sets the underlying block device to read-only if the mount is read-only.
		* See "man 2 mount" for return values.
		*/
		static int __mount(const char source, const char target, const struct fstab_rec *rec)
		{
		unsigned long mountflags = rec->flags;
		int ret;
		int save_errno;

		/* We need this because sometimes we have legacy symlinks
		* that are lingering around and need cleaning up.
		*/
		// __mount(): wrapper around the mount() system call which also
		// sets the underlying block device to read-only if the mount is read-only.
		// See "man 2 mount" for return values.
		static int __mount(const std::string& source, const std::string& target,
		const struct fstab_rec* rec) {
		// We need this because sometimes we have legacy symlinks that are
		// lingering around and need cleaning up.
		struct stat info;
		if (!lstat(target, &info))
		if ((info.st_mode & S_IFMT) == S_IFLNK)
		unlink(target);
		mkdir(target, 0755);
		if (lstat(target.c_str(), &info) == 0 && (info.st_mode & S_IFMT) == S_IFLNK) {
		unlink(target.c_str());
		}
		mkdir(target.c_str(), 0755);
		errno = 0;
		ret = mount(source, target, rec->fs_type, mountflags, rec->fs_options);
		save_errno = errno;
		unsigned long mountflags = rec->flags;
		int ret = mount(source.c_str(), target.c_str(), rec->fs_type, mountflags, rec->fs_options);
		int save_errno = errno;
		const char* target_missing = "";
		const char* source_missing = "";
		if (save_errno == ENOENT) {
		if (access(target, F_OK)) {
		if (access(target.c_str(), F_OK)) {
		target_missing = "(missing)";
		} else if (access(source, F_OK)) {
		} else if (access(source.c_str(), F_OK)) {
		source_missing = "(missing)";
		}
		errno = save_errno;
		@@ -589,24 +577,32 @@ static int __mount(const char source, const char target, const struct fstab_re
		return ret;
		}

		static int fs_match(const char in1, const char in2)
		{
		char *n1;
		char *n2;
		int ret;
		static bool fs_match(const std::string& in1, const std::string& in2) {
		if (in1.empty() \|\| in2.empty()) {
		return false;
		}

		n1 = strdup(in1);
		n2 = strdup(in2);
		auto in1_end = in1.size() - 1;
		while (in1_end > 0 && in1[in1_end] == '/') {
		in1_end--;
		}

		remove_trailing_slashes(n1);
		remove_trailing_slashes(n2);
		auto in2_end = in2.size() - 1;
		while (in2_end > 0 && in2[in2_end] == '/') {
		in2_end--;
		}

		ret = !strcmp(n1, n2);
		if (in1_end != in2_end) {
		return false;
		}

		free(n1);
		free(n2);
		for (size_t i = 0; i <= in1_end; ++i) {
		if (in1[i] != in2[i]) {
		return false;
		}
		}

		return ret;
		return true;
		}

		/*
		@@ -746,17 +742,12 @@ static bool TranslateExtLabels(fstab_rec* rec) {
		}

		if (label == super_block.s_volume_name) {
		char* new_blk_device;

		if (asprintf(&new_blk_device, "/dev/block/%s", ent->d_name) < 0) {
		LERROR << "Could not allocate block device string";
		return false;
		}
		std::string new_blk_device = "/dev/block/"s + ent->d_name;

		LINFO << "resolved label " << rec->blk_device << " to " << new_blk_device;

		free(rec->blk_device);
		rec->blk_device = new_blk_device;
		rec->blk_device = strdup(new_blk_device.c_str());
		return true;
		}
		}
		@@ -771,18 +762,14 @@ static bool needs_block_encryption(const struct fstab_rec* rec)
		return true;
		if (rec->fs_mgr_flags & MF_FORCECRYPT) return true;
		if (rec->fs_mgr_flags & MF_CRYPT) {
		/* Check for existence of convert_fde breadcrumb file */
		char convert_fde_name[PATH_MAX];
		snprintf(convert_fde_name, sizeof(convert_fde_name),
		"%s/misc/vold/convert_fde", rec->mount_point);
		if (access(convert_fde_name, F_OK) == 0) return true;
		// Check for existence of convert_fde breadcrumb file.
		auto convert_fde_name = rec->mount_point + "%s/misc/vold/convert_fde"s;
		if (access(convert_fde_name.c_str(), F_OK) == 0) return true;
		}
		if (rec->fs_mgr_flags & MF_FORCEFDEORFBE) {
		/* Check for absence of convert_fbe breadcrumb file */
		char convert_fbe_name[PATH_MAX];
		snprintf(convert_fbe_name, sizeof(convert_fbe_name),
		"%s/convert_fbe", rec->mount_point);
		if (access(convert_fbe_name, F_OK) != 0) return true;
		// Check for absence of convert_fbe breadcrumb file.
		auto convert_fbe_name = rec->mount_point + "/convert_fbe"s;
		if (access(convert_fbe_name.c_str(), F_OK) != 0) return true;
		}
		return false;
		}

fs_mgr/fs_mgr_format.cpp

+13 −21

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include <cutils/partition_utils.h>
		#include <sys/mount.h>

		#include <android-base/unique_fd.h>
		#include <ext4_utils/ext4.h>
		#include <ext4_utils/ext4_utils.h>
		#include <logwrap/logwrap.h>
		@@ -34,30 +35,28 @@
		#include "fs_mgr_priv.h"
		#include "cryptfs.h"

		static int get_dev_sz(char fs_blkdev, uint64_t dev_sz)
		{
		int fd;
		using android::base::unique_fd;

		static int get_dev_sz(const std::string& fs_blkdev, uint64_t* dev_sz) {
		unique_fd fd(TEMP_FAILURE_RETRY(open(fs_blkdev.c_str(), O_RDONLY \| O_CLOEXEC)));

		if ((fd = open(fs_blkdev, O_RDONLY)) < 0) {
		if (fd < 0) {
		PERROR << "Cannot open block device";
		return -1;
		}

		if ((ioctl(fd, BLKGETSIZE64, dev_sz)) == -1) {
		PERROR << "Cannot get block device size";
		close(fd);
		return -1;
		}

		close(fd);
		return 0;
		}

		static int format_ext4(char fs_blkdev, char fs_mnt_point, bool crypt_footer)
		{
		static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_point,
		bool crypt_footer) {
		uint64_t dev_sz;
		int rc = 0;
		int status;

		rc = get_dev_sz(fs_blkdev, &dev_sz);
		if (rc) {
		@@ -71,7 +70,8 @@ static int format_ext4(char fs_blkdev, char fs_mnt_point, bool crypt_footer)

		std::string size_str = std::to_string(dev_sz / 4096);
		const char* const mke2fs_args[] = {
		"/system/bin/mke2fs", "-t", "ext4", "-b", "4096", fs_blkdev, size_str.c_str(), nullptr};
		"/system/bin/mke2fs", "-t", "ext4", "-b", "4096", fs_blkdev.c_str(),
		size_str.c_str(), nullptr};

		rc = android_fork_execvp_ext(arraysize(mke2fs_args), const_cast<char**>(mke2fs_args), NULL,
		true, LOG_KLOG, true, nullptr, nullptr, 0);
		@@ -81,12 +81,7 @@ static int format_ext4(char fs_blkdev, char fs_mnt_point, bool crypt_footer)
		}

		const char* const e2fsdroid_args[] = {
		"/system/bin/e2fsdroid",
		"-e",
		"-a",
		fs_mnt_point,
		fs_blkdev,
		nullptr};
		"/system/bin/e2fsdroid", "-e", "-a", fs_mnt_point.c_str(), fs_blkdev.c_str(), nullptr};

		rc = android_fork_execvp_ext(arraysize(e2fsdroid_args), const_cast<char**>(e2fsdroid_args),
		NULL, true, LOG_KLOG, true, nullptr, nullptr, 0);
		@@ -97,10 +92,7 @@ static int format_ext4(char fs_blkdev, char fs_mnt_point, bool crypt_footer)
		return rc;
		}

		static int format_f2fs(char *fs_blkdev, uint64_t dev_sz, bool crypt_footer)
		{
		int status;

		static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool crypt_footer) {
		if (!dev_sz) {
		int rc = get_dev_sz(fs_blkdev, &dev_sz);
		if (rc) {
		@@ -118,7 +110,7 @@ static int format_f2fs(char *fs_blkdev, uint64_t dev_sz, bool crypt_footer)
		const char* const args[] = {
		"/system/bin/make_f2fs",
		"-g", "android",
		fs_blkdev,
		fs_blkdev.c_str(),
		size_str.c_str(),
		nullptr
		};