310 lines
12 KiB
C++
310 lines
12 KiB
C++
/*
|
|
* 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 <getopt.h>
|
|
#include <inttypes.h>
|
|
#include <sys/mount.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/statvfs.h>
|
|
#include <sys/types.h>
|
|
#include <sysexits.h>
|
|
#include <unistd.h>
|
|
|
|
#include <iostream>
|
|
#include <optional>
|
|
#include <regex>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <chrono>
|
|
|
|
#include <android-base/parseint.h>
|
|
#include <android-base/properties.h>
|
|
#include <android-base/strings.h>
|
|
#include <cutils/android_get_control_file.h>
|
|
#include <fs_mgr.h>
|
|
#include <liblp/builder.h>
|
|
#include <liblp/liblp.h>
|
|
#include <fs_mgr_dm_linear.h>
|
|
#include <libdm/dm.h>
|
|
|
|
#ifndef LPTOOLS_STATIC
|
|
#include <android/hardware/boot/1.1/IBootControl.h>
|
|
#include <android/hardware/boot/1.1/types.h>
|
|
#endif
|
|
|
|
using namespace android;
|
|
using namespace android::fs_mgr;
|
|
|
|
class FileOrBlockDeviceOpener final : public PartitionOpener {
|
|
public:
|
|
android::base::unique_fd Open(const std::string& path, int flags) const override {
|
|
// Try a local file first.
|
|
android::base::unique_fd fd;
|
|
|
|
#ifdef __ANDROID__
|
|
fd.reset(android_get_control_file(path.c_str()));
|
|
if (fd >= 0) return fd;
|
|
#endif
|
|
fd.reset(open(path.c_str(), flags));
|
|
if (fd >= 0) return fd;
|
|
|
|
return PartitionOpener::Open(path, flags);
|
|
}
|
|
};
|
|
|
|
static FileOrBlockDeviceOpener opener;
|
|
std::unique_ptr<MetadataBuilder> makeBuilder() {
|
|
auto builder = MetadataBuilder::New(opener, "super", 0);
|
|
if(builder == nullptr) {
|
|
std::cout << "Failed creating super builder" << std::endl;
|
|
}
|
|
return builder;
|
|
}
|
|
|
|
void saveToDisk(std::unique_ptr<MetadataBuilder> builder) {
|
|
auto newMetadata = builder->Export();
|
|
int nSlots = 2;//pt->geometry.metadata_slot_count;
|
|
for(int slot=0; slot < nSlots; slot++) {
|
|
std::cout << "Saving the updated partition table " << UpdatePartitionTable(opener, "super", *newMetadata, slot) << " for slot " << slot << std::endl;
|
|
}
|
|
}
|
|
|
|
inline bool ends_with(std::string const & value, std::string const & ending)
|
|
{
|
|
if (ending.size() > value.size()) return false;
|
|
return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
|
|
}
|
|
|
|
std::string findGroup(std::unique_ptr<MetadataBuilder>& builder) {
|
|
auto groups = builder->ListGroups();
|
|
|
|
auto partitionName = "system" + ::android::base::GetProperty("ro.boot.slot_suffix", "");
|
|
for(auto groupName: groups) {
|
|
auto partitions = builder->ListPartitionsInGroup(groupName);
|
|
for (const auto& partition : partitions) {
|
|
if(partition->name() == partitionName) {
|
|
return groupName;
|
|
}
|
|
}
|
|
}
|
|
|
|
std::string maxGroup = "";
|
|
uint64_t maxGroupSize = 0;
|
|
for(auto groupName: groups) {
|
|
auto group = builder->FindGroup(groupName);
|
|
if(group->maximum_size() > maxGroupSize) {
|
|
maxGroup = groupName;
|
|
maxGroupSize = group->maximum_size();
|
|
}
|
|
}
|
|
|
|
return maxGroup;
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv) {
|
|
if(argc<=1) {
|
|
std::cerr << "Usage: " << argv[0] << " <create|remove|resize|rename>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto builder = makeBuilder();
|
|
auto group = findGroup(builder);
|
|
std::cout << "Best group seems to be " << group << std::endl;
|
|
|
|
if(strcmp(argv[1], "create") == 0) {
|
|
if(argc != 4) {
|
|
std::cerr << "Usage: " << argv[0] << " create <partition name> <partition size>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto partName = argv[2];
|
|
auto size = strtoll(argv[3], NULL, 0);
|
|
auto partition = builder->FindPartition(partName);
|
|
if(partition != nullptr) {
|
|
std::cerr << "Partition " << partName << " already exists." << std::endl;
|
|
exit(1);
|
|
}
|
|
partition = builder->AddPartition(partName, group, 0);
|
|
auto result = builder->ResizePartition(partition, size);
|
|
std::cout << "Growing partition " << result << std::endl;
|
|
if(!result) return 1;
|
|
saveToDisk(std::move(builder));
|
|
|
|
std::string dmPath;
|
|
CreateLogicalPartitionParams params {
|
|
.block_device = "/dev/block/by-name/super",
|
|
.metadata_slot = 0,
|
|
.partition_name = partName,
|
|
.timeout_ms = std::chrono::milliseconds(10000),
|
|
.force_writable = true,
|
|
};
|
|
auto dmCreateRes = android::fs_mgr::CreateLogicalPartition(params, &dmPath);
|
|
std::cout << "Creating dm partition for " << partName << " answered " << dmCreateRes << " at " << dmPath << std::endl;
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "remove") == 0) {
|
|
if(argc != 3) {
|
|
std::cerr << "Usage: " << argv[0] << " remove <partition name>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto partName = argv[2];
|
|
auto dmState = android::dm::DeviceMapper::Instance().GetState(partName);
|
|
if(dmState == android::dm::DmDeviceState::ACTIVE) {
|
|
android::fs_mgr::DestroyLogicalPartition(partName);
|
|
}
|
|
builder->RemovePartition(partName);
|
|
saveToDisk(std::move(builder));
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "resize") == 0) {
|
|
if(argc != 4) {
|
|
std::cerr << "Usage: " << argv[0] << " resize <partition name> <newsize>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto partName = argv[2];
|
|
auto size = strtoll(argv[3], NULL, 0);
|
|
auto partition = builder->FindPartition(partName);
|
|
std::cout << "Resizing partition " << builder->ResizePartition(partition, size) << std::endl;
|
|
saveToDisk(std::move(builder));
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "replace") == 0) {
|
|
if(argc != 4) {
|
|
std::cerr << "Usage: " << argv[0] << " replace <original partition name> <new partition name>" << std::endl;
|
|
std::cerr << "This will delete <new partition name> and rename <original partition name> to <new partition name>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto src = argv[2];
|
|
auto dst = argv[3];
|
|
auto srcPartition = builder->FindPartition(src);
|
|
if(srcPartition == nullptr) {
|
|
srcPartition = builder->FindPartition(src + ::android::base::GetProperty("ro.boot.slot_suffix", ""));
|
|
}
|
|
auto dstPartition = builder->FindPartition(dst);
|
|
if(dstPartition == nullptr) {
|
|
dstPartition = builder->FindPartition(dst + ::android::base::GetProperty("ro.boot.slot_suffix", ""));
|
|
}
|
|
std::string dstPartitionName = dst;
|
|
if(dstPartition != nullptr) {
|
|
dstPartitionName = dstPartition->name();
|
|
}
|
|
std::vector<std::unique_ptr<Extent>> originalExtents;
|
|
|
|
const auto& extents = srcPartition->extents();
|
|
for(unsigned i=0; i<extents.size(); i++) {
|
|
const auto& extend = extents[i];
|
|
auto linear = extend->AsLinearExtent();
|
|
if(linear != nullptr) {
|
|
auto copyLinear = std::make_unique<LinearExtent>(linear->num_sectors(), linear->device_index(), linear->physical_sector());
|
|
originalExtents.push_back(std::move(copyLinear));
|
|
} else {
|
|
auto copyZero = std::make_unique<ZeroExtent>(extend->num_sectors());
|
|
originalExtents.push_back(std::move(copyZero));
|
|
}
|
|
}
|
|
builder->RemovePartition(srcPartition->name());
|
|
builder->RemovePartition(dstPartitionName);
|
|
auto newDstPartition = builder->AddPartition(dstPartitionName, group, 0);
|
|
for(auto&& extent: originalExtents) {
|
|
newDstPartition->AddExtent(std::move(extent));
|
|
}
|
|
saveToDisk(std::move(builder));
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "map") == 0) {
|
|
if(argc != 3) {
|
|
std::cerr << "Usage: " << argv[0] << " map <partition name>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto partName = argv[2];
|
|
std::string dmPath;
|
|
CreateLogicalPartitionParams params {
|
|
.block_device = "/dev/block/by-name/super",
|
|
.metadata_slot = 0,
|
|
.partition_name = partName,
|
|
.timeout_ms = std::chrono::milliseconds(10000),
|
|
.force_writable = true,
|
|
};
|
|
auto dmCreateRes = android::fs_mgr::CreateLogicalPartition(params, &dmPath);
|
|
std::cout << "Creating dm partition for " << partName << " answered " << dmCreateRes << " at " << dmPath << std::endl;
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "unmap") == 0) {
|
|
if(argc != 3) {
|
|
std::cerr << "Usage: " << argv[0] << " unmap <partition name>" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto partName = argv[2];
|
|
auto dmState = android::dm::DeviceMapper::Instance().GetState(partName);
|
|
if(dmState == android::dm::DmDeviceState::ACTIVE) {
|
|
android::fs_mgr::DestroyLogicalPartition(partName);
|
|
}
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "free") == 0) {
|
|
if(argc != 2) {
|
|
std::cerr << "Usage: " << argv[0] << " free" << std::endl;
|
|
exit(1);
|
|
}
|
|
auto groupO = builder->FindGroup(group);
|
|
uint64_t maxSize = groupO->maximum_size();
|
|
|
|
uint64_t total = 0;
|
|
auto partitions = builder->ListPartitionsInGroup(group);
|
|
for (const auto& partition : partitions) {
|
|
total += partition->BytesOnDisk();
|
|
}
|
|
|
|
uint64_t groupAllocatable = maxSize - total;
|
|
uint64_t superFreeSpace = builder->AllocatableSpace() - builder->UsedSpace();
|
|
if(groupAllocatable > superFreeSpace || maxSize == 0)
|
|
groupAllocatable = superFreeSpace;
|
|
|
|
printf("Free space: %" PRIu64 "\n", groupAllocatable);
|
|
|
|
exit(0);
|
|
} else if(strcmp(argv[1], "unlimited-group") == 0) {
|
|
builder->ChangeGroupSize(group, 0);
|
|
saveToDisk(std::move(builder));
|
|
return 0;
|
|
} else if(strcmp(argv[1], "clear-cow") == 0) {
|
|
#ifndef LPTOOLS_STATIC
|
|
// Ensure this is a V AB device, and that no merging is taking place (merging? in gsi? uh)
|
|
auto svc1_1 = ::android::hardware::boot::V1_1::IBootControl::tryGetService();
|
|
if(svc1_1 == nullptr) {
|
|
std::cerr << "Couldn't get a bootcontrol HAL. You can clear cow only on V AB devices" << std::endl;
|
|
return 1;
|
|
}
|
|
auto mergeStatus = svc1_1->getSnapshotMergeStatus();
|
|
if(mergeStatus != ::android::hardware::boot::V1_1::MergeStatus::NONE) {
|
|
std::cerr << "Merge status is NOT none, meaning a merge is pending. Clearing COW isn't safe" << std::endl;
|
|
return 1;
|
|
}
|
|
#endif
|
|
|
|
uint64_t superFreeSpace = builder->AllocatableSpace() - builder->UsedSpace();
|
|
std::cerr << "Super allocatable " << superFreeSpace << std::endl;
|
|
|
|
uint64_t total = 0;
|
|
auto partitions = builder->ListPartitionsInGroup("cow");
|
|
for (const auto& partition : partitions) {
|
|
std::cout << "Deleting partition? " << partition->name() << std::endl;
|
|
if(ends_with(partition->name(), "-cow")) {
|
|
std::cout << "Deleting partition " << partition->name() << std::endl;
|
|
builder->RemovePartition(partition->name());
|
|
}
|
|
}
|
|
saveToDisk(std::move(builder));
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|