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

Commit cedb057e authored by David Anderson's avatar David Anderson Committed by Gerrit Code Review
Browse files

Merge changes Ibffdd9c9,Ief5a16d1 

* changes:
  libsnapshot: Add a test case for unexpected snapshots during data resets.
  libfiemap: Add some dependency injection.
parents 53dfacea 7b33fad1

fs_mgr/libfiemap/binder.cpp

+3 −2
Original line number Diff line number Diff line
@@ -224,8 +224,9 @@ bool ImageManagerBinder::MapAllImages(const std::function<bool(std::set<std::str 
    return false;

}



std::unique_ptr<IImageManager> IImageManager::Open(

        const std::string& dir, const std::chrono::milliseconds& /*timeout_ms*/) {

std::unique_ptr<IImageManager> IImageManager::Open(const std::string& dir,

                                                   const std::chrono::milliseconds& /*timeout_ms*/,

                                                   const DeviceInfo&) {

    android::sp<IGsiService> service = android::gsi::GetGsiService();

    android::sp<IImageService> manager;

fs_mgr/libfiemap/image_manager.cpp

+26 −11
Original line number Diff line number Diff line
@@ -55,7 +55,8 @@ using android::fs_mgr::GetPartitionName; 
static constexpr char kTestImageMetadataDir[] = "/metadata/gsi/test";

static constexpr char kOtaTestImageMetadataDir[] = "/metadata/gsi/ota/test";



std::unique_ptr<ImageManager> ImageManager::Open(const std::string& dir_prefix) {

std::unique_ptr<ImageManager> ImageManager::Open(const std::string& dir_prefix,

                                                 const DeviceInfo& device_info) {

    auto metadata_dir = "/metadata/gsi/" + dir_prefix;

    auto data_dir = "/data/gsi/" + dir_prefix;

    auto install_dir_file = gsi::DsuInstallDirFile(gsi::GetDsuSlot(dir_prefix));
@@ -63,17 +64,28 @@ std::unique_ptr<ImageManager> ImageManager::Open(const std::string& dir_prefix) 
    if (ReadFileToString(install_dir_file, &path)) {

        data_dir = path;

    }

    return Open(metadata_dir, data_dir);

    return Open(metadata_dir, data_dir, device_info);

}



std::unique_ptr<ImageManager> ImageManager::Open(const std::string& metadata_dir,

                                                 const std::string& data_dir) {

    return std::unique_ptr<ImageManager>(new ImageManager(metadata_dir, data_dir));

                                                 const std::string& data_dir,

                                                 const DeviceInfo& device_info) {

    return std::unique_ptr<ImageManager>(new ImageManager(metadata_dir, data_dir, device_info));

}



ImageManager::ImageManager(const std::string& metadata_dir, const std::string& data_dir)

    : metadata_dir_(metadata_dir), data_dir_(data_dir) {

ImageManager::ImageManager(const std::string& metadata_dir, const std::string& data_dir,

                           const DeviceInfo& device_info)

    : metadata_dir_(metadata_dir), data_dir_(data_dir), device_info_(device_info) {

    partition_opener_ = std::make_unique<android::fs_mgr::PartitionOpener>();



    // Allow overriding whether ImageManager thinks it's in recovery, for testing.

#ifdef __ANDROID_RECOVERY__

    device_info_.is_recovery = {true};

#else

    if (!device_info_.is_recovery.has_value()) {

        device_info_.is_recovery = {false};

    }

#endif

}



std::string ImageManager::GetImageHeaderPath(const std::string& name) {
@@ -261,10 +273,11 @@ bool ImageManager::DeleteBackingImage(const std::string& name) { 
        return false;

    }



#if defined __ANDROID_RECOVERY__

    if (device_info_.is_recovery.value()) {

        LOG(ERROR) << "Cannot remove images backed by /data in recovery";

        return false;

#else

    }



    std::string message;

    auto header_file = GetImageHeaderPath(name);

    if (!SplitFiemap::RemoveSplitFiles(header_file, &message)) {
@@ -278,7 +291,6 @@ bool ImageManager::DeleteBackingImage(const std::string& name) { 
        LOG(ERROR) << "Error removing " << status_file << ": " << message;

    }

    return RemoveImageMetadata(metadata_dir_, name);

#endif

}



// Create a block device for an image file, using its extents in its
@@ -521,6 +533,9 @@ bool ImageManager::MapImageDevice(const std::string& name, 
    // filesystem. This should only happen on devices with no encryption, or

    // devices with FBE and no metadata encryption. For these cases it suffices

    // to perform normal file writes to /data/gsi (which is unencrypted).

    //

    // Note: this is not gated on DeviceInfo, because the recovery-specific path

    // must only be used in actual recovery.

    std::string block_device;

    bool can_use_devicemapper;

    if (!FiemapWriter::GetBlockDeviceForFile(image_header, &block_device, &can_use_devicemapper)) {

fs_mgr/libfiemap/include/libfiemap/image_manager.h

+16 −5
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ 
#include <chrono>

#include <functional>

#include <memory>

#include <optional>

#include <set>

#include <string>
@@ -37,11 +38,17 @@ class IImageManager { 


    virtual ~IImageManager() {}



    // Helper for dependency injection.

    struct DeviceInfo {

        std::optional<bool> is_recovery;

    };



    // When linking to libfiemap_binder, the Open() call will use binder.

    // Otherwise, the Open() call will use the ImageManager implementation

    // below.

    // below. In binder mode, device_info is ignored.

    static std::unique_ptr<IImageManager> Open(const std::string& dir_prefix,

                                               const std::chrono::milliseconds& timeout_ms);

                                               const std::chrono::milliseconds& timeout_ms,

                                               const DeviceInfo& device_info = {});



    // Flags for CreateBackingImage().

    static constexpr int CREATE_IMAGE_DEFAULT = 0x0;
@@ -131,11 +138,13 @@ class ImageManager final : public IImageManager { 
    // Return an ImageManager for the given metadata and data directories. Both

    // directories must already exist.

    static std::unique_ptr<ImageManager> Open(const std::string& metadata_dir,

                                              const std::string& data_dir);

                                              const std::string& data_dir,

                                              const DeviceInfo& device_info = {});



    // Helper function that derives the metadata and data dirs given a single

    // prefix.

    static std::unique_ptr<ImageManager> Open(const std::string& dir_prefix);

    static std::unique_ptr<ImageManager> Open(const std::string& dir_prefix,

                                              const DeviceInfo& device_info = {});



    // Methods that must be implemented from IImageManager.

    FiemapStatus CreateBackingImage(const std::string& name, uint64_t size, int flags,
@@ -166,7 +175,8 @@ class ImageManager final : public IImageManager { 
    FiemapStatus ZeroFillNewImage(const std::string& name, uint64_t bytes);



  private:

    ImageManager(const std::string& metadata_dir, const std::string& data_dir);

    ImageManager(const std::string& metadata_dir, const std::string& data_dir,

                 const DeviceInfo& device_info);

    std::string GetImageHeaderPath(const std::string& name);

    std::string GetStatusFilePath(const std::string& image_name);

    bool MapWithLoopDevice(const std::string& name, const std::chrono::milliseconds& timeout_ms,
@@ -187,6 +197,7 @@ class ImageManager final : public IImageManager { 
    std::string metadata_dir_;

    std::string data_dir_;

    std::unique_ptr<IPartitionOpener> partition_opener_;

    DeviceInfo device_info_;

};



// RAII helper class for mapping and opening devices with an ImageManager.

fs_mgr/libfiemap/passthrough.cpp

+3 −2
Original line number Diff line number Diff line
@@ -20,9 +20,10 @@ namespace android { 
namespace fiemap {



std::unique_ptr<IImageManager> IImageManager::Open(const std::string& dir_prefix,

                                                   const std::chrono::milliseconds& timeout_ms) {

                                                   const std::chrono::milliseconds& timeout_ms,

                                                   const DeviceInfo& device_info) {

    (void)timeout_ms;

    return ImageManager::Open(dir_prefix);

    return ImageManager::Open(dir_prefix, device_info);

}



}  // namespace fiemap

fs_mgr/libsnapshot/include/libsnapshot/snapshot.h

+1 −0
Original line number Diff line number Diff line
@@ -392,6 +392,7 @@ class SnapshotManager final : public ISnapshotManager { 
    FRIEND_TEST(SnapshotUpdateTest, DaemonTransition);

    FRIEND_TEST(SnapshotUpdateTest, DataWipeAfterRollback);

    FRIEND_TEST(SnapshotUpdateTest, DataWipeRollbackInRecovery);

    FRIEND_TEST(SnapshotUpdateTest, DataWipeWithStaleSnapshots);

    FRIEND_TEST(SnapshotUpdateTest, FullUpdateFlow);

    FRIEND_TEST(SnapshotUpdateTest, MergeCannotRemoveCow);

    FRIEND_TEST(SnapshotUpdateTest, MergeInRecovery);