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

Commit 69ebd440 authored by Mark Salyzyn's avatar Mark Salyzyn
Browse files

fs_mgr: overlayfs create scratch using a Dynamic Logical Partition 

The default is a valid /mnt/scratch/overlay/ or /cache/overlay/
directory, with .../<mount_point>/upper and .../<mount_point>/work,
associated with each system partition <mount_point>.  Add support
for Dynamically Resized Partitions to create /mnt/scratch.

Test: manual
Bug: 109821005
Change-Id: I5e3f66778ea9e937c839e25541fedb6fbf34ab50
parent b5ca7281

fs_mgr/fs_mgr_overlayfs.cpp

+277 −25
Original line number Diff line number Diff line
@@ -41,14 +41,18 @@ 
#include <android-base/strings.h>

#include <android-base/unique_fd.h>

#include <ext4_utils/ext4_utils.h>

#include <fs_mgr_dm_linear.h>

#include <fs_mgr_overlayfs.h>

#include <fstab/fstab.h>

#include <libdm/dm.h>

#include <liblp/builder.h>

#include <liblp/liblp.h>



#include "fs_mgr_priv.h"



using namespace std::literals;

using namespace android::dm;

using namespace android::fs_mgr;



#if ALLOW_ADBD_DISABLE_VERITY == 0  // If we are a user build, provide stubs
@@ -74,8 +78,10 @@ bool fs_mgr_overlayfs_teardown(const char*, bool* change) { 


namespace {



// acceptable overlayfs backing storage

const auto kOverlayMountPoint = "/cache"s;

// list of acceptable overlayfs backing storage

const auto kScratchMountPoint = "/mnt/scratch"s;

const auto kCacheMountPoint = "/cache"s;

const std::vector<const std::string> kOverlayMountPoints = {kScratchMountPoint, kCacheMountPoint};



// Return true if everything is mounted, but before adb is started.  Right

// after 'trigger load_persist_props_action' is done.
@@ -136,15 +142,18 @@ const auto kOverlayTopDir = "/overlay"s; 


std::string fs_mgr_get_overlayfs_candidate(const std::string& mount_point) {

    if (!fs_mgr_is_dir(mount_point)) return "";

    auto dir =

            kOverlayMountPoint + kOverlayTopDir + "/" + android::base::Basename(mount_point) + "/";

    const auto base = android::base::Basename(mount_point) + "/";

    for (const auto& overlay_mount_point : kOverlayMountPoints) {

        auto dir = overlay_mount_point + kOverlayTopDir + "/" + base;

        auto upper = dir + kUpperName;

    if (!fs_mgr_is_dir(upper)) return "";

        if (!fs_mgr_is_dir(upper)) continue;

        auto work = dir + kWorkName;

    if (!fs_mgr_is_dir(work)) return "";

    if (!fs_mgr_dir_is_writable(work)) return "";

        if (!fs_mgr_is_dir(work)) continue;

        if (!fs_mgr_dir_is_writable(work)) continue;

        return dir;

    }

    return "";

}



const auto kLowerdirOption = "lowerdir="s;

const auto kUpperdirOption = "upperdir="s;
@@ -187,6 +196,14 @@ bool fs_mgr_access(const std::string& path) { 
    return ret;

}



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

    if (path.empty()) return false;

    auto save_errno = errno;

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

    errno = save_errno;

    return ret;

}



// return true if system supports overlayfs

bool fs_mgr_wants_overlayfs() {

    // Properties will return empty on init first_stage_mount, so speculative
@@ -200,7 +217,7 @@ bool fs_mgr_wants_overlayfs() { 
    return fs_mgr_access("/sys/module/overlay/parameters/override_creds");

}



bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point) {

bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point, bool overlay_only = true) {

    std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab("/proc/mounts"),

                                                               fs_mgr_free_fstab);

    if (!fstab) return false;
@@ -209,10 +226,11 @@ bool fs_mgr_overlayfs_already_mounted(const std::string& mount_point) { 
        const auto fsrec = &fstab->recs[i];

        const auto fs_type = fsrec->fs_type;

        if (!fs_type) continue;

        if (("overlay"s != fs_type) && ("overlayfs"s != fs_type)) continue;

        if (overlay_only && ("overlay"s != fs_type) && ("overlayfs"s != fs_type)) continue;

        auto fsrec_mount_point = fsrec->mount_point;

        if (!fsrec_mount_point) continue;

        if (mount_point != fsrec_mount_point) continue;

        if (!overlay_only) return true;

        const auto fs_options = fsrec->fs_options;

        if (!fs_options) continue;

        const auto options = android::base::Split(fs_options, ",");
@@ -373,6 +391,67 @@ bool fs_mgr_overlayfs_setup_one(const std::string& overlay, const std::string& m 
    return ret;

}



uint32_t fs_mgr_overlayfs_slot_number() {

    return SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix());

}



std::string fs_mgr_overlayfs_super_device(uint32_t slot_number) {

    return "/dev/block/by-name/" + fs_mgr_get_super_partition_name(slot_number);

}



bool fs_mgr_overlayfs_has_logical(const fstab* fstab) {

    if (!fstab) return false;

    for (auto i = 0; i < fstab->num_entries; i++) {

        const auto fsrec = &fstab->recs[i];

        if (fs_mgr_is_logical(fsrec)) return true;

    }

    return false;

}



// reduce 'DM_DEV_STATUS failed for scratch: No such device or address' noise

std::string scratch_device_cache;



bool fs_mgr_overlayfs_teardown_scratch(const std::string& overlay, bool* change) {

    // umount and delete kScratchMountPoint storage if we have logical partitions

    if (overlay != kScratchMountPoint) return true;

    scratch_device_cache.erase();

    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)) return true;



    auto save_errno = errno;

    if (fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false)) {

        // Lazy umount will allow us to move on and possibly later

        // establish a new fresh mount without requiring a reboot should

        // the developer wish to restart.  Old references should melt

        // away or have no data.  Main goal is to shut the door on the

        // current overrides with an expectation of a subsequent reboot,

        // thus any errors here are ignored.

        umount2(kScratchMountPoint.c_str(), MNT_DETACH);

    }

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

    if (!builder) {

        errno = save_errno;

        return true;

    }

    const auto partition_name = android::base::Basename(kScratchMountPoint);

    if (builder->FindPartition(partition_name) == nullptr) {

        errno = save_errno;

        return true;

    }

    builder->RemovePartition(partition_name);

    auto metadata = builder->Export();

    if (metadata && UpdatePartitionTable(super_device, *metadata.get(), slot_number)) {

        if (change) *change = true;

        if (!DestroyLogicalPartition(partition_name, 0s)) return false;

    } else {

        PERROR << "delete partition " << overlay;

        return false;

    }

    errno = save_errno;

    return true;

}



bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string& mount_point,

                                   bool* change) {

    const auto top = overlay + kOverlayTopDir;
@@ -406,13 +485,16 @@ bool fs_mgr_overlayfs_teardown_one(const std::string& overlay, const std::string 
        save_errno = errno;

        if (!rmdir(top.c_str())) {

            if (change) *change = true;

            cleanup_all = true;

        } else if ((errno != ENOENT) && (errno != ENOTEMPTY)) {

            ret = false;

            PERROR << "rmdir " << top;

        } else {

            errno = save_errno;

            cleanup_all = true;

        }

    }

    if (cleanup_all) ret &= fs_mgr_overlayfs_teardown_scratch(overlay, change);

    return ret;

}
@@ -504,6 +586,138 @@ std::vector<std::string> fs_mgr_candidate_list(const fstab* fstab, 
    return mounts;

}



// Mount kScratchMountPoint

bool fs_mgr_overlayfs_mount_scratch(const std::string& device_path, const std::string mnt_type) {

    if (setfscreatecon(kOverlayfsFileContext)) {

        PERROR << "setfscreatecon " << kOverlayfsFileContext;

    }

    if (mkdir(kScratchMountPoint.c_str(), 0755) && (errno != EEXIST)) {

        PERROR << "create " << kScratchMountPoint;

    }



    std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> local_fstab(

            static_cast<fstab*>(calloc(1, sizeof(fstab))), fs_mgr_free_fstab);

    auto fsrec = static_cast<fstab_rec*>(calloc(1, sizeof(fstab_rec)));

    local_fstab->num_entries = 1;

    local_fstab->recs = fsrec;

    fsrec->blk_device = strdup(device_path.c_str());

    fsrec->mount_point = strdup(kScratchMountPoint.c_str());

    fsrec->fs_type = strdup(mnt_type.c_str());

    fsrec->flags = MS_RELATIME;

    fsrec->fs_options = strdup("");

    auto mounted = fs_mgr_do_mount_one(fsrec) == 0;

    auto save_errno = errno;

    setfscreatecon(nullptr);

    if (!mounted) rmdir(kScratchMountPoint.c_str());

    errno = save_errno;

    return mounted;

}



