Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 7a6c511a authored by David Anderson's avatar David Anderson
Browse files

liblp: Add an abstraction layer for opening partitions. 

This change introduces an IPartitionOpener abstraction. Methods that
interact with live metadata, such as ReadMetadata, UpdatePartitionTable,
and FlashPartitionTable, now require an IPartitionOpener object. Its
purpose is dependency injection: it will make these methods much easier
to test when the super partition spans multiple block devices.

All non-test consumers should be using PartitionOpener, and as such,
some helper methods have been added that automatically create one.

Bug: 116802789
Test: liblp_test gtest
      device with super partition boots
Change-Id: I76725a5830ef643c5007c152c00ccaad8085151f
parent 9a532417

fs_mgr/liblp/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ cc_library { 
    srcs: [

        "builder.cpp",

        "images.cpp",

        "partition_opener.cpp",

        "reader.cpp",

        "utility.cpp",

        "writer.cpp",
@@ -59,6 +60,7 @@ cc_test { 
    srcs: [

        "builder_test.cpp",

        "io_test.cpp",

        "test_partition_opener.cpp",

        "utility_test.cpp",

    ],

}

fs_mgr/liblp/builder.cpp

+9 −44
Original line number Diff line number Diff line
@@ -16,11 +16,7 @@ 


#include "liblp/builder.h"



#if defined(__linux__)

#include <linux/fs.h>

#endif

#include <string.h>

#include <sys/ioctl.h>



#include <algorithm>
@@ -33,43 +29,6 @@ 
namespace android {

namespace fs_mgr {



bool GetBlockDeviceInfo(const std::string& block_device, BlockDeviceInfo* device_info) {

#if defined(__linux__)

    android::base::unique_fd fd(open(block_device.c_str(), O_RDONLY));

    if (fd < 0) {

        PERROR << __PRETTY_FUNCTION__ << "open '" << block_device << "' failed";

        return false;

    }

    if (!GetDescriptorSize(fd, &device_info->size)) {

        return false;

    }

    if (ioctl(fd, BLKIOMIN, &device_info->alignment) < 0) {

        PERROR << __PRETTY_FUNCTION__ << "BLKIOMIN failed";

        return false;

    }



    int alignment_offset;

    if (ioctl(fd, BLKALIGNOFF, &alignment_offset) < 0) {

        PERROR << __PRETTY_FUNCTION__ << "BLKIOMIN failed";

        return false;

    }

    int logical_block_size;

    if (ioctl(fd, BLKSSZGET, &logical_block_size) < 0) {

        PERROR << __PRETTY_FUNCTION__ << "BLKSSZGET failed";

        return false;

    }



    device_info->alignment_offset = static_cast<uint32_t>(alignment_offset);

    device_info->logical_block_size = static_cast<uint32_t>(logical_block_size);

    return true;

#else

    (void)block_device;

    (void)device_info;

    LERROR << __PRETTY_FUNCTION__ << ": Not supported on this operating system.";

    return false;

#endif

}



void LinearExtent::AddTo(LpMetadata* out) const {

    out->extents.push_back(LpMetadataExtent{num_sectors_, LP_TARGET_TYPE_LINEAR, physical_sector_});

}
@@ -138,9 +97,10 @@ uint64_t Partition::BytesOnDisk() const { 
    return sectors * LP_SECTOR_SIZE;

}



std::unique_ptr<MetadataBuilder> MetadataBuilder::New(const std::string& block_device,

std::unique_ptr<MetadataBuilder> MetadataBuilder::New(const IPartitionOpener& opener,

                                                      const std::string& super_partition,

                                                      uint32_t slot_number) {

    std::unique_ptr<LpMetadata> metadata = ReadMetadata(block_device.c_str(), slot_number);

    std::unique_ptr<LpMetadata> metadata = ReadMetadata(opener, super_partition, slot_number);

    if (!metadata) {

        return nullptr;

    }
@@ -149,12 +109,17 @@ std::unique_ptr<MetadataBuilder> MetadataBuilder::New(const std::string& block_d 
        return nullptr;

    }

    BlockDeviceInfo device_info;

    if (fs_mgr::GetBlockDeviceInfo(block_device, &device_info)) {

    if (opener.GetInfo(super_partition, &device_info)) {

        builder->UpdateBlockDeviceInfo(device_info);

    }

    return builder;

}



std::unique_ptr<MetadataBuilder> MetadataBuilder::New(const std::string& super_partition,

                                                      uint32_t slot_number) {

    return New(PartitionOpener(), super_partition, slot_number);

}



std::unique_ptr<MetadataBuilder> MetadataBuilder::New(const BlockDeviceInfo& device_info,

                                                      uint32_t metadata_max_size,

                                                      uint32_t metadata_slot_count) {

fs_mgr/liblp/builder_test.cpp

+2 −5
Original line number Diff line number Diff line
@@ -424,13 +424,10 @@ TEST(liblp, block_device_info) { 
                                                               fs_mgr_free_fstab);

    ASSERT_NE(fstab, nullptr);



    // This should read from the "super" partition once we have a well-defined

    // way to access it.

    struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab.get(), "/data");

    ASSERT_NE(rec, nullptr);

    PartitionOpener opener;



    BlockDeviceInfo device_info;

    ASSERT_TRUE(GetBlockDeviceInfo(rec->blk_device, &device_info));

    ASSERT_TRUE(opener.GetInfo(fs_mgr_get_super_partition_name(), &device_info));



    // Sanity check that the device doesn't give us some weird inefficient

    // alignment.

fs_mgr/liblp/include/liblp/builder.h

+7 −22
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <memory>



#include "liblp.h"

#include "partition_opener.h"



namespace android {

namespace fs_mgr {
@@ -34,27 +35,6 @@ class LinearExtent; 
static const uint32_t kDefaultPartitionAlignment = 1024 * 1024;

static const uint32_t kDefaultBlockSize = 4096;



struct BlockDeviceInfo {

    BlockDeviceInfo() : size(0), alignment(0), alignment_offset(0), logical_block_size(0) {}

    BlockDeviceInfo(uint64_t size, uint32_t alignment, uint32_t alignment_offset,

                    uint32_t logical_block_size)

        : size(size),

          alignment(alignment),

          alignment_offset(alignment_offset),

          logical_block_size(logical_block_size) {}

    // Size of the block device, in bytes.

    uint64_t size;

    // Optimal target alignment, in bytes. Partition extents will be aligned to

    // this value by default. This value must be 0 or a multiple of 512.

    uint32_t alignment;

    // Alignment offset to parent device (if any), in bytes. The sector at

    // |alignment_offset| on the target device is correctly aligned on its

    // parent device. This value must be 0 or a multiple of 512.

    uint32_t alignment_offset;

    // Block size, for aligning extent sizes and partition sizes.

    uint32_t logical_block_size;

};



// Abstraction around dm-targets that can be encoded into logical partition tables.

class Extent {

  public:
@@ -157,7 +137,12 @@ class MetadataBuilder { 
    // Import an existing table for modification. This reads metadata off the

    // given block device and imports it. It also adjusts alignment information

    // based on run-time values in the operating system.

    static std::unique_ptr<MetadataBuilder> New(const std::string& block_device,

    static std::unique_ptr<MetadataBuilder> New(const IPartitionOpener& opener,

                                                const std::string& super_partition,

                                                uint32_t slot_number);



    // Same as above, but use the default PartitionOpener.

    static std::unique_ptr<MetadataBuilder> New(const std::string& super_partition,

                                                uint32_t slot_number);



    // Import an existing table for modification. If the table is not valid, for

fs_mgr/liblp/include/liblp/liblp.h

+15 −4
Original line number Diff line number Diff line
@@ -24,7 +24,10 @@ 
#include <memory>

#include <string>



#include <android-base/unique_fd.h>



#include "metadata_format.h"

#include "partition_opener.h"



namespace android {

namespace fs_mgr {
@@ -44,7 +47,8 @@ struct LpMetadata { 
// existing geometry, and should not be used for normal partition table

// updates. False can be returned if the geometry is incompatible with the

// block device or an I/O error occurs.

bool FlashPartitionTable(const std::string& block_device, const LpMetadata& metadata);

bool FlashPartitionTable(const IPartitionOpener& opener, const std::string& super_partition,

                         const LpMetadata& metadata);



// Update the partition table for a given metadata slot number. False is

// returned if an error occurs, which can include:
@@ -52,12 +56,19 @@ bool FlashPartitionTable(const std::string& block_device, const LpMetadata& meta 
//  - I/O error.

//  - Corrupt or missing metadata geometry on disk.

//  - Incompatible geometry.

bool UpdatePartitionTable(const std::string& block_device, const LpMetadata& metadata,

                          uint32_t slot_number);

bool UpdatePartitionTable(const IPartitionOpener& opener, const std::string& super_partition,

                          const LpMetadata& metadata, uint32_t slot_number);



// Read logical partition metadata from its predetermined location on a block

// device. If readback fails, we also attempt to load from a backup copy.

std::unique_ptr<LpMetadata> ReadMetadata(const char* block_device, uint32_t slot_number);

std::unique_ptr<LpMetadata> ReadMetadata(const IPartitionOpener& opener,

                                         const std::string& super_partition, uint32_t slot_number);



// Helper functions that use the default PartitionOpener.

bool FlashPartitionTable(const std::string& super_partition, const LpMetadata& metadata);

bool UpdatePartitionTable(const std::string& super_partition, const LpMetadata& metadata,

                          uint32_t slot_number);

std::unique_ptr<LpMetadata> ReadMetadata(const std::string& super_partition, uint32_t slot_number);



// Read/Write logical partition metadata to an image file, for diagnostics or

// flashing.