blob: 37f28e124102101ff6df564d555fb55d296dffac [file] [log] [blame]
//
// Copyright (C) 2023 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/super_layout_builder.h>
#include <liblp/liblp.h>
#include "images.h"
#include "utility.h"
#include "writer.h"
using android::base::borrowed_fd;
using android::base::unique_fd;
namespace android {
namespace fs_mgr {
bool SuperLayoutBuilder::Open(borrowed_fd fd) {
auto metadata = ReadFromImageFile(fd.get());
if (!metadata) {
return false;
}
return Open(*metadata.get());
}
bool SuperLayoutBuilder::Open(const void* data, size_t size) {
auto metadata = ReadFromImageBlob(data, size);
if (!metadata) {
return false;
}
return Open(*metadata.get());
}
bool SuperLayoutBuilder::Open(const LpMetadata& metadata) {
for (const auto& partition : metadata.partitions) {
if (partition.attributes & LP_PARTITION_ATTR_SLOT_SUFFIXED) {
// Retrofit devices are not supported.
return false;
}
if (!(partition.attributes & LP_PARTITION_ATTR_READONLY)) {
// Writable partitions are not supported.
return false;
}
}
if (!metadata.extents.empty()) {
// Partitions that already have extents are not supported (should
// never be true of super_empty.img).
return false;
}
if (metadata.block_devices.size() != 1) {
// Only one "super" is supported.
return false;
}
builder_ = MetadataBuilder::New(metadata);
return !!builder_;
}
bool SuperLayoutBuilder::AddPartition(const std::string& partition_name,
const std::string& image_name, uint64_t partition_size) {
auto p = builder_->FindPartition(partition_name);
if (!p) {
return false;
}
if (!builder_->ResizePartition(p, partition_size)) {
return false;
}
image_map_.emplace(partition_name, image_name);
return true;
}
// Fill the space between each extent, if any, with either a fill or dontcare
// extent. The caller constructs a sample extent to re-use.
static bool AddGapExtents(std::vector<SuperImageExtent>* extents, SuperImageExtent::Type gap_type) {
std::vector<SuperImageExtent> old = std::move(*extents);
std::sort(old.begin(), old.end());
*extents = {};
uint64_t current_offset = 0;
for (const auto& extent : old) {
// Check for overlapping extents - this would be a serious error.
if (current_offset > extent.offset) {
LOG(INFO) << "Overlapping extents detected; cannot layout temporary super image";
return false;
}
if (extent.offset != current_offset) {
uint64_t gap_size = extent.offset - current_offset;
extents->emplace_back(current_offset, gap_size, gap_type);
current_offset = extent.offset;
}
extents->emplace_back(extent);
current_offset += extent.size;
}
return true;
}
std::vector<SuperImageExtent> SuperLayoutBuilder::GetImageLayout() {
auto metadata = builder_->Export();
if (!metadata) {
return {};
}
std::vector<SuperImageExtent> extents;
// Write the primary and backup copies of geometry.
std::string geometry_bytes = SerializeGeometry(metadata->geometry);
auto blob = std::make_shared<std::string>(std::move(geometry_bytes));
extents.emplace_back(0, GetPrimaryGeometryOffset(), SuperImageExtent::Type::ZERO);
extents.emplace_back(GetPrimaryGeometryOffset(), blob);
extents.emplace_back(GetBackupGeometryOffset(), blob);
// Write the primary and backup copies of each metadata slot. When flashing,
// all metadata copies are the same, even for different slots.
std::string metadata_bytes = SerializeMetadata(*metadata.get());
// Align metadata size to 4KB. This makes the layout easily compatible with
// libsparse.
static constexpr size_t kSparseAlignment = 4096;
size_t metadata_aligned_bytes;
if (!AlignTo(metadata_bytes.size(), kSparseAlignment, &metadata_aligned_bytes)) {
LOG(ERROR) << "Unable to align metadata size " << metadata_bytes.size() << " to "
<< kSparseAlignment;
return {};
}
metadata_bytes.resize(metadata_aligned_bytes, '\0');
// However, alignment can cause larger-than-supported metadata blocks. Fall
// back to fastbootd/update-super.
if (metadata_bytes.size() > metadata->geometry.metadata_max_size) {
LOG(VERBOSE) << "Aligned metadata size " << metadata_bytes.size()
<< " is larger than maximum metadata size "
<< metadata->geometry.metadata_max_size;
return {};
}
blob = std::make_shared<std::string>(std::move(metadata_bytes));
for (uint32_t i = 0; i < metadata->geometry.metadata_slot_count; i++) {
int64_t metadata_primary = GetPrimaryMetadataOffset(metadata->geometry, i);
int64_t metadata_backup = GetBackupMetadataOffset(metadata->geometry, i);
extents.emplace_back(metadata_primary, blob);
extents.emplace_back(metadata_backup, blob);
}
// Add extents for each partition.
for (const auto& partition : metadata->partitions) {
auto partition_name = GetPartitionName(partition);
auto image_name_iter = image_map_.find(partition_name);
if (image_name_iter == image_map_.end()) {
if (partition.num_extents != 0) {
LOG(ERROR) << "Partition " << partition_name
<< " has extents but no image filename";
return {};
}
continue;
}
const auto& image_name = image_name_iter->second;
uint64_t image_offset = 0;
for (uint32_t i = 0; i < partition.num_extents; i++) {
const auto& e = metadata->extents[partition.first_extent_index + i];
if (e.target_type != LP_TARGET_TYPE_LINEAR) {
// Any type other than LINEAR isn't understood here. We don't even
// bother with ZERO, which is never generated.
LOG(INFO) << "Unknown extent type from liblp: " << e.target_type;
return {};
}
size_t size = e.num_sectors * LP_SECTOR_SIZE;
uint64_t super_offset = e.target_data * LP_SECTOR_SIZE;
extents.emplace_back(super_offset, size, image_name, image_offset);
image_offset += size;
}
}
if (!AddGapExtents(&extents, SuperImageExtent::Type::DONTCARE)) {
return {};
}
return extents;
}
bool SuperImageExtent::operator==(const SuperImageExtent& other) const {
if (offset != other.offset) {
return false;
}
if (size != other.size) {
return false;
}
if (type != other.type) {
return false;
}
switch (type) {
case Type::DATA:
return *blob == *other.blob;
case Type::PARTITION:
return image_name == other.image_name && image_offset == other.image_offset;
default:
return true;
}
}
std::ostream& operator<<(std::ostream& stream, const SuperImageExtent& extent) {
stream << "extent:" << extent.offset << ":" << extent.size << ":";
switch (extent.type) {
case SuperImageExtent::Type::DATA:
stream << "data";
break;
case SuperImageExtent::Type::PARTITION:
stream << "partition:" << extent.image_name << ":" << extent.image_offset;
break;
case SuperImageExtent::Type::ZERO:
stream << "zero";
break;
case SuperImageExtent::Type::DONTCARE:
stream << "dontcare";
break;
default:
stream << "invalid";
}
return stream;
}
} // namespace fs_mgr
} // namespace android