Merge "fs_mgr: support metadata_csum for ext4 partition" (04bf79dc) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+54 −7

Original line number	Diff line number	Diff line
		@@ -78,6 +78,7 @@
		#define F2FS_FSCK_BIN "/system/bin/fsck.f2fs"
		#define MKSWAP_BIN "/system/bin/mkswap"
		#define TUNE2FS_BIN "/system/bin/tune2fs"
		#define RESIZE2FS_BIN "/system/bin/resize2fs"

		#define FSCK_LOG_FILE "/dev/fscklogs/log"

		@@ -126,6 +127,7 @@ enum FsStatFlags {
		FS_STAT_ENABLE_ENCRYPTION_FAILED = 0x40000,
		FS_STAT_ENABLE_VERITY_FAILED = 0x80000,
		FS_STAT_ENABLE_CASEFOLD_FAILED = 0x100000,
		FS_STAT_ENABLE_METADATA_CSUM_FAILED = 0x200000,
		};

		static void log_fs_stat(const std::string& blk_device, int fs_stat) {
		@@ -336,7 +338,7 @@ static bool tune2fs_available(void) {
		return access(TUNE2FS_BIN, X_OK) == 0;
		}

		static bool run_tune2fs(const char* argv[], int argc) {
		static bool run_command(const char* argv[], int argc) {
		int ret;

		ret = logwrap_fork_execvp(argc, argv, nullptr, false, LOG_KLOG, false, nullptr);
		@@ -377,7 +379,7 @@ static void tune_quota(const std::string& blk_device, const FstabEntry& entry,
		argv[2] = "-Q^usrquota,^grpquota,^prjquota";
		}

		if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
		if (!run_command(argv, ARRAY_SIZE(argv))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to " << (want_quota ? "enable" : "disable")
		<< " quotas on " << blk_device;
		*fs_stat \|= FS_STAT_TOGGLE_QUOTAS_FAILED;
		@@ -419,7 +421,7 @@ static void tune_reserved_size(const std::string& blk_device, const FstabEntry&
		const char* argv[] = {
		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))) {
		if (!run_command(argv, ARRAY_SIZE(argv))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to set the number of reserved blocks on "
		<< blk_device;
		*fs_stat \|= FS_STAT_SET_RESERVED_BLOCKS_FAILED;
		@@ -463,7 +465,7 @@ static void tune_encrypt(const std::string& blk_device, const FstabEntry& entry,
		const char* argv[] = {TUNE2FS_BIN, flag_arg.c_str(), blk_device.c_str()};

		LINFO << "Enabling ext4 flags " << flags << " on " << blk_device;
		if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
		if (!run_command(argv, ARRAY_SIZE(argv))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to enable "
		<< "ext4 flags " << flags << " on " << blk_device;
		*fs_stat \|= FS_STAT_ENABLE_ENCRYPTION_FAILED;
		@@ -500,7 +502,7 @@ static void tune_verity(const std::string& blk_device, const FstabEntry& entry,
		LINFO << "Enabling ext4 verity on " << blk_device;

		const char* argv[] = {TUNE2FS_BIN, "-O", "verity", blk_device.c_str()};
		if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
		if (!run_command(argv, ARRAY_SIZE(argv))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to enable "
		<< "ext4 verity on " << blk_device;
		*fs_stat \|= FS_STAT_ENABLE_VERITY_FAILED;
		@@ -536,13 +538,57 @@ static void tune_casefold(const std::string& blk_device, const struct ext4_super
		LINFO << "Enabling ext4 casefold on " << blk_device;

		const char* argv[] = {TUNE2FS_BIN, "-O", "casefold", "-E", "encoding=utf8", blk_device.c_str()};
		if (!run_tune2fs(argv, ARRAY_SIZE(argv))) {
		if (!run_command(argv, ARRAY_SIZE(argv))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to enable "
		<< "ext4 casefold on " << blk_device;
		*fs_stat \|= FS_STAT_ENABLE_CASEFOLD_FAILED;
		}
		}

		static bool resize2fs_available(void) {
		return access(RESIZE2FS_BIN, X_OK) == 0;
		}

		// Enable metadata_csum
		static void tune_metadata_csum(const std::string& blk_device, const FstabEntry& entry,
		const struct ext4_super_block* sb, int* fs_stat) {
		bool has_meta_csum =
		(sb->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) != 0;
		bool want_meta_csum = entry.fs_mgr_flags.ext_meta_csum;

		if (has_meta_csum \|\| !want_meta_csum) return;

		if (!tune2fs_available()) {
		LERROR << "Unable to enable metadata_csum on " << blk_device
		<< " because " TUNE2FS_BIN " is missing";
		return;
		}
		if (!resize2fs_available()) {
		LERROR << "Unable to enable metadata_csum on " << blk_device
		<< " because " RESIZE2FS_BIN " is missing";
		return;
		}

		LINFO << "Enabling ext4 metadata_csum on " << blk_device;

		// requires to give last_fsck_time to current to avoid insane time.
		// otherwise, tune2fs won't enable metadata_csum.
		std::string now = std::to_string(time(0));
		const char* tune2fs_args[] = {TUNE2FS_BIN, "-O", "metadata_csum,64bit,extent",
		"-T", now.c_str(), blk_device.c_str()};
		const char* resize2fs_args[] = {RESIZE2FS_BIN, "-b", blk_device.c_str()};

		if (!run_command(tune2fs_args, ARRAY_SIZE(tune2fs_args))) {
		LERROR << "Failed to run " TUNE2FS_BIN " to enable "
		<< "ext4 metadata_csum on " << blk_device;
		*fs_stat \|= FS_STAT_ENABLE_METADATA_CSUM_FAILED;
		} else if (!run_command(resize2fs_args, ARRAY_SIZE(resize2fs_args))) {
		LERROR << "Failed to run " RESIZE2FS_BIN " to enable "
		<< "ext4 metadata_csum on " << blk_device;
		*fs_stat \|= FS_STAT_ENABLE_METADATA_CSUM_FAILED;
		}
		}

		// Read the primary superblock from an f2fs filesystem. On failure return
		// false. If it's not an f2fs filesystem, also set FS_STAT_INVALID_MAGIC.
		#define F2FS_BLKSIZE 4096
		@@ -633,7 +679,7 @@ static int prepare_fs_for_mount(const std::string& blk_device, const FstabEntry&

		if (is_extfs(entry.fs_type) &&
		(entry.reserved_size != 0 \|\| entry.fs_mgr_flags.file_encryption \|\|
		entry.fs_mgr_flags.fs_verity)) {
		entry.fs_mgr_flags.fs_verity \|\| entry.fs_mgr_flags.ext_meta_csum)) {
		struct ext4_super_block sb;

		if (read_ext4_superblock(blk_device, &sb, &fs_stat)) {
		@@ -641,6 +687,7 @@ static int prepare_fs_for_mount(const std::string& blk_device, const FstabEntry&
		tune_encrypt(blk_device, entry, &sb, &fs_stat);
		tune_verity(blk_device, entry, &sb, &fs_stat);
		tune_casefold(blk_device, &sb, &fs_stat);
		tune_metadata_csum(blk_device, entry, &sb, &fs_stat);
		}
		}

fs_mgr/fs_mgr_format.cpp

+18 −2

Original line number	Diff line number	Diff line
		@@ -58,7 +58,7 @@ static int get_dev_sz(const std::string& fs_blkdev, uint64_t* dev_sz) {
		}

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

		@@ -83,6 +83,21 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
		}
		// casefolding is enabled via tune2fs during boot.

		if (needs_metadata_csum) {
		mke2fs_args.push_back("-O");
		mke2fs_args.push_back("metadata_csum");
		// tune2fs recommends to enable 64bit and extent:
		// Extents are not enabled. The file extent tree can be checksummed,
		// whereas block maps cannot. Not enabling extents reduces the coverage
		// of metadata checksumming. Re-run with -O extent to rectify.
		// 64-bit filesystem support is not enabled. The larger fields afforded
		// by this feature enable full-strength checksumming. Run resize2fs -b to rectify.
		mke2fs_args.push_back("-O");
		mke2fs_args.push_back("64bit");
		mke2fs_args.push_back("-O");
		mke2fs_args.push_back("extent");
		}

		mke2fs_args.push_back(fs_blkdev.c_str());
		mke2fs_args.push_back(size_str.c_str());

		@@ -153,7 +168,8 @@ int fs_mgr_do_format(const FstabEntry& entry, bool crypt_footer) {
		return format_f2fs(entry.blk_device, entry.length, crypt_footer, needs_projid,
		needs_casefold);
		} else if (entry.fs_type == "ext4") {
		return format_ext4(entry.blk_device, entry.mount_point, crypt_footer, needs_projid);
		return format_ext4(entry.blk_device, entry.mount_point, crypt_footer, needs_projid,
		entry.fs_mgr_flags.ext_meta_csum);
		} else {
		LERROR << "File system type '" << entry.fs_type << "' is not supported";
		return -EINVAL;

fs_mgr/fs_mgr_fstab.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -176,6 +176,7 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		CheckFlag("first_stage_mount", first_stage_mount);
		CheckFlag("slotselect_other", slot_select_other);
		CheckFlag("fsverity", fs_verity);
		CheckFlag("metadata_csum", ext_meta_csum);

		#undef CheckFlag

fs_mgr/include_fstab/fstab/fstab.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -83,6 +83,7 @@ struct FstabEntry {
		bool first_stage_mount : 1;
		bool slot_select_other : 1;
		bool fs_verity : 1;
		bool ext_meta_csum : 1;
		} fs_mgr_flags = {};

		bool is_encryptable() const {