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

Commit 98e35227 authored by Yi-Yo Chiang's avatar Yi-Yo Chiang
Browse files

fs_mgr: Refactor by inlining trivial helpers 

Inline some trivial helpers and remove unused header declarations.

Remove fs_mgr_*access() as it is really just access().
Remove fs_mgr_overlayfs_super_device() as we always want the primary
slot and having this wrapper isn't particularly helpful.

Test: adb-remount-test
Change-Id: I2581fd7c7d5071cbb97778535b7811dbcb80d76e
parent b2e0edca

fs_mgr/fs_mgr_fstab.cpp

+16 −10
Original line number Diff line number Diff line
@@ -328,8 +328,7 @@ bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) { 
    // some recovery fstabs still contain the FDE options since they didn't do

    // anything in recovery mode anyway (except possibly to cause the

    // reservation of a crypto footer) and thus never got removed.

    if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed &&

        access("/system/bin/recovery", F_OK) != 0) {

    if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed && !InRecovery()) {

        LERROR << "FDE is no longer supported; 'encryptable' can only be used for adoptable "

                  "storage";

        return false;
@@ -520,6 +519,9 @@ std::vector<FstabPtrEntryType*> GetEntriesByPred(FstabPtr fstab, const Pred& pre 
// ramdisk's copy of the fstab had to be located in the root directory, but now

// the system/etc directory is supported too and is the preferred location.

std::string GetFstabPath() {

    if (InRecovery()) {

        return "/etc/recovery.fstab";

    }

    for (const char* prop : {"fstab_suffix", "hardware", "hardware.platform"}) {

        std::string suffix;
@@ -835,15 +837,8 @@ bool ReadDefaultFstab(Fstab* fstab) { 
    fstab->clear();

    ReadFstabFromDt(fstab, false /* verbose */);



    std::string default_fstab_path;

    // Use different fstab paths for normal boot and recovery boot, respectively

    if ((access("/sbin/recovery", F_OK) == 0) || (access("/system/bin/recovery", F_OK) == 0)) {

        default_fstab_path = "/etc/recovery.fstab";

    } else {  // normal boot

        default_fstab_path = GetFstabPath();

    }



    Fstab default_fstab;

    const std::string default_fstab_path = GetFstabPath();

    if (!default_fstab_path.empty() && ReadFstabFromFile(default_fstab_path, &default_fstab)) {

        for (auto&& entry : default_fstab) {

            fstab->emplace_back(std::move(entry));
@@ -936,6 +931,17 @@ std::string GetVerityDeviceName(const FstabEntry& entry) { 
    return base_device + "-verity";

}



bool InRecovery() {

    // Check the existence of recovery binary instead of using the compile time

    // __ANDROID_RECOVERY__ macro.

    // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot

    // mode would use the same init binary, which would mean during normal boot

    // the '/init' binary is actually a symlink pointing to

    // init_second_stage.recovery, which would be compiled with

    // __ANDROID_RECOVERY__ defined.

    return access("/system/bin/recovery", F_OK) == 0 || access("/sbin/recovery", F_OK) == 0;

}



}  // namespace fs_mgr

}  // namespace android

fs_mgr/fs_mgr_overlayfs_control.cpp

+12 −28
Original line number Diff line number Diff line
@@ -18,17 +18,10 @@ 
#include <errno.h>

#include <fcntl.h>

#include <linux/fs.h>

#include <selinux/selinux.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mount.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <sys/statvfs.h>

#include <sys/types.h>

#include <sys/utsname.h>

#include <sys/vfs.h>

#include <unistd.h>



#include <algorithm>
@@ -38,13 +31,9 @@ 
#include <vector>



#include <android-base/file.h>

#include <android-base/macros.h>

#include <android-base/properties.h>

#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <ext4_utils/ext4_utils.h>

#include <fs_mgr.h>

#include <fs_mgr/file_wait.h>

#include <fs_mgr_dm_linear.h>

#include <fs_mgr_overlayfs.h>

#include <fstab/fstab.h>
@@ -89,7 +78,7 @@ static bool ScratchIsOnData() { 
    if (fs_mgr_is_dsu_running()) {

        return false;

    }

    return fs_mgr_access(kScratchImageMetadata);

    return access(kScratchImageMetadata, F_OK) == 0;

}



static bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level = 0) {
@@ -198,10 +187,6 @@ static uint32_t fs_mgr_overlayfs_slot_number() { 
    return SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix());

}



static std::string fs_mgr_overlayfs_super_device(uint32_t slot_number) {

    return kPhysicalDevice + fs_mgr_get_super_partition_name(slot_number);

}



static bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {

    for (const auto& entry : fstab) {

        if (entry.fs_mgr_flags.logical) {
@@ -261,8 +246,8 @@ OverlayfsTeardownResult fs_mgr_overlayfs_teardown_scratch(const std::string& ove 
    }



    auto slot_number = fs_mgr_overlayfs_slot_number();

    auto super_device = fs_mgr_overlayfs_super_device(slot_number);

    if (!fs_mgr_rw_access(super_device)) {

    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();

    if (access(super_device.c_str(), R_OK | W_OK)) {

        return OverlayfsTeardownResult::Ok;

    }
@@ -295,7 +280,7 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string 
                                   bool* change, bool* should_destroy_scratch = nullptr) {

    const auto top = overlay + "/" + kOverlayTopDir;



    if (!fs_mgr_access(top)) {

    if (access(top.c_str(), F_OK)) {

        if (should_destroy_scratch) *should_destroy_scratch = true;

        return true;

    }
@@ -443,7 +428,7 @@ static bool CreateDynamicScratch(std::string* scratch_device, bool* partition_ex 


    auto partition_create = !*partition_exists;

    auto slot_number = fs_mgr_overlayfs_slot_number();

    auto super_device = fs_mgr_overlayfs_super_device(slot_number);

    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();

    auto builder = MetadataBuilder::New(super_device, slot_number);

    if (!builder) {

        LERROR << "open " << super_device << " metadata";
@@ -583,8 +568,8 @@ static bool CreateScratchOnData(std::string* scratch_device, bool* partition_exi 


static bool CanUseSuperPartition(const Fstab& fstab) {

    auto slot_number = fs_mgr_overlayfs_slot_number();

    auto super_device = fs_mgr_overlayfs_super_device(slot_number);

    if (!fs_mgr_rw_access(super_device) || !fs_mgr_overlayfs_has_logical(fstab)) {

    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();

    if (access(super_device.c_str(), R_OK | W_OK) || !fs_mgr_overlayfs_has_logical(fstab)) {

        return false;

    }

    auto metadata = ReadMetadata(super_device, slot_number);
@@ -634,8 +619,8 @@ bool fs_mgr_overlayfs_setup_scratch(const Fstab& fstab) { 
    // If the partition exists, assume first that it can be mounted.

    if (partition_exists) {

        if (MountScratch(scratch_device)) {

            if (fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir) ||

                fs_mgr_filesystem_has_space(kScratchMountPoint)) {

            const auto top = kScratchMountPoint + "/"s + kOverlayTopDir;

            if (access(top.c_str(), F_OK) == 0 || fs_mgr_filesystem_has_space(kScratchMountPoint)) {

                return true;

            }

            // declare it useless, no overrides and no free space
@@ -755,7 +740,7 @@ static std::optional<MapInfo> EnsureScratchMapped() { 
    if (!info.device.empty()) {

        return {std::move(info)};

    }

    if (!fs_mgr_in_recovery()) {

    if (!InRecovery()) {

        return {};

    }
@@ -778,8 +763,7 @@ static std::optional<MapInfo> EnsureScratchMapped() { 
    }



    // Avoid uart spam by first checking for a scratch partition.

    auto metadata_slot = fs_mgr_overlayfs_slot_number();

    auto super_device = fs_mgr_overlayfs_super_device(metadata_slot);

    const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();

    auto metadata = ReadCurrentMetadata(super_device);

    if (!metadata) {

        return {};
@@ -941,7 +925,7 @@ void TeardownAllOverlayForMountPoint(const std::string& mount_point) { 
    if (!OverlayfsTeardownAllowed()) {

        return;

    }

    if (!fs_mgr_in_recovery()) {

    if (!InRecovery()) {

        LERROR << __FUNCTION__ << "(): must be called within recovery.";

        return;

    }

fs_mgr/fs_mgr_overlayfs_control.h

+0 −2
Original line number Diff line number Diff line
@@ -14,8 +14,6 @@ 


#pragma once



#include <string>



#include <fstab/fstab.h>



// If "mount_point" is non-null, set up exactly one overlay.

fs_mgr/fs_mgr_overlayfs_mount.cpp

+13 −41
Original line number Diff line number Diff line
@@ -14,16 +14,12 @@ 
 * limitations under the License.

 */



#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <linux/fs.h>

#include <selinux/selinux.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/mount.h>

#include <sys/param.h>

#include <sys/stat.h>

#include <sys/statvfs.h>

#include <sys/types.h>
@@ -33,7 +29,6 @@ 


#include <algorithm>

#include <memory>

#include <optional>

#include <string>

#include <vector>
@@ -45,7 +40,6 @@ 
#include <ext4_utils/ext4_utils.h>

#include <fs_mgr.h>

#include <fs_mgr/file_wait.h>

#include <fs_mgr_dm_linear.h>

#include <fs_mgr_overlayfs.h>

#include <fstab/fstab.h>

#include <libdm/dm.h>
@@ -68,34 +62,15 @@ constexpr char kPhysicalDevice[] = "/dev/block/by-name/"; 
constexpr char kLowerdirOption[] = "lowerdir=";

constexpr char kUpperdirOption[] = "upperdir=";



bool fs_mgr_access(const std::string& path) {

    return access(path.c_str(), F_OK) == 0;

}



bool fs_mgr_in_recovery() {

    // Check the existence of recovery binary instead of using the compile time

    // __ANDROID_RECOVERY__ macro.

    // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot

    // mode would use the same init binary, which would mean during normal boot

    // the '/init' binary is actually a symlink pointing to

    // init_second_stage.recovery, which would be compiled with

    // __ANDROID_RECOVERY__ defined.

    return fs_mgr_access("/system/bin/recovery");

}



bool fs_mgr_is_dsu_running() {

    // Since android::gsi::CanBootIntoGsi() or android::gsi::MarkSystemAsGsi() is

    // never called in recovery, the return value of android::gsi::IsGsiRunning()

    // is not well-defined. In this case, just return false as being in recovery

    // implies not running a DSU system.

    if (fs_mgr_in_recovery()) return false;

    if (InRecovery()) return false;

    return android::gsi::IsGsiRunning();

}



static bool IsABDevice() {

    return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();

}



std::vector<const std::string> OverlayMountPoints() {

    // Never fallback to legacy cache mount point if within a DSU system,

    // because running a DSU system implies the device supports dynamic
@@ -106,7 +81,8 @@ std::vector<const std::string> OverlayMountPoints() { 


    // For non-A/B devices prefer cache backing storage if

    // kPreferCacheBackingStorageProp property set.

    if (!IsABDevice() && android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&

    if (fs_mgr_get_slot_suffix().empty() &&

        android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&

        android::base::GetIntProperty("ro.vendor.api_level", -1) < __ANDROID_API_T__) {

        return {kCacheMountPoint, kScratchMountPoint};

    }
@@ -119,11 +95,6 @@ static bool fs_mgr_is_dir(const std::string& path) { 
    return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);

}



bool fs_mgr_rw_access(const std::string& path) {

    if (path.empty()) return false;

    return access(path.c_str(), R_OK | W_OK) == 0;

}



// At less than 1% or 8MB of free space return value of false,

// means we will try to wrap with overlayfs.

bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
@@ -146,7 +117,7 @@ static bool fs_mgr_update_blk_device(FstabEntry* entry) { 
    if (entry->fs_mgr_flags.logical) {

        fs_mgr_update_logical_partition(entry);

    }

    if (fs_mgr_access(entry->blk_device)) {

    if (access(entry->blk_device.c_str(), F_OK) == 0) {

        return true;

    }

    if (entry->blk_device != "/dev/root") {
@@ -155,9 +126,9 @@ static bool fs_mgr_update_blk_device(FstabEntry* entry) { 


    // special case for system-as-root (taimen and others)

    auto blk_device = kPhysicalDevice + "system"s;

    if (!fs_mgr_access(blk_device)) {

    if (access(blk_device.c_str(), F_OK)) {

        blk_device += fs_mgr_get_slot_suffix();

        if (!fs_mgr_access(blk_device)) {

        if (access(blk_device.c_str(), F_OK)) {

            return false;

        }

    }
@@ -241,7 +212,7 @@ static std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point 
        if (!fs_mgr_is_dir(upper)) continue;

        auto work = dir + kWorkName;

        if (!fs_mgr_is_dir(work)) continue;

        if (!fs_mgr_rw_access(work)) continue;

        if (access(work.c_str(), R_OK | W_OK)) continue;

        return dir;

    }

    return "";
@@ -528,11 +499,11 @@ static bool fs_mgr_overlayfs_mount(const FstabEntry& entry) { 
// Mount kScratchMountPoint

bool MountScratch(const std::string& device_path, bool readonly) {

    if (readonly) {

        if (!fs_mgr_access(device_path)) {

        if (access(device_path.c_str(), F_OK)) {

            LOG(ERROR) << "Path does not exist: " << device_path;

            return false;

        }

    } else if (!fs_mgr_rw_access(device_path)) {

    } else if (access(device_path.c_str(), R_OK | W_OK)) {

        LOG(ERROR) << "Path does not exist or is not readwrite: " << device_path;

        return false;

    }
@@ -644,7 +615,7 @@ bool OverlayfsSetupAllowed(bool verbose) { 
        return false;

    }

    // in recovery or fastbootd, not allowed!

    if (fs_mgr_in_recovery()) {

    if (InRecovery()) {

        if (verbose) {

            LOG(ERROR) << "Unsupported overlayfs setup from recovery";

        }
@@ -724,7 +695,7 @@ static void TryMountScratch() { 
    // if verity is still disabled, i.e. no reboot occurred), and skips calling

    // fs_mgr_overlayfs_mount_all().

    auto scratch_device = GetBootScratchDevice();

    if (!fs_mgr_rw_access(scratch_device)) {

    if (access(scratch_device.c_str(), R_OK | W_OK)) {

        return;

    }

    if (!WaitForFile(scratch_device, 10s)) {
@@ -733,7 +704,8 @@ static void TryMountScratch() { 
    if (!MountScratch(scratch_device, true /* readonly */)) {

        return;

    }

    auto has_overlayfs_dir = fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir);

    const auto top = kScratchMountPoint + "/"s + kOverlayTopDir;

    const bool has_overlayfs_dir = access(top.c_str(), F_OK) == 0;

    fs_mgr_overlayfs_umount_scratch();

    if (has_overlayfs_dir) {

        MountScratch(scratch_device);

fs_mgr/fs_mgr_overlayfs_mount.h

+0 −3
Original line number Diff line number Diff line
@@ -49,9 +49,6 @@ class AutoSetFsCreateCon final { 
};



bool fs_mgr_is_dsu_running();

bool fs_mgr_in_recovery();

bool fs_mgr_access(const std::string& path);

bool fs_mgr_rw_access(const std::string& path);

bool fs_mgr_filesystem_has_space(const std::string& mount_point);

const std::string fs_mgr_mount_point(const std::string& mount_point);

bool OverlayfsSetupAllowed(bool verbose = false);