blob: 40c266373ba9ed70b7de982891013d964e7374b0 [file] [log] [blame]
//
// 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