Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 78f040c6 authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

fs_mgr: support metadata_csum for ext4 partition 



The metadata_csum can enhance ext4 stability, so this patch adds a way to
enable it.

Requiring "metadata_csum" in fsmgr flag of fstab.

Bug: 149039306
Change-Id: I618a65d7afc63a617f5f2582c93002af7f8e7234
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@google.com>
parent c7b92ea1

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) {
@@ -335,7 +337,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, true, nullptr);
@@ -376,7 +378,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;
@@ -418,7 +420,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;
@@ -462,7 +464,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;
@@ -499,7 +501,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;
@@ -535,13 +537,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
@@ -632,7 +678,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)) {
@@ -640,6 +686,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 {