Merge "Add device= in Fstab" into main (4dced90f) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+10 −3

Original line number	Diff line number	Diff line
		@@ -40,6 +40,7 @@
		#include <functional>
		#include <map>
		#include <memory>
		#include <numeric>
		#include <string>
		#include <string_view>
		#include <thread>
		@@ -1553,7 +1554,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
		fs_mgr_set_blk_ro(attempted_entry.blk_device, false);
		if (!call_vdc({"cryptfs", "encryptFstab", attempted_entry.blk_device,
		attempted_entry.mount_point, wiped ? "true" : "false",
		attempted_entry.fs_type, attempted_entry.zoned_device},
		attempted_entry.fs_type,
		attempted_entry.fs_mgr_flags.is_zoned ? "true" : "false",
		android::base::Join(attempted_entry.user_devices, ' ')},
		nullptr)) {
		LERROR << "Encryption failed";
		set_type_property(encryptable);
		@@ -1596,7 +1599,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {

		if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
		current_entry.mount_point, "true" /* shouldFormat */,
		current_entry.fs_type, current_entry.zoned_device},
		current_entry.fs_type,
		current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
		android::base::Join(current_entry.user_devices, ' ')},
		nullptr)) {
		LERROR << "Encryption failed";
		} else {
		@@ -1621,7 +1626,9 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
		if (mount_errno != EBUSY && mount_errno != EACCES &&
		should_use_metadata_encryption(attempted_entry)) {
		if (!call_vdc({"cryptfs", "mountFstab", attempted_entry.blk_device,
		attempted_entry.mount_point, attempted_entry.zoned_device},
		attempted_entry.mount_point,
		current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
		android::base::Join(current_entry.user_devices, ' ')},
		nullptr)) {
		++error_count;
		} else if (current_entry.mount_point == "/data") {

fs_mgr/fs_mgr_format.cpp

+14 −7

Original line number	Diff line number	Diff line
		@@ -125,7 +125,8 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
		}

		static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs_projid,
		bool needs_casefold, bool fs_compress, const std::string& zoned_device) {
		bool needs_casefold, bool fs_compress, bool is_zoned,
		const std::vector<std::string>& user_devices) {
		if (!dev_sz) {
		int rc = get_dev_sz(fs_blkdev, &dev_sz);
		if (rc) {
		@@ -159,16 +160,21 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs
		args.push_back(block_size.c_str());
		args.push_back("-b");
		args.push_back(block_size.c_str());
		if (!zoned_device.empty()) {
		args.push_back("-c");
		args.push_back(zoned_device.c_str());

		if (is_zoned) {
		args.push_back("-m");
		}
		for (auto& device : user_devices) {
		args.push_back("-c");
		args.push_back(device.c_str());
		}

		if (user_devices.empty()) {
		args.push_back(fs_blkdev.c_str());
		args.push_back(size_str.c_str());
		} else {
		args.push_back(fs_blkdev.c_str());
		args.push_back(size_str.c_str());
		}

		return logwrap_fork_execvp(args.size(), args.data(), nullptr, false, LOG_KLOG, false, nullptr);
		}

		@@ -184,7 +190,8 @@ int fs_mgr_do_format(const FstabEntry& entry) {

		if (entry.fs_type == "f2fs") {
		return format_f2fs(entry.blk_device, entry.length, needs_projid, needs_casefold,
		entry.fs_mgr_flags.fs_compress, entry.zoned_device);
		entry.fs_mgr_flags.fs_compress, entry.fs_mgr_flags.is_zoned,
		entry.user_devices);
		} else if (entry.fs_type == "ext4") {
		return format_ext4(entry.blk_device, entry.mount_point, needs_projid,
		entry.fs_mgr_flags.ext_meta_csum);

fs_mgr/libfstab/fstab.cpp

+25 −11

Original line number	Diff line number	Diff line
		@@ -147,6 +147,29 @@ void ParseMountFlags(const std::string& flags, FstabEntry* entry) {
		entry->fs_options = std::move(fs_options);
		}

		void ParseUserDevices(const std::string& arg, FstabEntry* entry) {
		auto param = Split(arg, ":");
		if (param.size() != 2) {
		LWARNING << "Warning: device= malformed: " << arg;
		return;
		}

		if (access(param[1].c_str(), F_OK) != 0) {
		LWARNING << "Warning: device does not exist : " << param[1];
		return;
		}

		if (param[0] == "zoned") {
		// atgc in f2fs does not support a zoned device
		auto options = Split(entry->fs_options, ",");
		options.erase(std::remove(options.begin(), options.end(), "atgc"), options.end());
		entry->fs_options = android::base::Join(options, ",");
		LINFO << "Removed ATGC in fs_options as " << entry->fs_options << " for zoned device";
		entry->fs_mgr_flags.is_zoned = true;
		}
		entry->user_devices.push_back(param[1]);
		}

		bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		for (const auto& flag : Split(flags, ",")) {
		if (flag.empty() \|\| flag == "defaults") continue;
		@@ -311,17 +334,8 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		if (!ParseByteCount(arg, &entry->zram_backingdev_size)) {
		LWARNING << "Warning: zram_backingdev_size= flag malformed: " << arg;
		}
		} else if (flag == "zoned_device") {
		if (access("/dev/block/by-name/zoned_device", F_OK) == 0) {
		entry->zoned_device = "/dev/block/by-name/zoned_device";

		// atgc in f2fs does not support a zoned device
		auto options = Split(entry->fs_options, ",");
		options.erase(std::remove(options.begin(), options.end(), "atgc"), options.end());
		entry->fs_options = android::base::Join(options, ",");
		LINFO << "Removed ATGC in fs_options as " << entry->fs_options
		<< " for zoned device=" << entry->zoned_device;
		}
		} else if (StartsWith(flag, "device=")) {
		ParseUserDevices(arg, entry);
		} else {
		LWARNING << "Warning: unknown flag: " << flag;
		}

fs_mgr/libfstab/include/fstab/fstab.h

+2 −1

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@ namespace fs_mgr {

		struct FstabEntry {
		std::string blk_device;
		std::string zoned_device;
		std::vector<std::string> user_devices;
		std::string logical_partition_name;
		std::string mount_point;
		std::string fs_type;
		@@ -85,6 +85,7 @@ struct FstabEntry {
		bool ext_meta_csum : 1;
		bool fs_compress : 1;
		bool overlayfs_remove_missing_lowerdir : 1;
		bool is_zoned : 1;
		} fs_mgr_flags = {};

		bool is_encryptable() const { return fs_mgr_flags.crypt; }