const std::string kMkF2fs("/system/bin/make_f2fs");

const std::string kMkExt4("/system/bin/mke2fs");



std::string fs_mgr_overlayfs_scratch_mount_type() {

    if (!access(kMkF2fs.c_str(), X_OK)) return "f2fs";

    if (!access(kMkExt4.c_str(), X_OK)) return "ext4";

    return "auto";

}



std::string fs_mgr_overlayfs_scratch_device() {

    if (!scratch_device_cache.empty()) return scratch_device_cache;



    auto& dm = DeviceMapper::Instance();

    const auto partition_name = android::base::Basename(kScratchMountPoint);

    std::string path;

    if (!dm.GetDmDevicePathByName(partition_name, &path)) return "";

    return scratch_device_cache = path;

}



// Create and mount kScratchMountPoint storage if we have logical partitions

bool fs_mgr_overlayfs_setup_scratch(const fstab* fstab, bool* change) {

    if (fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false)) return true;

    auto mnt_type = fs_mgr_overlayfs_scratch_mount_type();

    auto scratch_device = fs_mgr_overlayfs_scratch_device();

    auto partition_exists = fs_mgr_rw_access(scratch_device);

    if (!partition_exists) {

        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)) return false;

        if (!fs_mgr_overlayfs_has_logical(fstab)) return false;

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

        if (!builder) {

            PERROR << "open " << super_device << " metadata";

            return false;

        }

        const auto partition_name = android::base::Basename(kScratchMountPoint);

        partition_exists = builder->FindPartition(partition_name) != nullptr;

        if (!partition_exists) {

            auto partition = builder->AddPartition(partition_name, LP_PARTITION_ATTR_NONE);

            if (!partition) {

                PERROR << "create " << partition_name;

                return false;

            }

            auto partition_size = builder->AllocatableSpace() - builder->UsedSpace();

            // 512MB or half the remaining available space, whichever is greater.

            partition_size = std::max(uint64_t(512 * 1024 * 1024), partition_size / 2);

            if (!builder->ResizePartition(partition, partition_size)) {

                PERROR << "resize " << partition_name;

                return false;

            }



            auto metadata = builder->Export();

            if (!metadata) {

                LERROR << "generate new metadata " << partition_name;

                return false;

            }

            if (!UpdatePartitionTable(super_device, *metadata.get(), slot_number)) {

                LERROR << "update " << partition_name;

                return false;

            }



            if (change) *change = true;

        }



        if (!CreateLogicalPartition(super_device, slot_number, partition_name, true, 0s,

                                    &scratch_device))

            return false;

    }



    if (partition_exists) {

        if (fs_mgr_overlayfs_mount_scratch(scratch_device, mnt_type)) {

            if (change) *change = true;

            return true;

        }

        // partition existed, but was not initialized;

        errno = 0;

    }



    auto ret = system((mnt_type == "f2fs")

                              ? ((kMkF2fs + " -d1 " + scratch_device).c_str())

                              : ((kMkExt4 + " -b 4096 -t ext4 -m 0 -M "s + kScratchMountPoint +

                                  " -O has_journal " + scratch_device)

                                         .c_str()));

    if (ret) {

        LERROR << "make " << mnt_type << " filesystem on " << scratch_device << " error=" << ret;

        return false;

    }



    if (change) *change = true;



    return fs_mgr_overlayfs_mount_scratch(scratch_device, mnt_type);

}



bool fs_mgr_overlayfs_scratch_can_be_mounted(const std::string& scratch_device) {

    if (scratch_device.empty()) return false;

    if (fs_mgr_overlayfs_already_mounted(kScratchMountPoint, false)) return false;

    if (fs_mgr_rw_access(scratch_device)) return true;

    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)) return false;

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

    if (!builder) return false;

    return builder->FindPartition(android::base::Basename(kScratchMountPoint)) != nullptr;

}



}  // namespace



