ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Don't hardcode the super partition name."

Browse source
This commit is contained in:
Treehugger Robot 2018-10-04 19:29:34 +00:00 • committed by Gerrit Code Review
commit 02678f32be
6 changed files with 24 additions and 8 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
fastboot/device/commands.cpp
View file

@ -27,6 +27,7 @@
#include <android-base/unique_fd.h>
#include <cutils/android_reboot.h>
#include <ext4_utils/wipe.h>
#include <fs_mgr.h>
#include <liblp/builder.h>
#include <liblp/liblp.h>
#include <uuid/uuid.h>
@ -310,7 +311,7 @@ class PartitionBuilder {
};
PartitionBuilder::PartitionBuilder(FastbootDevice* device) {
auto super_device = FindPhysicalPartition(LP_METADATA_PARTITION_NAME);
auto super_device = FindPhysicalPartition(fs_mgr_get_super_partition_name());
if (!super_device) {
return;
}

7
fastboot/device/utility.cpp
View file

@ -23,6 +23,7 @@
#include <android-base/file.h>
#include <android-base/logging.h>
#include <fs_mgr.h>
#include <fs_mgr_dm_linear.h>
#include <liblp/liblp.h>
@ -44,7 +45,7 @@ static bool OpenPhysicalPartition(const std::string& name, PartitionHandle* hand
static bool OpenLogicalPartition(const std::string& name, const std::string& slot,
PartitionHandle* handle) {
std::optional<std::string> path = FindPhysicalPartition(LP_METADATA_PARTITION_NAME);
std::optional<std::string> path = FindPhysicalPartition(fs_mgr_get_super_partition_name());
if (!path) {
return false;
}
@ -100,7 +101,7 @@ static const LpMetadataPartition* FindLogicalPartition(const LpMetadata& metadat
bool LogicalPartitionExists(const std::string& name, const std::string& slot_suffix,
bool* is_zero_length) {
auto path = FindPhysicalPartition(LP_METADATA_PARTITION_NAME);
auto path = FindPhysicalPartition(fs_mgr_get_super_partition_name());
if (!path) {
return false;
}
@ -149,7 +150,7 @@ std::vector<std::string> ListPartitions(FastbootDevice* device) {
}
// Next get logical partitions.
if (auto path = FindPhysicalPartition(LP_METADATA_PARTITION_NAME)) {
if (auto path = FindPhysicalPartition(fs_mgr_get_super_partition_name())) {
uint32_t slot_number = SlotNumberForSlotSuffix(device->GetCurrentSlot());
if (auto metadata = ReadMetadata(path->c_str(), slot_number)) {
for (const auto& partition : metadata->partitions) {

5
fs_mgr/fs_mgr.cpp
View file

@ -55,6 +55,7 @@
#include <ext4_utils/wipe.h>
#include <fs_mgr_overlayfs.h>
#include <libdm/dm.h>
#include <liblp/metadata_format.h>
#include <linux/fs.h>
#include <linux/loop.h>
#include <linux/magic.h>
@ -1540,3 +1541,7 @@ bool fs_mgr_update_verity_state(std::function<fs_mgr_verity_state_callback> call
return true;
}
std::string fs_mgr_get_super_partition_name(int /* slot */) {
return LP_METADATA_DEFAULT_PARTITION_NAME;
}

6
fs_mgr/include/fs_mgr.h
View file

@ -23,6 +23,7 @@
#include <linux/dm-ioctl.h>
#include <functional>
#include <string>
#include <fstab/fstab.h>
@ -89,4 +90,9 @@ int fs_mgr_do_format(struct fstab_rec *fstab, bool reserve_footer);
#define FS_MGR_SETUP_VERITY_SUCCESS 0
int fs_mgr_setup_verity(struct fstab_rec *fstab, bool wait_for_verity_dev);
// Return the name of the super partition if it exists. If a slot number is
// specified, the super partition for the corresponding metadata slot will be
// returned. Otherwise, it will use the current slot.
std::string fs_mgr_get_super_partition_name(int slot = -1);
#endif /* __CORE_FS_MGR_H */

2
fs_mgr/liblp/include/liblp/metadata_format.h
View file

@ -67,7 +67,7 @@ extern "C" {
* | Geometry Backup |
* +--------------------+
*/
#define LP_METADATA_PARTITION_NAME "super"
#define LP_METADATA_DEFAULT_PARTITION_NAME "super"
/* Size of a sector is always 512 bytes for compatibility with the Linux kernel. */
#define LP_SECTOR_SIZE 512

9
init/first_stage_mount.cpp
View file

@ -83,6 +83,7 @@ class FirstStageMount {
std::string lp_metadata_partition_;
std::vector<fstab_rec*> mount_fstab_recs_;
std::set<std::string> required_devices_partition_names_;
std::string super_partition_name_;
std::unique_ptr<DeviceHandler> device_handler_;
UeventListener uevent_listener_;
};
@ -153,6 +154,8 @@ FirstStageMount::FirstStageMount()
device_handler_ = std::make_unique<DeviceHandler>(
std::vector<Permissions>{}, std::vector<SysfsPermissions>{}, std::vector<Subsystem>{},
std::move(boot_devices), false);
super_partition_name_ = fs_mgr_get_super_partition_name();
}
std::unique_ptr<FirstStageMount> FirstStageMount::Create() {
@ -196,7 +199,7 @@ bool FirstStageMount::GetBackingDmLinearDevices() {
return true;
}
required_devices_partition_names_.emplace(LP_METADATA_PARTITION_NAME);
required_devices_partition_names_.emplace(super_partition_name_);
return true;
}
@ -262,7 +265,7 @@ bool FirstStageMount::CreateLogicalPartitions() {
if (lp_metadata_partition_.empty()) {
LOG(ERROR) << "Could not locate logical partition tables in partition "
<< LP_METADATA_PARTITION_NAME;
<< super_partition_name_;
return false;
}
return android::fs_mgr::CreateLogicalPartitions(lp_metadata_partition_);
@ -275,7 +278,7 @@ ListenerAction FirstStageMount::HandleBlockDevice(const std::string& name, const
auto iter = required_devices_partition_names_.find(name);
if (iter != required_devices_partition_names_.end()) {
LOG(VERBOSE) << __PRETTY_FUNCTION__ << ": found partition: " << *iter;
if (IsDmLinearEnabled() && name == LP_METADATA_PARTITION_NAME) {
if (IsDmLinearEnabled() && name == super_partition_name_) {
std::vector<std::string> links = device_handler_->GetBlockDeviceSymlinks(uevent);
lp_metadata_partition_ = links[0];
}