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
diff --git a/fastboot/Android.bp b/fastboot/Android.bp
index 19f6390..9995052 100644
--- a/fastboot/Android.bp
+++ b/fastboot/Android.bp
@@ -114,6 +114,7 @@
"libhidltransport",
"libhwbinder",
"liblog",
+ "liblp",
"libsparse",
"libutils",
],
diff --git a/fastboot/device/flashing.cpp b/fastboot/device/flashing.cpp
index d3dd82c..b5ed170 100644
--- a/fastboot/device/flashing.cpp
+++ b/fastboot/device/flashing.cpp
@@ -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"
diff --git a/fastboot/device/utility.cpp b/fastboot/device/utility.cpp
index 73cf1bf..ec84576 100644
--- a/fastboot/device/utility.cpp
+++ b/fastboot/device/utility.cpp
@@ -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 @@
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 @@
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;
diff --git a/fastboot/device/utility.h b/fastboot/device/utility.h
index 26f486b..0931fc3 100644
--- a/fastboot/device/utility.h
+++ b/fastboot/device/utility.h
@@ -29,6 +29,17 @@
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 @@
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);
diff --git a/fastboot/device/variables.cpp b/fastboot/device/variables.cpp
index 8f66fea..b51b985 100644
--- a/fastboot/device/variables.cpp
+++ b/fastboot/device/variables.cpp
@@ -133,6 +133,14 @@
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");