Merge "fs_mgr: Add a library for managing logical partitions." (c86d3110) · Commits · e / os / android_system_core

fs_mgr/Android.bp

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -57,12 +57,15 @@ cc_library_static {
	"libavb",		"libavb",
	"libfstab",		"libfstab",
	"libdm",		"libdm",
			"liblp",
	],		],
	export_static_lib_headers: [		export_static_lib_headers: [
	"libfstab",		"libfstab",
	"libdm",		"libdm",
			"liblp",
	],		],
	whole_static_libs: [		whole_static_libs: [
			"liblp",
	"liblogwrap",		"liblogwrap",
	"libdm",		"libdm",
	"libfstab",		"libfstab",

fs_mgr/liblp/Android.bp

0 → 100644

+44 −0

Original line number	Original line	Diff line number	Diff line
			//
			// Copyright (C) 2018 The Android Open Source Project
			//
			// Licensed under the Apache License, Version 2.0 (the "License");
			// you may not use this file except in compliance with the License.
			// You may obtain a copy of the License at
			//
			// http://www.apache.org/licenses/LICENSE-2.0
			//
			// Unless required by applicable law or agreed to in writing, software
			// distributed under the License is distributed on an "AS IS" BASIS,
			// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			// See the License for the specific language governing permissions and
			// limitations under the License.
			//

			cc_library_static {
			name: "liblp",
			host_supported: true,
			recovery_available: true,
			defaults: ["fs_mgr_defaults"],
			cppflags: [
			"-D_FILE_OFFSET_BITS=64",
			],
			srcs: [
			"builder.cpp",
			"reader.cpp",
			"utility.cpp",
			"writer.cpp",
			],
			static_libs: [
			"libbase",
			"liblog",
			"libcrypto",
			"libcrypto_utils",
			],
			whole_static_libs: [
			"libext2_uuid",
			"libext4_utils",
			"libsparse",
			"libz",
			],
			export_include_dirs: ["include"],
			}

fs_mgr/liblp/builder.cpp

0 → 100644

+351 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2018 The Android Open Source Project
			*
			* Licensed under the Apache License, Version 2.0 (the "License");
			* you may not use this file except in compliance with the License.
			* You may obtain a copy of the License at
			*
			* http://www.apache.org/licenses/LICENSE-2.0
			*
			* Unless required by applicable law or agreed to in writing, software
			* distributed under the License is distributed on an "AS IS" BASIS,
			* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			* See the License for the specific language governing permissions and
			* limitations under the License.
			*/

			#include "liblp/builder.h"

			#include <string.h>

			#include <algorithm>

			#include <uuid/uuid.h>

			#include "liblp/metadata_format.h"
			#include "utility.h"

			namespace android {
			namespace fs_mgr {

			// Align a byte count up to the nearest 512-byte sector.
			template <typename T>
			static inline T AlignToSector(T value) {
			return (value + (LP_SECTOR_SIZE - 1)) & ~T(LP_SECTOR_SIZE - 1);
			}

			void LinearExtent::AddTo(LpMetadata* out) const {
			out->extents.push_back(LpMetadataExtent{num_sectors_, LP_TARGET_TYPE_LINEAR, physical_sector_});
			}

			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& guid, uint32_t attributes)
			: name_(name), guid_(guid), attributes_(attributes), size_(0) {}

			void Partition::AddExtent(std::unique_ptr<Extent>&& extent) {
			size_ += extent->num_sectors() * LP_SECTOR_SIZE;
			extents_.push_back(std::move(extent));
			}

			void Partition::RemoveExtents() {
			size_ = 0;
			extents_.clear();
			}

			void Partition::ShrinkTo(uint64_t requested_size) {
			uint64_t aligned_size = AlignToSector(requested_size);
			if (size_ <= aligned_size) {
			return;
			}
			if (aligned_size == 0) {
			RemoveExtents();
			return;
			}

			// Remove or shrink extents of any kind until the total partition size is
			// equal to the requested size.
			uint64_t sectors_to_remove = (size_ - aligned_size) / LP_SECTOR_SIZE;
			while (sectors_to_remove) {
			Extent* extent = extents_.back().get();
			if (extent->num_sectors() > sectors_to_remove) {
			size_ -= sectors_to_remove * LP_SECTOR_SIZE;
			extent->set_num_sectors(extent->num_sectors() - sectors_to_remove);
			break;
			}
			size_ -= (extent->num_sectors() * LP_SECTOR_SIZE);
			sectors_to_remove -= extent->num_sectors();
			extents_.pop_back();
			}
			DCHECK(size_ == requested_size);
			}

			std::unique_ptr<MetadataBuilder> MetadataBuilder::New(uint64_t blockdevice_size,
			uint32_t metadata_max_size,
			uint32_t metadata_slot_count) {
			std::unique_ptr<MetadataBuilder> builder(new MetadataBuilder());
			if (!builder->Init(blockdevice_size, metadata_max_size, metadata_slot_count)) {
			return nullptr;
			}
			return builder;
			}

			std::unique_ptr<MetadataBuilder> MetadataBuilder::New(const LpMetadata& metadata) {
			std::unique_ptr<MetadataBuilder> builder(new MetadataBuilder());
			if (!builder->Init(metadata)) {
			return nullptr;
			}
			return builder;
			}

			MetadataBuilder::MetadataBuilder() {
			memset(&geometry_, 0, sizeof(geometry_));
			geometry_.magic = LP_METADATA_GEOMETRY_MAGIC;
			geometry_.struct_size = sizeof(geometry_);

			memset(&header_, 0, sizeof(header_));
			header_.magic = LP_METADATA_HEADER_MAGIC;
			header_.major_version = LP_METADATA_MAJOR_VERSION;
			header_.minor_version = LP_METADATA_MINOR_VERSION;
			header_.header_size = sizeof(header_);
			header_.partitions.entry_size = sizeof(LpMetadataPartition);
			header_.extents.entry_size = sizeof(LpMetadataExtent);
			}

			bool MetadataBuilder::Init(const LpMetadata& metadata) {
			geometry_ = metadata.geometry;

			for (const auto& partition : metadata.partitions) {
			Partition* builder = AddPartition(GetPartitionName(partition), GetPartitionGuid(partition),
			partition.attributes);
			if (!builder) {
			return false;
			}

			for (size_t i = 0; i < partition.num_extents; i++) {
			const LpMetadataExtent& extent = metadata.extents[partition.first_extent_index + i];
			if (extent.target_type == LP_TARGET_TYPE_LINEAR) {
			auto copy = std::make_unique<LinearExtent>(extent.num_sectors, extent.target_data);
			builder->AddExtent(std::move(copy));
			} else if (extent.target_type == LP_TARGET_TYPE_ZERO) {
			auto copy = std::make_unique<ZeroExtent>(extent.num_sectors);
			builder->AddExtent(std::move(copy));
			}
			}
			}
			return true;
			}

			bool MetadataBuilder::Init(uint64_t blockdevice_size, uint32_t metadata_max_size,
			uint32_t metadata_slot_count) {
			if (metadata_max_size < sizeof(LpMetadataHeader)) {
			LERROR << "Invalid metadata maximum size.";
			return false;
			}
			if (metadata_slot_count == 0) {
			LERROR << "Invalid metadata slot count.";
			return false;
			}

			// Align the metadata size up to the nearest sector.
			metadata_max_size = AlignToSector(metadata_max_size);

			// We reserve a geometry block (4KB) plus space for each copy of the
			// maximum size of a metadata blob. Then, we double that space since
			// we store a backup copy of everything.
			uint64_t reserved =
			LP_METADATA_GEOMETRY_SIZE + (uint64_t(metadata_max_size) * metadata_slot_count);
			uint64_t total_reserved = reserved * 2;

			if (blockdevice_size < total_reserved \|\| blockdevice_size - total_reserved < LP_SECTOR_SIZE) {
			LERROR << "Attempting to create metadata on a block device that is too small.";
			return false;
			}

			// The last sector is inclusive. We subtract one to make sure that logical
			// partitions won't overlap with the same sector as the backup metadata,
			// which could happen if the block device was not aligned to LP_SECTOR_SIZE.
			geometry_.first_logical_sector = reserved / LP_SECTOR_SIZE;
			geometry_.last_logical_sector = ((blockdevice_size - reserved) / LP_SECTOR_SIZE) - 1;
			geometry_.metadata_max_size = metadata_max_size;
			geometry_.metadata_slot_count = metadata_slot_count;
			DCHECK(geometry_.last_logical_sector >= geometry_.first_logical_sector);
			return true;
			}

			Partition* MetadataBuilder::AddPartition(const std::string& name, const std::string& guid,
			uint32_t attributes) {
			if (name.empty()) {
			LERROR << "Partition must have a non-empty name.";
			return nullptr;
			}
			if (FindPartition(name)) {
			LERROR << "Attempting to create duplication partition with name: " << name;
			return nullptr;
			}
			partitions_.push_back(std::make_unique<Partition>(name, guid, attributes));
			return partitions_.back().get();
			}

			Partition* MetadataBuilder::FindPartition(const std::string& name) {
			for (const auto& partition : partitions_) {
			if (partition->name() == name) {
			return partition.get();
			}
			}
			return nullptr;
			}

			void MetadataBuilder::RemovePartition(const std::string& name) {
			for (auto iter = partitions_.begin(); iter != partitions_.end(); iter++) {
			if ((*iter)->name() == name) {
			partitions_.erase(iter);
			return;
			}
			}
			}

			bool MetadataBuilder::GrowPartition(Partition* partition, uint64_t requested_size) {
			// Align the space needed up to the nearest sector.
			uint64_t aligned_size = AlignToSector(requested_size);
			if (partition->size() >= aligned_size) {
			return true;
			}

			// Figure out how much we need to allocate.
			uint64_t space_needed = aligned_size - partition->size();
			uint64_t sectors_needed = space_needed / LP_SECTOR_SIZE;
			DCHECK(sectors_needed * LP_SECTOR_SIZE == space_needed);

			struct Interval {
			uint64_t start;
			uint64_t end;

			Interval(uint64_t start, uint64_t end) : start(start), end(end) {}
			bool operator<(const Interval& other) const { return start < other.start; }
			};
			std::vector<Interval> intervals;

			// Collect all extents in the partition table.
			for (const auto& partition : partitions_) {
			for (const auto& extent : partition->extents()) {
			LinearExtent* linear = extent->AsLinearExtent();
			if (!linear) {
			continue;
			}
			intervals.emplace_back(linear->physical_sector(),
			linear->physical_sector() + extent->num_sectors());
			}
			}

			// Sort extents by starting sector.
			std::sort(intervals.begin(), intervals.end());

			// Find gaps that we can use for new extents. Note we store new extents in a
			// temporary vector, and only commit them if we are guaranteed enough free
			// space.
			std::vector<std::unique_ptr<LinearExtent>> new_extents;
			for (size_t i = 1; i < intervals.size(); i++) {
			const Interval& previous = intervals[i - 1];
			const Interval& current = intervals[i];

			if (previous.end >= current.start) {
			// There is no gap between these two extents, try the next one. Note that
			// extents may never overlap, but just for safety, we ignore them if they
			// do.
			DCHECK(previous.end == current.start);
			continue;
			}

			// This gap is enough to hold the remainder of the space requested, so we
			// can allocate what we need and return.
			if (current.start - previous.end >= sectors_needed) {
			auto extent = std::make_unique<LinearExtent>(sectors_needed, previous.end);
			sectors_needed -= extent->num_sectors();
			new_extents.push_back(std::move(extent));
			break;
			}

			// This gap is not big enough to fit the remainder of the space requested,
			// so consume the whole thing and keep looking for more.
			auto extent = std::make_unique<LinearExtent>(current.start - previous.end, previous.end);
			sectors_needed -= extent->num_sectors();
			new_extents.push_back(std::move(extent));
			}

			// If we still have more to allocate, take it from the remaining free space
			// in the allocatable region.
			if (sectors_needed) {
			uint64_t first_sector;
			if (intervals.empty()) {
			first_sector = geometry_.first_logical_sector;
			} else {
			first_sector = intervals.back().end;
			}
			DCHECK(first_sector <= geometry_.last_logical_sector);

			// Note: the last usable sector is inclusive.
			if (first_sector + sectors_needed > geometry_.last_logical_sector) {
			LERROR << "Not enough free space to expand partition: " << partition->name();
			return false;
			}
			auto extent = std::make_unique<LinearExtent>(sectors_needed, first_sector);
			new_extents.push_back(std::move(extent));
			}

			for (auto& extent : new_extents) {
			partition->AddExtent(std::move(extent));
			}
			return true;
			}

			void MetadataBuilder::ShrinkPartition(Partition* partition, uint64_t requested_size) {
			partition->ShrinkTo(requested_size);
			}

			std::unique_ptr<LpMetadata> MetadataBuilder::Export() {
			std::unique_ptr<LpMetadata> metadata = std::make_unique<LpMetadata>();
			metadata->header = header_;
			metadata->geometry = geometry_;

			// Flatten the partition and extent structures into an LpMetadata, which
			// makes it very easy to validate, serialize, or pass on to device-mapper.
			for (const auto& partition : partitions_) {
			LpMetadataPartition part;
			memset(&part, 0, sizeof(part));

			if (partition->name().size() > sizeof(part.name)) {
			LERROR << "Partition name is too long: " << partition->name();
			return nullptr;
			}
			if (partition->attributes() & ~(LP_PARTITION_ATTRIBUTE_MASK)) {
			LERROR << "Partition " << partition->name() << " has unsupported attribute.";
			return nullptr;
			}

			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();

			for (const auto& extent : partition->extents()) {
			extent->AddTo(metadata.get());
			}
			metadata->partitions.push_back(part);
			}

			metadata->header.partitions.num_entries = static_cast<uint32_t>(metadata->partitions.size());
			metadata->header.extents.num_entries = static_cast<uint32_t>(metadata->extents.size());
			return metadata;
			}

			} // namespace fs_mgr
			} // namespace android

fs_mgr/liblp/include/liblp/builder.h

0 → 100644

+169 −0

Original line number	Original line	Diff line number	Diff line
			//
			// Copyright (C) 2018 The Android Open Source Project
			//
			// Licensed under the Apache License, Version 2.0 (the "License");
			// you may not use this file except in compliance with the License.
			// You may obtain a copy of the License at
			//
			// http://www.apache.org/licenses/LICENSE-2.0
			//
			// Unless required by applicable law or agreed to in writing, software
			// distributed under the License is distributed on an "AS IS" BASIS,
			// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			// See the License for the specific language governing permissions and
			// limitations under the License.
			//

			#ifndef LIBLP_METADATA_BUILDER_H
			#define LIBLP_METADATA_BUILDER_H

			#include <stddef.h>
			#include <stdint.h>

			#include <map>
			#include <memory>

			#include "metadata_format.h"

			namespace android {
			namespace fs_mgr {

			class LinearExtent;

			// Abstraction around dm-targets that can be encoded into logical partition tables.
			class Extent {
			public:
			explicit Extent(uint64_t num_sectors) : num_sectors_(num_sectors) {}
			virtual ~Extent() {}

			virtual void AddTo(LpMetadata* out) const = 0;
			virtual LinearExtent* AsLinearExtent() { return nullptr; }

			uint64_t num_sectors() const { return num_sectors_; }
			void set_num_sectors(uint64_t num_sectors) { num_sectors_ = num_sectors; }

			protected:
			uint64_t num_sectors_;
			};

			// This corresponds to a dm-linear target.
			class LinearExtent final : public Extent {
			public:
			LinearExtent(uint64_t num_sectors, uint64_t physical_sector)
			: Extent(num_sectors), physical_sector_(physical_sector) {}

			void AddTo(LpMetadata* metadata) const override;
			LinearExtent* AsLinearExtent() override { return this; }

			uint64_t physical_sector() const { return physical_sector_; }

			private:
			uint64_t physical_sector_;
			};

			// This corresponds to a dm-zero target.
			class ZeroExtent final : public Extent {
			public:
			explicit ZeroExtent(uint64_t num_sectors) : Extent(num_sectors) {}

			void AddTo(LpMetadata* out) const override;
			};

			class Partition final {
			public:
			Partition(const std::string& name, const std::string& guid, uint32_t attributes);

			// Add a raw extent.
			void AddExtent(std::unique_ptr<Extent>&& extent);

			// Remove all extents from this partition.
			void RemoveExtents();

			// Remove and/or shrink extents until the partition is the requested size.
			// See MetadataBuilder::ShrinkPartition for more information.
			void ShrinkTo(uint64_t requested_size);

			const std::string& name() const { return name_; }
			uint32_t attributes() const { return attributes_; }
			const std::string& guid() const { return guid_; }
			const std::vector<std::unique_ptr<Extent>>& extents() const { return extents_; }
			uint64_t size() const { return size_; }

			private:
			std::string name_;
			std::string guid_;
			std::vector<std::unique_ptr<Extent>> extents_;
			uint32_t attributes_;
			uint64_t size_;
			};

			class MetadataBuilder {
			public:
			// Construct an empty logical partition table builder. The block device size
			// and maximum metadata size must be specified, as this will determine which
			// areas of the physical partition can be flashed for metadata vs for logical
			// partitions.
			//
			// If the parameters would yield invalid metadata, nullptr is returned. This
			// could happen if the block device size is too small to store the metadata
			// and backup copies.
			static std::unique_ptr<MetadataBuilder> New(uint64_t blockdevice_size,
			uint32_t metadata_max_size,
			uint32_t metadata_slot_count);

			// Import an existing table for modification. If the table is not valid, for
			// example it contains duplicate partition names, then nullptr is returned.
			static std::unique_ptr<MetadataBuilder> New(const LpMetadata& metadata);

			// Export metadata so it can be serialized to an image, to disk, or mounted
			// via device-mapper.
			std::unique_ptr<LpMetadata> Export();

			// Add a partition, returning a handle so it can be sized as needed. If a
			// partition with the given name already exists, nullptr is returned.
			Partition* AddPartition(const std::string& name, const std::string& guid, uint32_t attributes);

			// Delete a partition by name if it exists.
			void RemovePartition(const std::string& name);

			// Find a partition by name. If no partition is found, nullptr is returned.
			Partition* FindPartition(const std::string& name);

			// Grow a partition to the requested size. If the partition's size is already
			// greater or equal to the requested size, this will return true and the
			// partition table will not be changed. Otherwise, a greedy algorithm is
			// used to find free gaps in the partition table and allocate them for this
			// partition. If not enough space can be allocated, false is returned, and
			// the parition table will not be modified.
			//
			// The size will be rounded UP to the nearest sector.
			//
			// Note, this is an in-memory operation, and it does not alter the
			// underlying filesystem or contents of the partition on disk.
			bool GrowPartition(Partition* partition, uint64_t requested_size);

			// Shrink a partition to the requested size. If the partition is already
			// smaller than the given size, this will return and the partition table
			// will not be changed. Otherwise, extents will be removed and/or shrunk
			// from the end of the partition until it is the requested size.
			//
			// The size will be rounded UP to the nearest sector.
			//
			// Note, this is an in-memory operation, and it does not alter the
			// underlying filesystem or contents of the partition on disk.
			void ShrinkPartition(Partition* partition, uint64_t requested_size);

			private:
			MetadataBuilder();
			bool Init(uint64_t blockdevice_size, uint32_t metadata_max_size, uint32_t metadata_slot_count);
			bool Init(const LpMetadata& metadata);

			LpMetadataGeometry geometry_;
			LpMetadataHeader header_;
			std::vector<std::unique_ptr<Partition>> partitions_;
			};

			} // namespace fs_mgr
			} // namespace android

			#endif /* LIBLP_METADATA_BUILDER_H */

fs_mgr/liblp/include/liblp/metadata_format.h

0 → 100644

+263 −0

File added.

Preview size limit exceeded, changes collapsed.