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

fs_mgr/Android.bp

+3 −0

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

fs_mgr/liblp/Android.bp

0 → 100644

+44 −0

Original line number	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	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	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.