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

Commit 990b8f11 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Skip F2FS formatting for dev option enabled devices" into main am: b346ff1e am: 2f70233f 

Original change: https://android-review.googlesource.com/c/platform/system/core/+/3192001



Change-Id: I51fcb4ee4cf70fddb9e3e1387890828c7c6f331a
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents fc005efa 2f70233f

fs_mgr/fs_mgr.cpp

+46 −18
Original line number Diff line number Diff line
@@ -38,10 +38,8 @@ 


#include <array>

#include <chrono>

#include <functional>

#include <map>

#include <memory>

#include <numeric>

#include <string>

#include <string_view>

#include <thread>
@@ -66,6 +64,7 @@ 
#include <fs_mgr/file_wait.h>

#include <fs_mgr_overlayfs.h>

#include <fscrypt/fscrypt.h>

#include <fstab/fstab.h>

#include <libdm/dm.h>

#include <libdm/loop_control.h>

#include <liblp/metadata_format.h>
@@ -138,8 +137,8 @@ enum FsStatFlags { 
static void log_fs_stat(const std::string& blk_device, int 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)));

    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)) {

        LWARNING << __FUNCTION__ << "() cannot log " << msg;

    }
@@ -1430,6 +1429,34 @@ bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) { 
    return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0;

}



FstabEntry* LocateFormattableEntry(FstabEntry* const begin, FstabEntry* const end) {

    const bool dev_option_enabled =

            android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);

    FstabEntry* f2fs_entry = nullptr;

    for (auto iter = begin; iter->blk_device == begin->blk_device && iter < end; iter++) {

        if (iter->fs_mgr_flags.formattable) {

            if (getpagesize() != 4096 && is_f2fs(iter->fs_type) && dev_option_enabled) {

                f2fs_entry = iter;

                continue;

            }

            if (f2fs_entry) {

                LOG(INFO) << "Skipping F2FS format for block device " << iter->blk_device << " @ "

                          << iter->mount_point

                          << " in non-4K mode for dev option enabled devices, "

                             "as these devices need to toggle between 4K/16K mode, and F2FS does "

                             "not support page_size != block_size configuration.";

            }

            return iter;

        }

    }

    if (f2fs_entry) {

        LOG(INFO) << "Using F2FS for " << f2fs_entry->blk_device << " @ " << f2fs_entry->mount_point

                  << " even though we are in non-4K mode. Device might require a data wipe after "

                     "going back to 4K mode, as F2FS does not support page_size != block_size";

    }

    return f2fs_entry;

}



// When multiple fstab records share the same mount_point, it will try to mount each

// one in turn, and ignore any duplicates after a first successful mount.

// Returns -1 on error, and  FS_MGR_MNTALL_* otherwise.
@@ -1540,8 +1567,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) { 
            }

        }



        int last_idx_inspected;

        int top_idx = i;

        int last_idx_inspected = -1;

        const int top_idx = i;

        int attempted_idx = -1;



        bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry);
@@ -1591,7 +1618,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) { 
            // Success!  Go get the next one.

            continue;

        }



        auto formattable_entry =

                LocateFormattableEntry(fstab->data() + top_idx, fstab->data() + fstab->size());

        // Mounting failed, understand why and retry.

        wiped = partition_wiped(current_entry.blk_device.c_str());

        if (mount_errno != EBUSY && mount_errno != EACCES &&
@@ -1619,12 +1647,12 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) { 
                encryptable = FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED;

                set_type_property(encryptable);



                if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,

                               current_entry.mount_point, "true" /* shouldFormat */,

                               current_entry.fs_type,

                               current_entry.fs_mgr_flags.is_zoned ? "true" : "false",

                               std::to_string(current_entry.length),

                               android::base::Join(current_entry.user_devices, ' ')},

                if (!call_vdc({"cryptfs", "encryptFstab", formattable_entry->blk_device,

                               formattable_entry->mount_point, "true" /* shouldFormat */,

                               formattable_entry->fs_type,

                               formattable_entry->fs_mgr_flags.is_zoned ? "true" : "false",

                               std::to_string(formattable_entry->length),

                               android::base::Join(formattable_entry->user_devices, ' ')},

                              nullptr)) {

                    LERROR << "Encryption failed";

                } else {
@@ -1633,7 +1661,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) { 
                }

            }



            if (fs_mgr_do_format(current_entry) == 0) {

            if (fs_mgr_do_format(*formattable_entry) == 0) {

                // Let's replay the mount actions.

                i = top_idx - 1;

                continue;