updater/updater_runtime_dynamic_partitions.cpp - android_bootable_recovery - Gitiles

 /*
  * Copyright (C) 2019 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 "updater/updater_runtime.h"

 #include <algorithm>
 #include <chrono>
 #include <iterator>
 #include <optional>
 #include <string>
 #include <type_traits>
 #include <vector>

 #include <android-base/logging.h>
 #include <android-base/parseint.h>
 #include <android-base/strings.h>
 #include <fs_mgr.h>
 #include <fs_mgr_dm_linear.h>
 #include <libdm/dm.h>
 #include <liblp/builder.h>

 using android::dm::DeviceMapper;
 using android::dm::DmDeviceState;
 using android::fs_mgr::CreateLogicalPartition;
 using android::fs_mgr::CreateLogicalPartitionParams;
 using android::fs_mgr::DestroyLogicalPartition;
 using android::fs_mgr::LpMetadata;
 using android::fs_mgr::MetadataBuilder;
 using android::fs_mgr::Partition;
 using android::fs_mgr::PartitionOpener;
 using android::fs_mgr::SlotNumberForSlotSuffix;

 static constexpr std::chrono::milliseconds kMapTimeout{ 1000 };

 static std::string GetSuperDevice() {
   return "/dev/block/by-name/" + fs_mgr_get_super_partition_name();
 }

 static std::string AddSlotSuffix(const std::string& partition_name) {
   return partition_name + fs_mgr_get_slot_suffix();
 }

 static bool UnmapPartitionWithSuffixOnDeviceMapper(const std::string& partition_name_suffix) {
   auto state = DeviceMapper::Instance().GetState(partition_name_suffix);
   if (state == DmDeviceState::INVALID) {
     return true;
   }
   if (state == DmDeviceState::ACTIVE) {
     return DestroyLogicalPartition(partition_name_suffix);
   }
   LOG(ERROR) << "Unknown device mapper state: "
              << static_cast<std::underlying_type_t<DmDeviceState>>(state);
   return false;
 }

 bool UpdaterRuntime::MapPartitionOnDeviceMapper(const std::string& partition_name,
                                                 std::string* path) {
   auto partition_name_suffix = AddSlotSuffix(partition_name);
   auto state = DeviceMapper::Instance().GetState(partition_name_suffix);
   if (state == DmDeviceState::INVALID) {
     CreateLogicalPartitionParams params = {
       .block_device = GetSuperDevice(),
       // If device supports A/B, apply non-A/B update to the partition at current slot. Otherwise,
       // SlotNumberForSlotSuffix("") returns 0.
       .metadata_slot = SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix()),
       // If device supports A/B, apply non-A/B update to the partition at current slot. Otherwise,
       // fs_mgr_get_slot_suffix() returns empty string.
       .partition_name = partition_name_suffix,
       .force_writable = true,
       .timeout_ms = kMapTimeout,
     };
     return CreateLogicalPartition(params, path);
   }

   if (state == DmDeviceState::ACTIVE) {
     return DeviceMapper::Instance().GetDmDevicePathByName(partition_name_suffix, path);
   }
   LOG(ERROR) << "Unknown device mapper state: "
              << static_cast<std::underlying_type_t<DmDeviceState>>(state);
   return false;
 }

 bool UpdaterRuntime::UnmapPartitionOnDeviceMapper(const std::string& partition_name) {
   return ::UnmapPartitionWithSuffixOnDeviceMapper(AddSlotSuffix(partition_name));
 }

 namespace {  // Ops

 struct OpParameters {
   std::vector<std::string> tokens;
   MetadataBuilder* builder;

   bool ExpectArgSize(size_t size) const {
     CHECK(!tokens.empty());
     auto actual = tokens.size() - 1;
     if (actual != size) {
       LOG(ERROR) << "Op " << op() << " expects " << size << " args, got " << actual;
       return false;
     }
     return true;
   }
   const std::string& op() const {
     CHECK(!tokens.empty());
     return tokens[0];
   }
   const std::string& arg(size_t pos) const {
     CHECK_LE(pos + 1, tokens.size());
     return tokens[pos + 1];
   }
   std::optional<uint64_t> uint_arg(size_t pos, const std::string& name) const {
     auto str = arg(pos);
     uint64_t ret;
     if (!android::base::ParseUint(str, &ret)) {
       LOG(ERROR) << "Op " << op() << " expects uint64 for argument " << name << ", got " << str;
       return std::nullopt;
     }
     return ret;
   }
 };

 using OpFunction = std::function<bool(const OpParameters&)>;
 using OpMap = std::map<std::string, OpFunction>;

 bool PerformOpResize(const OpParameters& params) {
   if (!params.ExpectArgSize(2)) return false;
   const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
   auto size = params.uint_arg(1, "size");
   if (!size.has_value()) return false;

   auto partition = params.builder->FindPartition(partition_name_suffix);
   if (partition == nullptr) {
     LOG(ERROR) << "Failed to find partition " << partition_name_suffix
                << " in dynamic partition metadata.";
     return false;
   }
   if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
     LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before resizing.";
     return false;
   }
   if (!params.builder->ResizePartition(partition, size.value())) {
     LOG(ERROR) << "Failed to resize partition " << partition_name_suffix << " to size " << *size
                << ".";
     return false;
   }
   return true;
 }

 bool PerformOpRemove(const OpParameters& params) {
   if (!params.ExpectArgSize(1)) return false;
   const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));

   if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
     LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before removing.";
     return false;
   }
   params.builder->RemovePartition(partition_name_suffix);
   return true;
 }

 bool PerformOpAdd(const OpParameters& params) {
   if (!params.ExpectArgSize(2)) return false;
   const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
   const auto& group_name_suffix = AddSlotSuffix(params.arg(1));

   if (params.builder->AddPartition(partition_name_suffix, group_name_suffix,
                                    LP_PARTITION_ATTR_READONLY) == nullptr) {
     LOG(ERROR) << "Failed to add partition " << partition_name_suffix << " to group "
                << group_name_suffix << ".";
     return false;
   }
   return true;
 }

 bool PerformOpMove(const OpParameters& params) {
   if (!params.ExpectArgSize(2)) return false;
   const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
   const auto& new_group_name_suffix = AddSlotSuffix(params.arg(1));

   auto partition = params.builder->FindPartition(partition_name_suffix);
   if (partition == nullptr) {
     LOG(ERROR) << "Cannot move partition " << partition_name_suffix << " to group "
                << new_group_name_suffix << " because it is not found.";
     return false;
   }

   auto old_group_name_suffix = partition->group_name();
   if (old_group_name_suffix != new_group_name_suffix) {
     if (!params.builder->ChangePartitionGroup(partition, new_group_name_suffix)) {
       LOG(ERROR) << "Cannot move partition " << partition_name_suffix << " from group "
                  << old_group_name_suffix << " to group " << new_group_name_suffix << ".";
       return false;
     }
   }
   return true;
 }

 bool PerformOpAddGroup(const OpParameters& params) {
   if (!params.ExpectArgSize(2)) return false;
   const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
   auto maximum_size = params.uint_arg(1, "maximum_size");
   if (!maximum_size.has_value()) return false;

   auto group = params.builder->FindGroup(group_name_suffix);
   if (group != nullptr) {
     LOG(ERROR) << "Cannot add group " << group_name_suffix << " because it already exists.";
     return false;
   }

   if (maximum_size.value() == 0) {
     LOG(WARNING) << "Adding group " << group_name_suffix << " with no size limits.";
   }

   if (!params.builder->AddGroup(group_name_suffix, maximum_size.value())) {
     LOG(ERROR) << "Failed to add group " << group_name_suffix << " with maximum size "
                << maximum_size.value() << ".";
     return false;
   }
   return true;
 }

 bool PerformOpResizeGroup(const OpParameters& params) {
   if (!params.ExpectArgSize(2)) return false;
   const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
   auto new_size = params.uint_arg(1, "maximum_size");
   if (!new_size.has_value()) return false;

   auto group = params.builder->FindGroup(group_name_suffix);
   if (group == nullptr) {
     LOG(ERROR) << "Cannot resize group " << group_name_suffix << " because it is not found.";
     return false;
   }

   auto old_size = group->maximum_size();
   if (old_size != new_size.value()) {
     if (!params.builder->ChangeGroupSize(group_name_suffix, new_size.value())) {
       LOG(ERROR) << "Cannot resize group " << group_name_suffix << " from " << old_size << " to "
                  << new_size.value() << ".";
       return false;
     }
   }
   return true;
 }

 std::vector<std::string> ListPartitionNamesInGroup(MetadataBuilder* builder,
                                                    const std::string& group_name_suffix) {
   auto partitions = builder->ListPartitionsInGroup(group_name_suffix);
   std::vector<std::string> partition_names;
   std::transform(partitions.begin(), partitions.end(), std::back_inserter(partition_names),
                  [](Partition* partition) { return partition->name(); });
   return partition_names;
 }

 bool PerformOpRemoveGroup(const OpParameters& params) {
   if (!params.ExpectArgSize(1)) return false;
   const auto& group_name_suffix = AddSlotSuffix(params.arg(0));

   auto partition_names = ListPartitionNamesInGroup(params.builder, group_name_suffix);
   if (!partition_names.empty()) {
     LOG(ERROR) << "Cannot remove group " << group_name_suffix
                << " because it still contains partitions ["
                << android::base::Join(partition_names, ", ") << "]";
     return false;
   }
   params.builder->RemoveGroupAndPartitions(group_name_suffix);
   return true;
 }

 bool PerformOpRemoveAllGroups(const OpParameters& params) {
   if (!params.ExpectArgSize(0)) return false;

   auto group_names = params.builder->ListGroups();
   for (const auto& group_name_suffix : group_names) {
     auto partition_names = ListPartitionNamesInGroup(params.builder, group_name_suffix);
     for (const auto& partition_name_suffix : partition_names) {
       if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
         LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before removing group "
                    << group_name_suffix << ".";
         return false;
       }
     }
     params.builder->RemoveGroupAndPartitions(group_name_suffix);
   }
   return true;
 }

 }  // namespace

 bool UpdaterRuntime::UpdateDynamicPartitions(const std::string_view op_list_value) {
   auto super_device = GetSuperDevice();
   auto builder = MetadataBuilder::New(PartitionOpener(), super_device, 0);
   if (builder == nullptr) {
     LOG(ERROR) << "Failed to load dynamic partition metadata.";
     return false;
   }

   static const OpMap op_map{
     // clang-format off
     {"resize",                PerformOpResize},
     {"remove",                PerformOpRemove},
     {"add",                   PerformOpAdd},
     {"move",                  PerformOpMove},
     {"add_group",             PerformOpAddGroup},
     {"resize_group",          PerformOpResizeGroup},
     {"remove_group",          PerformOpRemoveGroup},
     {"remove_all_groups",     PerformOpRemoveAllGroups},
     // clang-format on
   };

   std::vector<std::string> lines = android::base::Split(std::string(op_list_value), "\n");
   for (const auto& line : lines) {
     auto comment_idx = line.find('#');
     auto op_and_args = comment_idx == std::string::npos ? line : line.substr(0, comment_idx);
     op_and_args = android::base::Trim(op_and_args);
     if (op_and_args.empty()) continue;

     auto tokens = android::base::Split(op_and_args, " ");
     const auto& op = tokens[0];
     auto it = op_map.find(op);
     if (it == op_map.end()) {
       LOG(ERROR) << "Unknown operation in op_list: " << op;
       return false;
     }
     OpParameters params;
     params.tokens = tokens;
     params.builder = builder.get();
     if (!it->second(params)) {
       return false;
     }
   }

   auto metadata = builder->Export();
   if (metadata == nullptr) {
     LOG(ERROR) << "Failed to export metadata.";
     return false;
   }

   if (!UpdatePartitionTable(super_device, *metadata, 0)) {
     LOG(ERROR) << "Failed to write metadata.";
     return false;
   }

   return true;
 }
	/*
	* Copyright (C) 2019 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 "updater/updater_runtime.h"

	#include <algorithm>
	#include <chrono>
	#include <iterator>
	#include <optional>
	#include <string>
	#include <type_traits>
	#include <vector>

	#include <android-base/logging.h>
	#include <android-base/parseint.h>
	#include <android-base/strings.h>
	#include <fs_mgr.h>
	#include <fs_mgr_dm_linear.h>
	#include <libdm/dm.h>
	#include <liblp/builder.h>

	using android::dm::DeviceMapper;
	using android::dm::DmDeviceState;
	using android::fs_mgr::CreateLogicalPartition;
	using android::fs_mgr::CreateLogicalPartitionParams;
	using android::fs_mgr::DestroyLogicalPartition;
	using android::fs_mgr::LpMetadata;
	using android::fs_mgr::MetadataBuilder;
	using android::fs_mgr::Partition;
	using android::fs_mgr::PartitionOpener;
	using android::fs_mgr::SlotNumberForSlotSuffix;

	static constexpr std::chrono::milliseconds kMapTimeout{ 1000 };

	static std::string GetSuperDevice() {
	return "/dev/block/by-name/" + fs_mgr_get_super_partition_name();
	}

	static std::string AddSlotSuffix(const std::string& partition_name) {
	return partition_name + fs_mgr_get_slot_suffix();
	}

	static bool UnmapPartitionWithSuffixOnDeviceMapper(const std::string& partition_name_suffix) {
	auto state = DeviceMapper::Instance().GetState(partition_name_suffix);
	if (state == DmDeviceState::INVALID) {
	return true;
	}
	if (state == DmDeviceState::ACTIVE) {
	return DestroyLogicalPartition(partition_name_suffix);
	}
	LOG(ERROR) << "Unknown device mapper state: "
	<< static_cast<std::underlying_type_t<DmDeviceState>>(state);
	return false;
	}

	bool UpdaterRuntime::MapPartitionOnDeviceMapper(const std::string& partition_name,
	std::string* path) {
	auto partition_name_suffix = AddSlotSuffix(partition_name);
	auto state = DeviceMapper::Instance().GetState(partition_name_suffix);
	if (state == DmDeviceState::INVALID) {
	CreateLogicalPartitionParams params = {
	.block_device = GetSuperDevice(),
	// If device supports A/B, apply non-A/B update to the partition at current slot. Otherwise,
	// SlotNumberForSlotSuffix("") returns 0.
	.metadata_slot = SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix()),
	// If device supports A/B, apply non-A/B update to the partition at current slot. Otherwise,
	// fs_mgr_get_slot_suffix() returns empty string.
	.partition_name = partition_name_suffix,
	.force_writable = true,
	.timeout_ms = kMapTimeout,
	};
	return CreateLogicalPartition(params, path);
	}

	if (state == DmDeviceState::ACTIVE) {
	return DeviceMapper::Instance().GetDmDevicePathByName(partition_name_suffix, path);
	}
	LOG(ERROR) << "Unknown device mapper state: "
	<< static_cast<std::underlying_type_t<DmDeviceState>>(state);
	return false;
	}

	bool UpdaterRuntime::UnmapPartitionOnDeviceMapper(const std::string& partition_name) {
	return ::UnmapPartitionWithSuffixOnDeviceMapper(AddSlotSuffix(partition_name));
	}

	namespace { // Ops

	struct OpParameters {
	std::vector<std::string> tokens;
	MetadataBuilder* builder;

	bool ExpectArgSize(size_t size) const {
	CHECK(!tokens.empty());
	auto actual = tokens.size() - 1;
	if (actual != size) {
	LOG(ERROR) << "Op " << op() << " expects " << size << " args, got " << actual;
	return false;
	}
	return true;
	}
	const std::string& op() const {
	CHECK(!tokens.empty());
	return tokens[0];
	}
	const std::string& arg(size_t pos) const {
	CHECK_LE(pos + 1, tokens.size());
	return tokens[pos + 1];
	}
	std::optional<uint64_t> uint_arg(size_t pos, const std::string& name) const {
	auto str = arg(pos);
	uint64_t ret;
	if (!android::base::ParseUint(str, &ret)) {
	LOG(ERROR) << "Op " << op() << " expects uint64 for argument " << name << ", got " << str;
	return std::nullopt;
	}
	return ret;
	}
	};

	using OpFunction = std::function<bool(const OpParameters&)>;
	using OpMap = std::map<std::string, OpFunction>;

	bool PerformOpResize(const OpParameters& params) {
	if (!params.ExpectArgSize(2)) return false;
	const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
	auto size = params.uint_arg(1, "size");
	if (!size.has_value()) return false;

	auto partition = params.builder->FindPartition(partition_name_suffix);
	if (partition == nullptr) {
	LOG(ERROR) << "Failed to find partition " << partition_name_suffix
	<< " in dynamic partition metadata.";
	return false;
	}
	if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
	LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before resizing.";
	return false;
	}
	if (!params.builder->ResizePartition(partition, size.value())) {
	LOG(ERROR) << "Failed to resize partition " << partition_name_suffix << " to size " << *size
	<< ".";
	return false;
	}
	return true;
	}

	bool PerformOpRemove(const OpParameters& params) {
	if (!params.ExpectArgSize(1)) return false;
	const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));

	if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
	LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before removing.";
	return false;
	}
	params.builder->RemovePartition(partition_name_suffix);
	return true;
	}

	bool PerformOpAdd(const OpParameters& params) {
	if (!params.ExpectArgSize(2)) return false;
	const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
	const auto& group_name_suffix = AddSlotSuffix(params.arg(1));

	if (params.builder->AddPartition(partition_name_suffix, group_name_suffix,
	LP_PARTITION_ATTR_READONLY) == nullptr) {
	LOG(ERROR) << "Failed to add partition " << partition_name_suffix << " to group "
	<< group_name_suffix << ".";
	return false;
	}
	return true;
	}

	bool PerformOpMove(const OpParameters& params) {
	if (!params.ExpectArgSize(2)) return false;
	const auto& partition_name_suffix = AddSlotSuffix(params.arg(0));
	const auto& new_group_name_suffix = AddSlotSuffix(params.arg(1));

	auto partition = params.builder->FindPartition(partition_name_suffix);
	if (partition == nullptr) {
	LOG(ERROR) << "Cannot move partition " << partition_name_suffix << " to group "
	<< new_group_name_suffix << " because it is not found.";
	return false;
	}

	auto old_group_name_suffix = partition->group_name();
	if (old_group_name_suffix != new_group_name_suffix) {
	if (!params.builder->ChangePartitionGroup(partition, new_group_name_suffix)) {
	LOG(ERROR) << "Cannot move partition " << partition_name_suffix << " from group "
	<< old_group_name_suffix << " to group " << new_group_name_suffix << ".";
	return false;
	}
	}
	return true;
	}

	bool PerformOpAddGroup(const OpParameters& params) {
	if (!params.ExpectArgSize(2)) return false;
	const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
	auto maximum_size = params.uint_arg(1, "maximum_size");
	if (!maximum_size.has_value()) return false;

	auto group = params.builder->FindGroup(group_name_suffix);
	if (group != nullptr) {
	LOG(ERROR) << "Cannot add group " << group_name_suffix << " because it already exists.";
	return false;
	}

	if (maximum_size.value() == 0) {
	LOG(WARNING) << "Adding group " << group_name_suffix << " with no size limits.";
	}

	if (!params.builder->AddGroup(group_name_suffix, maximum_size.value())) {
	LOG(ERROR) << "Failed to add group " << group_name_suffix << " with maximum size "
	<< maximum_size.value() << ".";
	return false;
	}
	return true;
	}

	bool PerformOpResizeGroup(const OpParameters& params) {
	if (!params.ExpectArgSize(2)) return false;
	const auto& group_name_suffix = AddSlotSuffix(params.arg(0));
	auto new_size = params.uint_arg(1, "maximum_size");
	if (!new_size.has_value()) return false;

	auto group = params.builder->FindGroup(group_name_suffix);
	if (group == nullptr) {
	LOG(ERROR) << "Cannot resize group " << group_name_suffix << " because it is not found.";
	return false;
	}

	auto old_size = group->maximum_size();
	if (old_size != new_size.value()) {
	if (!params.builder->ChangeGroupSize(group_name_suffix, new_size.value())) {
	LOG(ERROR) << "Cannot resize group " << group_name_suffix << " from " << old_size << " to "
	<< new_size.value() << ".";
	return false;
	}
	}
	return true;
	}

	std::vector<std::string> ListPartitionNamesInGroup(MetadataBuilder* builder,
	const std::string& group_name_suffix) {
	auto partitions = builder->ListPartitionsInGroup(group_name_suffix);
	std::vector<std::string> partition_names;
	std::transform(partitions.begin(), partitions.end(), std::back_inserter(partition_names),
	[](Partition* partition) { return partition->name(); });
	return partition_names;
	}

	bool PerformOpRemoveGroup(const OpParameters& params) {
	if (!params.ExpectArgSize(1)) return false;
	const auto& group_name_suffix = AddSlotSuffix(params.arg(0));

	auto partition_names = ListPartitionNamesInGroup(params.builder, group_name_suffix);
	if (!partition_names.empty()) {
	LOG(ERROR) << "Cannot remove group " << group_name_suffix
	<< " because it still contains partitions ["
	<< android::base::Join(partition_names, ", ") << "]";
	return false;
	}
	params.builder->RemoveGroupAndPartitions(group_name_suffix);
	return true;
	}

	bool PerformOpRemoveAllGroups(const OpParameters& params) {
	if (!params.ExpectArgSize(0)) return false;

	auto group_names = params.builder->ListGroups();
	for (const auto& group_name_suffix : group_names) {
	auto partition_names = ListPartitionNamesInGroup(params.builder, group_name_suffix);
	for (const auto& partition_name_suffix : partition_names) {
	if (!UnmapPartitionWithSuffixOnDeviceMapper(partition_name_suffix)) {
	LOG(ERROR) << "Cannot unmap " << partition_name_suffix << " before removing group "
	<< group_name_suffix << ".";
	return false;
	}
	}
	params.builder->RemoveGroupAndPartitions(group_name_suffix);
	}
	return true;
	}

	} // namespace

	bool UpdaterRuntime::UpdateDynamicPartitions(const std::string_view op_list_value) {
	auto super_device = GetSuperDevice();
	auto builder = MetadataBuilder::New(PartitionOpener(), super_device, 0);
	if (builder == nullptr) {
	LOG(ERROR) << "Failed to load dynamic partition metadata.";
	return false;
	}

	static const OpMap op_map{
	// clang-format off
	{"resize", PerformOpResize},
	{"remove", PerformOpRemove},
	{"add", PerformOpAdd},
	{"move", PerformOpMove},
	{"add_group", PerformOpAddGroup},
	{"resize_group", PerformOpResizeGroup},
	{"remove_group", PerformOpRemoveGroup},
	{"remove_all_groups", PerformOpRemoveAllGroups},
	// clang-format on
	};

	std::vector<std::string> lines = android::base::Split(std::string(op_list_value), "\n");
	for (const auto& line : lines) {
	auto comment_idx = line.find('#');
	auto op_and_args = comment_idx == std::string::npos ? line : line.substr(0, comment_idx);
	op_and_args = android::base::Trim(op_and_args);
	if (op_and_args.empty()) continue;

	auto tokens = android::base::Split(op_and_args, " ");
	const auto& op = tokens[0];
	auto it = op_map.find(op);
	if (it == op_map.end()) {
	LOG(ERROR) << "Unknown operation in op_list: " << op;
	return false;
	}
	OpParameters params;
	params.tokens = tokens;
	params.builder = builder.get();
	if (!it->second(params)) {
	return false;
	}
	}

	auto metadata = builder->Export();
	if (metadata == nullptr) {
	LOG(ERROR) << "Failed to export metadata.";
	return false;
	}

	if (!UpdatePartitionTable(super_device, *metadata, 0)) {
	LOG(ERROR) << "Failed to write metadata.";
	return false;
	}

	return true;
	}