Merge "liblp: Remove the guid field from LpMetadataPartition." (ba132f19) · Commits · e / os / android_system_core

fastboot/device/commands.cpp

+1 −7

Original line number	Diff line number	Diff line
		@@ -353,13 +353,7 @@ bool CreatePartitionHandler(FastbootDevice* device, const std::vector<std::strin
		return device->WriteFail("Partition already exists");
		}

		// Make a random UUID, since they're not currently used.
		uuid_t uuid;
		char uuid_str[37];
		uuid_generate_random(uuid);
		uuid_unparse(uuid, uuid_str);

		Partition* partition = builder->AddPartition(partition_name, uuid_str, 0);
		Partition* partition = builder->AddPartition(partition_name, 0);
		if (!partition) {
		return device->WriteFail("Failed to add partition");
		}

fastboot/device/flashing.cpp

+1 −2

Original line number	Diff line number	Diff line
		@@ -146,8 +146,7 @@ bool UpdateSuper(FastbootDevice* device, const std::string& partition_name, bool
		if (builder->FindPartition(name)) {
		continue;
		}
		std::string guid = GetPartitionGuid(partition);
		if (!builder->AddPartition(name, guid, partition.attributes)) {
		if (!builder->AddPartition(name, partition.attributes)) {
		return device->WriteFail("Unable to add partition: " + name);
		}
		}

fs_mgr/liblp/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -35,7 +35,6 @@ cc_library {
		"libcrypto",
		"libcrypto_utils",
		"libsparse",
		"libext2_uuid",
		"libext4_utils",
		"libz",
		],

fs_mgr/liblp/builder.cpp

+8 −17

Original line number	Diff line number	Diff line
		@@ -25,7 +25,6 @@
		#include <algorithm>

		#include <android-base/unique_fd.h>
		#include <uuid/uuid.h>

		#include "liblp/liblp.h"
		#include "reader.h"
		@@ -79,9 +78,8 @@ void ZeroExtent::AddTo(LpMetadata* out) const {
		out->extents.push_back(LpMetadataExtent{num_sectors_, LP_TARGET_TYPE_ZERO, 0});
		}

		Partition::Partition(const std::string& name, const std::string& group_name,
		const std::string& guid, uint32_t attributes)
		: name_(name), group_name_(group_name), guid_(guid), attributes_(attributes), size_(0) {}
		Partition::Partition(const std::string& name, const std::string& group_name, uint32_t attributes)
		: name_(name), group_name_(group_name), attributes_(attributes), size_(0) {}

		void Partition::AddExtent(std::unique_ptr<Extent>&& extent) {
		size_ += extent->num_sectors() * LP_SECTOR_SIZE;
		@@ -202,8 +200,8 @@ bool MetadataBuilder::Init(const LpMetadata& metadata) {

		for (const auto& partition : metadata.partitions) {
		std::string group_name = GetPartitionGroupName(metadata.groups[partition.group_index]);
		Partition* builder = AddPartition(GetPartitionName(partition), group_name,
		GetPartitionGuid(partition), partition.attributes);
		Partition* builder =
		AddPartition(GetPartitionName(partition), group_name, partition.attributes);
		if (!builder) {
		return false;
		}
		@@ -329,13 +327,12 @@ bool MetadataBuilder::AddGroup(const std::string& group_name, uint64_t maximum_s
		return true;
		}

		Partition* MetadataBuilder::AddPartition(const std::string& name, const std::string& guid,
		uint32_t attributes) {
		return AddPartition(name, "default", guid, attributes);
		Partition* MetadataBuilder::AddPartition(const std::string& name, uint32_t attributes) {
		return AddPartition(name, "default", attributes);
		}

		Partition* MetadataBuilder::AddPartition(const std::string& name, const std::string& group_name,
		const std::string& guid, uint32_t attributes) {
		uint32_t attributes) {
		if (name.empty()) {
		LERROR << "Partition must have a non-empty name.";
		return nullptr;
		@@ -348,7 +345,7 @@ Partition* MetadataBuilder::AddPartition(const std::string& name, const std::str
		LERROR << "Could not find partition group: " << group_name;
		return nullptr;
		}
		partitions_.push_back(std::make_unique<Partition>(name, group_name, guid, attributes));
		partitions_.push_back(std::make_unique<Partition>(name, group_name, attributes));
		return partitions_.back().get();
		}

		@@ -549,12 +546,6 @@ std::unique_ptr<LpMetadata> MetadataBuilder::Export() {
		}

		strncpy(part.name, partition->name().c_str(), sizeof(part.name));
		if (uuid_parse(partition->guid().c_str(), part.guid) != 0) {
		LERROR << "Could not parse guid " << partition->guid() << " for partition "
		<< partition->name();
		return nullptr;
		}

		part.first_extent_index = static_cast<uint32_t>(metadata->extents.size());
		part.num_extents = static_cast<uint32_t>(partition->extents().size());
		part.attributes = partition->attributes();

fs_mgr/liblp/builder_test.cpp

+18 −35

Original line number	Diff line number	Diff line
		@@ -22,16 +22,12 @@
		using namespace std;
		using namespace android::fs_mgr;

		static const char* TEST_GUID = "A799D1D6-669F-41D8-A3F0-EBB7572D8302";
		static const char* TEST_GUID2 = "A799D1D6-669F-41D8-A3F0-EBB7572D8303";

		TEST(liblp, BuildBasic) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		Partition* partition = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* partition = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(partition, nullptr);
		EXPECT_EQ(partition->name(), "system");
		EXPECT_EQ(partition->guid(), TEST_GUID);
		EXPECT_EQ(partition->attributes(), LP_PARTITION_ATTR_READONLY);
		EXPECT_EQ(partition->size(), 0);
		EXPECT_EQ(builder->FindPartition("system"), partition);
		@@ -43,7 +39,7 @@ TEST(liblp, BuildBasic) {
		TEST(liblp, ResizePartition) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		Partition* system = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(system, nullptr);
		EXPECT_EQ(builder->ResizePartition(system, 65536), true);
		EXPECT_EQ(system->size(), 65536);
		@@ -94,7 +90,7 @@ TEST(liblp, PartitionAlignment) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		// Test that we align up to one sector.
		Partition* system = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(system, nullptr);
		EXPECT_EQ(builder->ResizePartition(system, 10000), true);
		EXPECT_EQ(system->size(), 12288);
		@@ -171,9 +167,9 @@ TEST(liblp, InternalPartitionAlignment) {
		BlockDeviceInfo device_info(512 * 1024 * 1024, 768 * 1024, 753664, 4096);
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(device_info, 32 * 1024, 2);

		Partition* a = builder->AddPartition("a", TEST_GUID, 0);
		Partition* a = builder->AddPartition("a", 0);
		ASSERT_NE(a, nullptr);
		Partition* b = builder->AddPartition("b", TEST_GUID2, 0);
		Partition* b = builder->AddPartition("b", 0);
		ASSERT_NE(b, nullptr);

		// Add a bunch of small extents to each, interleaving.
		@@ -214,7 +210,7 @@ TEST(liblp, UseAllDiskSpace) {
		EXPECT_EQ(builder->AllocatableSpace(), allocatable);
		EXPECT_EQ(builder->UsedSpace(), 0);

		Partition* system = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(system, nullptr);
		EXPECT_EQ(builder->ResizePartition(system, allocatable), true);
		EXPECT_EQ(system->size(), allocatable);
		@@ -229,8 +225,8 @@ TEST(liblp, UseAllDiskSpace) {
		TEST(liblp, BuildComplex) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		Partition* system = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* vendor = builder->AddPartition("vendor", TEST_GUID2, LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		Partition* vendor = builder->AddPartition("vendor", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(system, nullptr);
		ASSERT_NE(vendor, nullptr);
		EXPECT_EQ(builder->ResizePartition(system, 65536), true);
		@@ -263,15 +259,15 @@ TEST(liblp, BuildComplex) {
		TEST(liblp, AddInvalidPartition) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		Partition* partition = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* partition = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(partition, nullptr);

		// Duplicate name.
		partition = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		partition = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		EXPECT_EQ(partition, nullptr);

		// Empty name.
		partition = builder->AddPartition("", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		partition = builder->AddPartition("", LP_PARTITION_ATTR_READONLY);
		EXPECT_EQ(partition, nullptr);
		}

		@@ -282,8 +278,8 @@ TEST(liblp, BuilderExport) {
		unique_ptr<MetadataBuilder> builder =
		MetadataBuilder::New(kDiskSize, kMetadataSize, kMetadataSlots);

		Partition* system = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* vendor = builder->AddPartition("vendor", TEST_GUID2, LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		Partition* vendor = builder->AddPartition("vendor", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(system, nullptr);
		ASSERT_NE(vendor, nullptr);
		EXPECT_EQ(builder->ResizePartition(system, 65536), true);
		@@ -322,7 +318,6 @@ TEST(liblp, BuilderExport) {
		for (const auto& partition : exported->partitions) {
		Partition* original = builder->FindPartition(GetPartitionName(partition));
		ASSERT_NE(original, nullptr);
		EXPECT_EQ(original->guid(), GetPartitionGuid(partition));
		for (size_t i = 0; i < partition.num_extents; i++) {
		const auto& extent = exported->extents[partition.first_extent_index + i];
		LinearExtent* original_extent = original->extents()[i]->AsLinearExtent();
		@@ -337,8 +332,8 @@ TEST(liblp, BuilderExport) {
		TEST(liblp, BuilderImport) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		Partition* system = builder->AddPartition("system", TEST_GUID, LP_PARTITION_ATTR_READONLY);
		Partition* vendor = builder->AddPartition("vendor", TEST_GUID2, LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition("system", LP_PARTITION_ATTR_READONLY);
		Partition* vendor = builder->AddPartition("vendor", LP_PARTITION_ATTR_READONLY);
		ASSERT_NE(system, nullptr);
		ASSERT_NE(vendor, nullptr);
		EXPECT_EQ(builder->ResizePartition(system, 65536), true);
		@@ -357,11 +352,9 @@ TEST(liblp, BuilderImport) {

		EXPECT_EQ(system->size(), 98304);
		ASSERT_EQ(system->extents().size(), 2);
		EXPECT_EQ(system->guid(), TEST_GUID);
		EXPECT_EQ(system->attributes(), LP_PARTITION_ATTR_READONLY);
		EXPECT_EQ(vendor->size(), 32768);
		ASSERT_EQ(vendor->extents().size(), 1);
		EXPECT_EQ(vendor->guid(), TEST_GUID2);
		EXPECT_EQ(vendor->attributes(), LP_PARTITION_ATTR_READONLY);

		LinearExtent* system1 = system->extents()[0]->AsLinearExtent();
		@@ -378,17 +371,7 @@ TEST(liblp, ExportNameTooLong) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		std::string name = "abcdefghijklmnopqrstuvwxyz0123456789";
		Partition* system = builder->AddPartition(name + name, TEST_GUID, LP_PARTITION_ATTR_READONLY);
		EXPECT_NE(system, nullptr);

		unique_ptr<LpMetadata> exported = builder->Export();
		EXPECT_EQ(exported, nullptr);
		}

		TEST(liblp, ExportInvalidGuid) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(1024 * 1024, 1024, 2);

		Partition* system = builder->AddPartition("system", "bad", LP_PARTITION_ATTR_READONLY);
		Partition* system = builder->AddPartition(name + name, LP_PARTITION_ATTR_READONLY);
		EXPECT_NE(system, nullptr);

		unique_ptr<LpMetadata> exported = builder->Export();
		@@ -483,7 +466,7 @@ TEST(liblp, AlignedExtentSize) {
		unique_ptr<MetadataBuilder> builder = MetadataBuilder::New(device_info, 1024, 1);
		ASSERT_NE(builder, nullptr);

		Partition* partition = builder->AddPartition("system", TEST_GUID, 0);
		Partition* partition = builder->AddPartition("system", 0);
		ASSERT_NE(partition, nullptr);
		ASSERT_TRUE(builder->ResizePartition(partition, 512));
		EXPECT_EQ(partition->size(), 4096);
		@@ -511,7 +494,7 @@ TEST(liblp, GroupSizeLimits) {

		ASSERT_TRUE(builder->AddGroup("google", 16384));

		Partition* partition = builder->AddPartition("system", "google", TEST_GUID, 0);
		Partition* partition = builder->AddPartition("system", "google", 0);
		ASSERT_NE(partition, nullptr);
		EXPECT_TRUE(builder->ResizePartition(partition, 8192));
		EXPECT_EQ(partition->size(), 8192);