//
|
// 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 "update_engine/dynamic_partition_control_android.h"
|
|
#include <memory>
|
#include <set>
|
#include <string>
|
|
#include <android-base/properties.h>
|
#include <android-base/strings.h>
|
#include <base/files/file_util.h>
|
#include <base/logging.h>
|
#include <bootloader_message/bootloader_message.h>
|
#include <fs_mgr_dm_linear.h>
|
|
#include "update_engine/common/boot_control_interface.h"
|
#include "update_engine/common/utils.h"
|
|
using android::base::GetBoolProperty;
|
using android::base::Join;
|
using android::dm::DeviceMapper;
|
using android::dm::DmDeviceState;
|
using android::fs_mgr::CreateLogicalPartition;
|
using android::fs_mgr::DestroyLogicalPartition;
|
using android::fs_mgr::MetadataBuilder;
|
using android::fs_mgr::PartitionOpener;
|
|
namespace chromeos_update_engine {
|
|
constexpr char kUseDynamicPartitions[] = "ro.boot.dynamic_partitions";
|
constexpr char kRetrfoitDynamicPartitions[] =
|
"ro.boot.dynamic_partitions_retrofit";
|
constexpr uint64_t kMapTimeoutMillis = 1000;
|
|
DynamicPartitionControlAndroid::~DynamicPartitionControlAndroid() {
|
CleanupInternal(false /* wait */);
|
}
|
|
bool DynamicPartitionControlAndroid::IsDynamicPartitionsEnabled() {
|
return GetBoolProperty(kUseDynamicPartitions, false);
|
}
|
|
bool DynamicPartitionControlAndroid::IsDynamicPartitionsRetrofit() {
|
return GetBoolProperty(kRetrfoitDynamicPartitions, false);
|
}
|
|
bool DynamicPartitionControlAndroid::MapPartitionInternal(
|
const std::string& super_device,
|
const std::string& target_partition_name,
|
uint32_t slot,
|
bool force_writable,
|
std::string* path) {
|
if (!CreateLogicalPartition(super_device.c_str(),
|
slot,
|
target_partition_name,
|
force_writable,
|
std::chrono::milliseconds(kMapTimeoutMillis),
|
path)) {
|
LOG(ERROR) << "Cannot map " << target_partition_name << " in "
|
<< super_device << " on device mapper.";
|
return false;
|
}
|
LOG(INFO) << "Succesfully mapped " << target_partition_name
|
<< " to device mapper (force_writable = " << force_writable
|
<< "); device path at " << *path;
|
mapped_devices_.insert(target_partition_name);
|
return true;
|
}
|
|
bool DynamicPartitionControlAndroid::MapPartitionOnDeviceMapper(
|
const std::string& super_device,
|
const std::string& target_partition_name,
|
uint32_t slot,
|
bool force_writable,
|
std::string* path) {
|
DmDeviceState state = GetState(target_partition_name);
|
if (state == DmDeviceState::ACTIVE) {
|
if (mapped_devices_.find(target_partition_name) != mapped_devices_.end()) {
|
if (GetDmDevicePathByName(target_partition_name, path)) {
|
LOG(INFO) << target_partition_name
|
<< " is mapped on device mapper: " << *path;
|
return true;
|
}
|
LOG(ERROR) << target_partition_name << " is mapped but path is unknown.";
|
return false;
|
}
|
// If target_partition_name is not in mapped_devices_ but state is ACTIVE,
|
// the device might be mapped incorrectly before. Attempt to unmap it.
|
// Note that for source partitions, if GetState() == ACTIVE, callers (e.g.
|
// BootControlAndroid) should not call MapPartitionOnDeviceMapper, but
|
// should directly call GetDmDevicePathByName.
|
if (!UnmapPartitionOnDeviceMapper(target_partition_name, true /* wait */)) {
|
LOG(ERROR) << target_partition_name
|
<< " is mapped before the update, and it cannot be unmapped.";
|
return false;
|
}
|
state = GetState(target_partition_name);
|
if (state != DmDeviceState::INVALID) {
|
LOG(ERROR) << target_partition_name << " is unmapped but state is "
|
<< static_cast<std::underlying_type_t<DmDeviceState>>(state);
|
return false;
|
}
|
}
|
if (state == DmDeviceState::INVALID) {
|
return MapPartitionInternal(
|
super_device, target_partition_name, slot, force_writable, path);
|
}
|
|
LOG(ERROR) << target_partition_name
|
<< " is mapped on device mapper but state is unknown: "
|
<< static_cast<std::underlying_type_t<DmDeviceState>>(state);
|
return false;
|
}
|
|
bool DynamicPartitionControlAndroid::UnmapPartitionOnDeviceMapper(
|
const std::string& target_partition_name, bool wait) {
|
if (DeviceMapper::Instance().GetState(target_partition_name) !=
|
DmDeviceState::INVALID) {
|
if (!DestroyLogicalPartition(
|
target_partition_name,
|
std::chrono::milliseconds(wait ? kMapTimeoutMillis : 0))) {
|
LOG(ERROR) << "Cannot unmap " << target_partition_name
|
<< " from device mapper.";
|
return false;
|
}
|
LOG(INFO) << "Successfully unmapped " << target_partition_name
|
<< " from device mapper.";
|
}
|
mapped_devices_.erase(target_partition_name);
|
return true;
|
}
|
|
void DynamicPartitionControlAndroid::CleanupInternal(bool wait) {
|
// UnmapPartitionOnDeviceMapper removes objects from mapped_devices_, hence
|
// a copy is needed for the loop.
|
std::set<std::string> mapped = mapped_devices_;
|
LOG(INFO) << "Destroying [" << Join(mapped, ", ") << "] from device mapper";
|
for (const auto& partition_name : mapped) {
|
ignore_result(UnmapPartitionOnDeviceMapper(partition_name, wait));
|
}
|
}
|
|
void DynamicPartitionControlAndroid::Cleanup() {
|
CleanupInternal(true /* wait */);
|
}
|
|
bool DynamicPartitionControlAndroid::DeviceExists(const std::string& path) {
|
return base::PathExists(base::FilePath(path));
|
}
|
|
android::dm::DmDeviceState DynamicPartitionControlAndroid::GetState(
|
const std::string& name) {
|
return DeviceMapper::Instance().GetState(name);
|
}
|
|
bool DynamicPartitionControlAndroid::GetDmDevicePathByName(
|
const std::string& name, std::string* path) {
|
return DeviceMapper::Instance().GetDmDevicePathByName(name, path);
|
}
|
|
std::unique_ptr<MetadataBuilder>
|
DynamicPartitionControlAndroid::LoadMetadataBuilder(
|
const std::string& super_device,
|
uint32_t source_slot,
|
uint32_t target_slot) {
|
std::unique_ptr<MetadataBuilder> builder;
|
|
if (target_slot != BootControlInterface::kInvalidSlot &&
|
IsDynamicPartitionsRetrofit()) {
|
builder = MetadataBuilder::NewForUpdate(
|
PartitionOpener(), super_device, source_slot, target_slot);
|
} else {
|
builder =
|
MetadataBuilder::New(PartitionOpener(), super_device, source_slot);
|
}
|
|
if (builder == nullptr) {
|
LOG(WARNING) << "No metadata slot "
|
<< BootControlInterface::SlotName(source_slot) << " in "
|
<< super_device;
|
return nullptr;
|
}
|
LOG(INFO) << "Loaded metadata from slot "
|
<< BootControlInterface::SlotName(source_slot) << " in "
|
<< super_device;
|
return builder;
|
}
|
|
bool DynamicPartitionControlAndroid::StoreMetadata(
|
const std::string& super_device,
|
MetadataBuilder* builder,
|
uint32_t target_slot) {
|
auto metadata = builder->Export();
|
if (metadata == nullptr) {
|
LOG(ERROR) << "Cannot export metadata to slot "
|
<< BootControlInterface::SlotName(target_slot) << " in "
|
<< super_device;
|
return false;
|
}
|
|
if (IsDynamicPartitionsRetrofit()) {
|
if (!FlashPartitionTable(super_device, *metadata)) {
|
LOG(ERROR) << "Cannot write metadata to " << super_device;
|
return false;
|
}
|
LOG(INFO) << "Written metadata to " << super_device;
|
} else {
|
if (!UpdatePartitionTable(super_device, *metadata, target_slot)) {
|
LOG(ERROR) << "Cannot write metadata to slot "
|
<< BootControlInterface::SlotName(target_slot) << " in "
|
<< super_device;
|
return false;
|
}
|
LOG(INFO) << "Copied metadata to slot "
|
<< BootControlInterface::SlotName(target_slot) << " in "
|
<< super_device;
|
}
|
|
return true;
|
}
|
|
bool DynamicPartitionControlAndroid::GetDeviceDir(std::string* out) {
|
// We can't use fs_mgr to look up |partition_name| because fstab
|
// doesn't list every slot partition (it uses the slotselect option
|
// to mask the suffix).
|
//
|
// We can however assume that there's an entry for the /misc mount
|
// point and use that to get the device file for the misc
|
// partition. This helps us locate the disk that |partition_name|
|
// resides on. From there we'll assume that a by-name scheme is used
|
// so we can just replace the trailing "misc" by the given
|
// |partition_name| and suffix corresponding to |slot|, e.g.
|
//
|
// /dev/block/platform/soc.0/7824900.sdhci/by-name/misc ->
|
// /dev/block/platform/soc.0/7824900.sdhci/by-name/boot_a
|
//
|
// If needed, it's possible to relax the by-name assumption in the
|
// future by trawling /sys/block looking for the appropriate sibling
|
// of misc and then finding an entry in /dev matching the sysfs
|
// entry.
|
|
std::string err, misc_device = get_bootloader_message_blk_device(&err);
|
if (misc_device.empty()) {
|
LOG(ERROR) << "Unable to get misc block device: " << err;
|
return false;
|
}
|
|
if (!utils::IsSymlink(misc_device.c_str())) {
|
LOG(ERROR) << "Device file " << misc_device << " for /misc "
|
<< "is not a symlink.";
|
return false;
|
}
|
*out = base::FilePath(misc_device).DirName().value();
|
return true;
|
}
|
} // namespace chromeos_update_engine
|
