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

Commit 88ef0b1f authored by David Anderson's avatar David Anderson
Browse files

fastbootd: Add support for flashing logical partitions. 

When flashing logical partitions, we read the "super" partition metadata
corresponding to the current slot. We then temporarily create a
device-mapper device for that partition, and immediately destroy the
device after all operations are complete. We do not mount partitions
ahead of time, or keep them mounted, because a fastboot operation may
change the layout of the logical partition table (or change which slot
is current).

Bug: 78793464
Test: fastboot flash a logical partition under "super"
Change-Id: Id2a61d3592decabeebfd283c4fd6e6cbe576a18c
parent 12211d16

fastboot/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -114,6 +114,7 @@ cc_binary { 
        "libhidltransport",

        "libhwbinder",

        "liblog",

        "liblp",

        "libsparse",

        "libutils",

    ],

fastboot/device/flashing.cpp

+0 −1
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ 
#include <android-base/logging.h>

#include <android-base/strings.h>

#include <ext4_utils/ext4_utils.h>

#include <fs_mgr.h>

#include <sparse/sparse.h>



#include "fastboot_device.h"

fastboot/device/utility.cpp

+60 −2
Original line number Diff line number Diff line
@@ -17,9 +17,12 @@ 
#include "utility.h"



#include <android-base/logging.h>

#include <fs_mgr_dm_linear.h>

#include <liblp/liblp.h>



#include "fastboot_device.h"



using namespace android::fs_mgr;

using android::base::unique_fd;

using android::hardware::boot::V1_0::Slot;
@@ -32,8 +35,31 @@ static bool OpenPhysicalPartition(const std::string& name, PartitionHandle* hand 
    return true;

}



bool OpenPartition(FastbootDevice* /* device */, const std::string& name, PartitionHandle* handle) {

    if (!OpenPhysicalPartition(name, handle)) {

static bool OpenLogicalPartition(const std::string& name, const std::string& slot,

                                 PartitionHandle* handle) {

    std::optional<std::string> path = FindPhysicalPartition(LP_METADATA_PARTITION_NAME);

    if (!path) {

        return false;

    }

    uint32_t slot_number = SlotNumberForSlotSuffix(slot);

    std::string dm_path;

    if (!CreateLogicalPartition(path->c_str(), slot_number, name, true, &dm_path)) {

        LOG(ERROR) << "Could not map partition: " << name;

        return false;

    }

    auto closer = [name]() -> void { DestroyLogicalPartition(name); };

    *handle = PartitionHandle(dm_path, std::move(closer));

    return true;

}



bool OpenPartition(FastbootDevice* device, const std::string& name, PartitionHandle* handle) {

    // We prioritize logical partitions over physical ones, and do this

    // consistently for other partition operations (like getvar:partition-size).

    if (LogicalPartitionExists(name, device->GetCurrentSlot())) {

        if (!OpenLogicalPartition(name, device->GetCurrentSlot(), handle)) {

            return false;

        }

    } else if (!OpenPhysicalPartition(name, handle)) {

        LOG(ERROR) << "No such partition: " << name;

        return false;

    }
@@ -55,6 +81,38 @@ std::optional<std::string> FindPhysicalPartition(const std::string& name) { 
    return path;

}



static const LpMetadataPartition* FindLogicalPartition(const LpMetadata& metadata,

                                                       const std::string& name) {

    for (const auto& partition : metadata.partitions) {

        if (GetPartitionName(partition) == name) {

            return &partition;

        }

    }

    return nullptr;

}



bool LogicalPartitionExists(const std::string& name, const std::string& slot_suffix,

                            bool* is_zero_length) {

    auto path = FindPhysicalPartition(LP_METADATA_PARTITION_NAME);

    if (!path) {

        return false;

    }



    uint32_t slot_number = SlotNumberForSlotSuffix(slot_suffix);

    std::unique_ptr<LpMetadata> metadata = ReadMetadata(path->c_str(), slot_number);

    if (!metadata) {

        return false;

    }

    const LpMetadataPartition* partition = FindLogicalPartition(*metadata.get(), name);

    if (!partition) {

        return false;

    }

    if (is_zero_length) {

        *is_zero_length = (partition->num_extents == 0);

    }

    return true;

}



bool GetSlotNumber(const std::string& slot, Slot* number) {

    if (slot.size() != 1) {

        return false;

fastboot/device/utility.h

+14 −0
Original line number Diff line number Diff line
@@ -29,6 +29,17 @@ class PartitionHandle { 
  public:

    PartitionHandle() {}

    explicit PartitionHandle(const std::string& path) : path_(path) {}

    PartitionHandle(const std::string& path, std::function<void()>&& closer)

        : path_(path), closer_(std::move(closer)) {}

    PartitionHandle(PartitionHandle&& other) = default;

    PartitionHandle& operator=(PartitionHandle&& other) = default;

    ~PartitionHandle() {

        if (closer_) {

            // Make sure the device is closed first.

            fd_ = {};

            closer_();

        }

    }

    const std::string& path() const { return path_; }

    int fd() const { return fd_.get(); }

    void set_fd(android::base::unique_fd&& fd) { fd_ = std::move(fd); }
@@ -36,11 +47,14 @@ class PartitionHandle { 
  private:

    std::string path_;

    android::base::unique_fd fd_;

    std::function<void()> closer_;

};



class FastbootDevice;



std::optional<std::string> FindPhysicalPartition(const std::string& name);

bool LogicalPartitionExists(const std::string& name, const std::string& slot_suffix,

                            bool* is_zero_length = nullptr);

bool OpenPartition(FastbootDevice* device, const std::string& name, PartitionHandle* handle);



bool GetSlotNumber(const std::string& slot, android::hardware::boot::V1_0::Slot* number);

fastboot/device/variables.cpp

+8 −0
Original line number Diff line number Diff line
@@ -133,6 +133,14 @@ bool GetPartitionSize(FastbootDevice* device, const std::vector<std::string>& ar 
    if (args.size() < 1) {

        return device->WriteFail("Missing argument");

    }

    // Zero-length partitions cannot be created through device-mapper, so we

    // special case them here.

    bool is_zero_length;

    if (LogicalPartitionExists(args[0], device->GetCurrentSlot(), &is_zero_length) &&

        is_zero_length) {

        return device->WriteOkay("0");

    }

    // Otherwise, open the partition as normal.

    PartitionHandle handle;

    if (!OpenPartition(device, args[0], &handle)) {

        return device->WriteFail("Could not open partition");