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

Commit e6d71689 authored by Howard Chen's avatar Howard Chen Committed by Gerrit Code Review
Browse files

Merge "Mount multiple DSU partitions when present."

parents e71efc3d 1b094939

fs_mgr/fs_mgr_fstab.cpp

+89 −27
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 


#include "fs_mgr_priv.h"



using android::base::EndsWith;

using android::base::ParseByteCount;

using android::base::ParseInt;

using android::base::ReadFileToString;
@@ -598,7 +599,7 @@ std::set<std::string> ExtraBootDevices(const Fstab& fstab) { 
    return boot_devices;

}



FstabEntry BuildGsiUserdataFstabEntry() {

FstabEntry BuildDsuUserdataFstabEntry() {

    constexpr uint32_t kFlags = MS_NOATIME | MS_NOSUID | MS_NODEV;



    FstabEntry userdata = {
@@ -627,7 +628,12 @@ bool EraseFstabEntry(Fstab* fstab, const std::string& mount_point) { 
    return false;

}



void TransformFstabForGsi(Fstab* fstab) {

}  // namespace



void TransformFstabForDsu(Fstab* fstab, const std::vector<std::string>& dsu_partitions) {

    static constexpr char kGsiKeys[] =

            "/avb/q-gsi.avbpubkey:/avb/r-gsi.avbpubkey:/avb/s-gsi.avbpubkey";

    // Convert userdata

    // Inherit fstab properties for userdata.

    FstabEntry userdata;

    if (FstabEntry* entry = GetEntryForMountPoint(fstab, "/data")) {
@@ -639,19 +645,75 @@ void TransformFstabForGsi(Fstab* fstab) { 
            userdata.key_dir += "/gsi";

        }

    } else {

        userdata = BuildGsiUserdataFstabEntry();

    }



    if (EraseFstabEntry(fstab, "/system")) {

        fstab->emplace_back(BuildGsiSystemFstabEntry());

        userdata = BuildDsuUserdataFstabEntry();

    }



    if (EraseFstabEntry(fstab, "/data")) {

        fstab->emplace_back(userdata);

    }

}



}  // namespace

    // Convert others

    for (auto&& partition : dsu_partitions) {

        if (!EndsWith(partition, gsi::kDsuPostfix)) {

            continue;

        }

        // userdata has been handled

        if (StartsWith(partition, "user")) {

            continue;

        }

        // dsu_partition_name = corresponding_partition_name + kDsuPostfix

        // e.g.

        //    system_gsi for system

        //    product_gsi for product

        //    vendor_gsi for vendor

        std::string lp_name = partition.substr(0, partition.length() - strlen(gsi::kDsuPostfix));

        std::string mount_point = "/" + lp_name;

        std::vector<FstabEntry*> entries = GetEntriesForMountPoint(fstab, mount_point);

        if (entries.empty()) {

            FstabEntry entry = {

                    .blk_device = partition,

                    .mount_point = mount_point,

                    .fs_type = "ext4",

                    .flags = MS_RDONLY,

                    .fs_options = "barrier=1",

                    .avb_keys = kGsiKeys,

                    // .logical_partition_name is required to look up AVB Hashtree descriptors.

                    .logical_partition_name = "system"};

            entry.fs_mgr_flags.wait = true;

            entry.fs_mgr_flags.logical = true;

            entry.fs_mgr_flags.first_stage_mount = true;

            // Use the system key which may be in the vbmeta or vbmeta_system

            // TODO: b/141284191

            entry.vbmeta_partition = "vbmeta";

            fstab->emplace_back(entry);

            entry.vbmeta_partition = "vbmeta_system";

            fstab->emplace_back(entry);

        } else {

            // If the corresponding partition exists, transform all its Fstab

            // by pointing .blk_device to the DSU partition.

            for (auto&& entry : entries) {

                entry->blk_device = partition;

                if (entry->avb_keys.size() > 0) {

                    entry->avb_keys += ":";

                }

                // If the DSU is signed by OEM, the original Fstab already has the information

                // required by avb, otherwise the DSU is GSI and will need the avb_keys as listed

                // below.

                entry->avb_keys += kGsiKeys;

            }

            // Make sure the ext4 is included to support GSI.

            auto partition_ext4 =

                    std::find_if(fstab->begin(), fstab->end(), [&](const auto& entry) {

                        return entry.mount_point == mount_point && entry.fs_type == "ext4";

                    });

            if (partition_ext4 == fstab->end()) {

                auto new_entry = *GetEntryForMountPoint(fstab, mount_point);

                new_entry.fs_type = "ext4";

                fstab->emplace_back(new_entry);

            }

        }

    }

}



bool ReadFstabFromFile(const std::string& path, Fstab* fstab) {

    auto fstab_file = std::unique_ptr<FILE, decltype(&fclose)>{fopen(path.c_str(), "re"), fclose};
@@ -667,7 +729,9 @@ bool ReadFstabFromFile(const std::string& path, Fstab* fstab) { 
        return false;

    }

    if (!is_proc_mounts && !access(android::gsi::kGsiBootedIndicatorFile, F_OK)) {

        TransformFstabForGsi(fstab);

        std::string lp_names;

        ReadFileToString(gsi::kGsiLpNamesFile, &lp_names);

        TransformFstabForDsu(fstab, Split(lp_names, ","));

    }



    SkipMountingPartitions(fstab);
@@ -779,6 +843,21 @@ FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string& path) { 
    return nullptr;

}



std::vector<FstabEntry*> GetEntriesForMountPoint(Fstab* fstab, const std::string& path) {

    std::vector<FstabEntry*> entries;

    if (fstab == nullptr) {

        return entries;

    }



    for (auto& entry : *fstab) {

        if (entry.mount_point == path) {

            entries.emplace_back(&entry);

        }

    }



    return entries;

}



std::set<std::string> GetBootDevices() {

    // First check the kernel commandline, then try the device tree otherwise

    std::string dt_file_name = get_android_dt_dir() + "/boot_devices";
@@ -798,23 +877,6 @@ std::set<std::string> GetBootDevices() { 
    return ExtraBootDevices(fstab);

}



FstabEntry BuildGsiSystemFstabEntry() {

    // .logical_partition_name is required to look up AVB Hashtree descriptors.

    FstabEntry system = {

            .blk_device = "system_gsi",

            .mount_point = "/system",

            .fs_type = "ext4",

            .flags = MS_RDONLY,

            .fs_options = "barrier=1",

            // could add more keys separated by ':'.

            .avb_keys = "/avb/q-gsi.avbpubkey:/avb/r-gsi.avbpubkey:/avb/s-gsi.avbpubkey",

            .logical_partition_name = "system"};

    system.fs_mgr_flags.wait = true;

    system.fs_mgr_flags.logical = true;

    system.fs_mgr_flags.first_stage_mount = true;

    return system;

}



std::string GetVerityDeviceName(const FstabEntry& entry) {

    std::string base_device;

    if (entry.mount_point == "/") {

fs_mgr/include_fstab/fstab/fstab.h

+11 −2
Original line number Diff line number Diff line
@@ -101,9 +101,18 @@ bool ReadDefaultFstab(Fstab* fstab); 
bool SkipMountingPartitions(Fstab* fstab);



FstabEntry* GetEntryForMountPoint(Fstab* fstab, const std::string& path);

// The Fstab can contain multiple entries for the same mount point with different configurations.

std::vector<FstabEntry*> GetEntriesForMountPoint(Fstab* fstab, const std::string& path);



// Helper method to build a GSI fstab entry for mounting /system.

FstabEntry BuildGsiSystemFstabEntry();

// This method builds DSU fstab entries and transfer the fstab.

//

// fstab points to the unmodified fstab.

//

// dsu_partitions contains partition names, e.g.

//     dsu_partitions[0] = "system_gsi"

//     dsu_partitions[1] = "userdata_gsi"

//     dsu_partitions[2] = ...

void TransformFstabForDsu(Fstab* fstab, const std::vector<std::string>& dsu_partitions);



std::set<std::string> GetBootDevices();

init/first_stage_mount.cpp

+14 −11
Original line number Diff line number Diff line
@@ -50,12 +50,13 @@ using android::fs_mgr::AvbHandle; 
using android::fs_mgr::AvbHandleStatus;

using android::fs_mgr::AvbHashtreeResult;

using android::fs_mgr::AvbUniquePtr;

using android::fs_mgr::BuildGsiSystemFstabEntry;

using android::fs_mgr::Fstab;

using android::fs_mgr::FstabEntry;

using android::fs_mgr::ReadDefaultFstab;

using android::fs_mgr::ReadFstabFromDt;

using android::fs_mgr::SkipMountingPartitions;

using android::fs_mgr::TransformFstabForDsu;

using android::init::WriteFile;

using android::snapshot::SnapshotManager;



using namespace std::literals;
@@ -596,14 +597,14 @@ bool FirstStageMount::MountPartitions() { 
}



void FirstStageMount::UseGsiIfPresent() {

    std::string metadata_file, error;

    std::string error;



    if (!android::gsi::CanBootIntoGsi(&metadata_file, &error)) {

    if (!android::gsi::CanBootIntoGsi(&error)) {

        LOG(INFO) << "GSI " << error << ", proceeding with normal boot";

        return;

    }



    auto metadata = android::fs_mgr::ReadFromImageFile(metadata_file.c_str());

    auto metadata = android::fs_mgr::ReadFromImageFile(gsi::kDsuLpMetadataFile);

    if (!metadata) {

        LOG(ERROR) << "GSI partition layout could not be read";

        return;
@@ -627,14 +628,16 @@ void FirstStageMount::UseGsiIfPresent() { 
        return;

    }



    // Replace the existing system fstab entry.

    auto system_partition = std::find_if(fstab_.begin(), fstab_.end(), [](const auto& entry) {

        return entry.mount_point == "/system";

    });

    if (system_partition != fstab_.end()) {

        fstab_.erase(system_partition);

    std::string lp_names = "";

    std::vector<std::string> dsu_partitions;

    for (auto&& partition : metadata->partitions) {

        auto name = fs_mgr::GetPartitionName(partition);

        dsu_partitions.push_back(name);

        lp_names += name + ",";

    }

    fstab_.emplace_back(BuildGsiSystemFstabEntry());

    // Publish the logical partition names for TransformFstabForDsu

    WriteFile(gsi::kGsiLpNamesFile, lp_names);

    TransformFstabForDsu(&fstab_, dsu_partitions);

    gsi_not_on_userdata_ = (super_name != "userdata");

}