bool fs_mgr_overlayfs_mount_all(const fstab* fstab) {
@@ -513,14 +727,37 @@ bool fs_mgr_overlayfs_mount_all(const fstab* fstab) { 


    if (!fstab) return ret;



    auto scratch_can_be_mounted = true;

    for (const auto& mount_point : fs_mgr_candidate_list(fstab)) {

        if (fs_mgr_overlayfs_already_mounted(mount_point)) continue;

        if (scratch_can_be_mounted) {

            scratch_can_be_mounted = false;

            auto scratch_device = fs_mgr_overlayfs_scratch_device();

            if (fs_mgr_overlayfs_scratch_can_be_mounted(scratch_device) &&

                fs_mgr_wait_for_file(scratch_device, 10s) &&

                fs_mgr_overlayfs_mount_scratch(scratch_device,

                                               fs_mgr_overlayfs_scratch_mount_type()) &&

                !fs_mgr_access(kScratchMountPoint + kOverlayTopDir)) {

                umount2(kScratchMountPoint.c_str(), MNT_DETACH);

                rmdir(kScratchMountPoint.c_str());

            }

        }

        if (fs_mgr_overlayfs_mount(mount_point)) ret = true;

    }

    return ret;

}



std::vector<std::string> fs_mgr_overlayfs_required_devices(const fstab*) {

std::vector<std::string> fs_mgr_overlayfs_required_devices(const fstab* fstab) {

    if (fs_mgr_get_entry_for_mount_point(const_cast<struct fstab*>(fstab), kScratchMountPoint)) {

        return {};

    }



    for (const auto& mount_point : fs_mgr_candidate_list(fstab)) {

        if (fs_mgr_overlayfs_already_mounted(mount_point)) continue;

        auto device = fs_mgr_overlayfs_scratch_device();

        if (!fs_mgr_overlayfs_scratch_can_be_mounted(device)) break;

        return {device};

    }

    return {};

}
@@ -529,10 +766,6 @@ std::vector<std::string> fs_mgr_overlayfs_required_devices(const fstab*) { 
bool fs_mgr_overlayfs_setup(const char* backing, const char* mount_point, bool* change) {

    if (change) *change = false;

    auto ret = false;

    if (backing && (kOverlayMountPoint != backing)) {

        errno = EINVAL;

        return ret;

    }

    if (!fs_mgr_wants_overlayfs()) return ret;

    if (!fs_mgr_boot_completed()) {

        errno = EBUSY;
@@ -542,16 +775,32 @@ bool fs_mgr_overlayfs_setup(const char* backing, const char* mount_point, bool* 


    std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab_default(),

                                                               fs_mgr_free_fstab);

    if (fstab && !fs_mgr_get_entry_for_mount_point(fstab.get(), kOverlayMountPoint)) return ret;

    if (!fstab) return ret;

    auto mounts = fs_mgr_candidate_list(fstab.get(), fs_mgr_mount_point(fstab.get(), mount_point));

    if (fstab && mounts.empty()) return ret;

    if (mounts.empty()) return ret;



    std::string dir;

    for (const auto& overlay_mount_point : kOverlayMountPoints) {

        if (backing && backing[0] && (overlay_mount_point != backing)) continue;

        if (overlay_mount_point == kScratchMountPoint) {

            if (!fs_mgr_rw_access(fs_mgr_overlayfs_super_device(fs_mgr_overlayfs_slot_number())) ||

                !fs_mgr_overlayfs_has_logical(fstab.get())) {

                continue;

            }

            if (!fs_mgr_overlayfs_setup_scratch(fstab.get(), change)) continue;

        } else {

            if (!fs_mgr_get_entry_for_mount_point(fstab.get(), overlay_mount_point)) continue;

        }

        dir = overlay_mount_point;

        break;

    }

    if (dir.empty()) {

        errno = ESRCH;

        return ret;

    }



    std::string overlay;

    ret |= fs_mgr_overlayfs_setup_dir(kOverlayMountPoint, &overlay, change);



    if (!fstab && mount_point && fs_mgr_overlayfs_setup_one(overlay, mount_point, change)) {

        ret = true;

    }

    ret |= fs_mgr_overlayfs_setup_dir(dir, &overlay, change);

    for (const auto& fsrec_mount_point : mounts) {

        ret |= fs_mgr_overlayfs_setup_one(overlay, fsrec_mount_point, change);

    }
@@ -566,7 +815,10 @@ bool fs_mgr_overlayfs_teardown(const char* mount_point, bool* change) { 
                                             fs_mgr_read_fstab_default(), fs_mgr_free_fstab)

                                             .get(),

                                     mount_point);

    auto ret = fs_mgr_overlayfs_teardown_one(kOverlayMountPoint, mount_point ?: "", change);

    auto ret = true;

    for (const auto& overlay_mount_point : kOverlayMountPoints) {

        ret &= fs_mgr_overlayfs_teardown_one(overlay_mount_point, mount_point ?: "", change);

    }

    if (!fs_mgr_wants_overlayfs()) {

        // After obligatory teardown to make sure everything is clean, but if

        // we didn't want overlayfs in the the first place, we do not want to