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

Commit a8e8d94e authored by David Anderson's avatar David Anderson Committed by Automerger Merge Worker
Browse files

Merge "libsnapshot: Add a source_partition parameter to OpenSnapshotWriter."... 

Merge "libsnapshot: Add a source_partition parameter to OpenSnapshotWriter." am: 7d66a600 am: ded0ee57

Original change: https://android-review.googlesource.com/c/platform/system/core/+/1441021

Change-Id: Ib00280286ec803beb6cffb3a60293ffb1d709f95
parents f9e036a1 ded0ee57

fs_mgr/libsnapshot/include/libsnapshot/mock_snapshot.h

+3 −1
Original line number Diff line number Diff line
@@ -39,7 +39,9 @@ class MockSnapshotManager : public ISnapshotManager { 
                 std::string* snapshot_path),

                (override));

    MOCK_METHOD(std::unique_ptr<ISnapshotWriter>, OpenSnapshotWriter,

                (const android::fs_mgr::CreateLogicalPartitionParams& params), (override));

                (const android::fs_mgr::CreateLogicalPartitionParams& params,

                 const std::optional<std::string>&),

                (override));

    MOCK_METHOD(bool, UnmapUpdateSnapshot, (const std::string& target_partition_name), (override));

    MOCK_METHOD(bool, NeedSnapshotsInFirstStageMount, (), (override));

    MOCK_METHOD(bool, CreateLogicalAndSnapshotPartitions,

fs_mgr/libsnapshot/include/libsnapshot/snapshot.h

+15 −11
Original line number Diff line number Diff line
@@ -182,9 +182,12 @@ class ISnapshotManager { 
                                   std::string* snapshot_path) = 0;



    // Create an ISnapshotWriter to build a snapshot against a target partition. The partition name

    // must be suffixed.

    // must be suffixed. If a source partition exists, it must be specified as well. The source

    // partition will only be used if raw bytes are needed. The source partition should be an

    // absolute path to the device, not a partition name.

    virtual std::unique_ptr<ISnapshotWriter> OpenSnapshotWriter(

            const android::fs_mgr::CreateLogicalPartitionParams& params) = 0;

            const android::fs_mgr::CreateLogicalPartitionParams& params,

            const std::optional<std::string>& source_device) = 0;



    // Unmap a snapshot device or CowWriter that was previously opened with MapUpdateSnapshot,

    // OpenSnapshotWriter. All outstanding open descriptors, writers, or
@@ -300,7 +303,8 @@ class SnapshotManager final : public ISnapshotManager { 
    bool MapUpdateSnapshot(const CreateLogicalPartitionParams& params,

                           std::string* snapshot_path) override;

    std::unique_ptr<ISnapshotWriter> OpenSnapshotWriter(

            const android::fs_mgr::CreateLogicalPartitionParams& params) override;

            const android::fs_mgr::CreateLogicalPartitionParams& params,

            const std::optional<std::string>& source_device) override;

    bool UnmapUpdateSnapshot(const std::string& target_partition_name) override;

    bool NeedSnapshotsInFirstStageMount() override;

    bool CreateLogicalAndSnapshotPartitions(
@@ -540,13 +544,13 @@ class SnapshotManager final : public ISnapshotManager { 
    };



    // Helpers for OpenSnapshotWriter.

    std::unique_ptr<ISnapshotWriter> OpenCompressedSnapshotWriter(LockedFile* lock,

                                                                  const std::string& partition_name,

                                                                  const SnapshotStatus& status,

    std::unique_ptr<ISnapshotWriter> OpenCompressedSnapshotWriter(

            LockedFile* lock, const std::optional<std::string>& source_device,

            const std::string& partition_name, const SnapshotStatus& status,

            const SnapshotPaths& paths);

    std::unique_ptr<ISnapshotWriter> OpenKernelSnapshotWriter(LockedFile* lock,

                                                              const std::string& partition_name,

                                                              const SnapshotStatus& status,

    std::unique_ptr<ISnapshotWriter> OpenKernelSnapshotWriter(

            LockedFile* lock, const std::optional<std::string>& source_device,

            const std::string& partition_name, const SnapshotStatus& status,

            const SnapshotPaths& paths);



    // Map the base device, COW devices, and snapshot device.

fs_mgr/libsnapshot/include/libsnapshot/snapshot_stub.h

+2 −1
Original line number Diff line number Diff line
@@ -37,7 +37,8 @@ class SnapshotManagerStub : public ISnapshotManager { 
    bool MapUpdateSnapshot(const android::fs_mgr::CreateLogicalPartitionParams& params,

                           std::string* snapshot_path) override;

    std::unique_ptr<ISnapshotWriter> OpenSnapshotWriter(

            const android::fs_mgr::CreateLogicalPartitionParams& params) override;

            const android::fs_mgr::CreateLogicalPartitionParams& params,

            const std::optional<std::string>& source_device) override;

    bool UnmapUpdateSnapshot(const std::string& target_partition_name) override;

    bool NeedSnapshotsInFirstStageMount() override;

    bool CreateLogicalAndSnapshotPartitions(

fs_mgr/libsnapshot/include/libsnapshot/snapshot_writer.h

+7 −2
Original line number Diff line number Diff line
@@ -33,13 +33,18 @@ class ISnapshotWriter : public ICowWriter { 


    // Set the source device. This is used for AddCopy() operations, if the

    // underlying writer needs the original bytes (for example if backed by

    // dm-snapshot or if writing directly to an unsnapshotted region).

    void SetSourceDevice(android::base::unique_fd&& source_fd);

    // dm-snapshot or if writing directly to an unsnapshotted region). The

    // device is only opened on the first operation that requires it.

    void SetSourceDevice(const std::string& source_device);



    virtual std::unique_ptr<FileDescriptor> OpenReader() = 0;



  protected:

    android::base::borrowed_fd GetSourceFd();



  private:

    android::base::unique_fd source_fd_;

    std::optional<std::string> source_device_;

};



// Send writes to a COW or a raw device directly, based on a threshold.

fs_mgr/libsnapshot/snapshot.cpp

+19 −13
Original line number Diff line number Diff line
@@ -2471,9 +2471,11 @@ bool SnapshotManager::MapUpdateSnapshot(const CreateLogicalPartitionParams& para 
}



std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenSnapshotWriter(

        const android::fs_mgr::CreateLogicalPartitionParams& params) {

        const android::fs_mgr::CreateLogicalPartitionParams& params,

        const std::optional<std::string>& source_device) {

#if defined(LIBSNAPSHOT_NO_COW_WRITE)

    (void)params;

    (void)source_device;



    LOG(ERROR) << "Snapshots cannot be written in first-stage init or recovery";

    return nullptr;
@@ -2508,16 +2510,19 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenSnapshotWriter( 
    }



    if (IsCompressionEnabled()) {

        return OpenCompressedSnapshotWriter(lock.get(), params.GetPartitionName(), status, paths);

        return OpenCompressedSnapshotWriter(lock.get(), source_device, params.GetPartitionName(),

                                            status, paths);

    }

    return OpenKernelSnapshotWriter(lock.get(), params.GetPartitionName(), status, paths);

    return OpenKernelSnapshotWriter(lock.get(), source_device, params.GetPartitionName(), status,

                                    paths);

#endif

}



#if !defined(LIBSNAPSHOT_NO_COW_WRITE)

std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter(

        LockedFile* lock, [[maybe_unused]] const std::string& partition_name,

        const SnapshotStatus& status, const SnapshotPaths& paths) {

        LockedFile* lock, const std::optional<std::string>& source_device,

        [[maybe_unused]] const std::string& partition_name, const SnapshotStatus& status,

        const SnapshotPaths& paths) {

    CHECK(lock);



    CowOptions cow_options;
@@ -2529,13 +2534,9 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter( 
    CHECK(status.snapshot_size() == status.device_size());



    auto writer = std::make_unique<CompressedSnapshotWriter>(cow_options);



    unique_fd base_fd(open(paths.target_device.c_str(), O_RDWR | O_CLOEXEC));

    if (base_fd < 0) {

        PLOG(ERROR) << "OpenCompressedSnapshotWriter: open " << paths.target_device;

        return nullptr;

    if (source_device) {

        writer->SetSourceDevice(*source_device);

    }

    writer->SetSourceDevice(std::move(base_fd));



    std::string cow_path;

    if (!GetMappedImageDevicePath(paths.cow_device_name, &cow_path)) {
@@ -2557,8 +2558,9 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenCompressedSnapshotWriter( 
}



std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenKernelSnapshotWriter(

        LockedFile* lock, [[maybe_unused]] const std::string& partition_name,

        const SnapshotStatus& status, const SnapshotPaths& paths) {

        LockedFile* lock, const std::optional<std::string>& source_device,

        [[maybe_unused]] const std::string& partition_name, const SnapshotStatus& status,

        const SnapshotPaths& paths) {

    CHECK(lock);



    CowOptions cow_options;
@@ -2573,6 +2575,10 @@ std::unique_ptr<ISnapshotWriter> SnapshotManager::OpenKernelSnapshotWriter( 
        return nullptr;

    }



    if (source_device) {

        writer->SetSourceDevice(*source_device);

    }



    uint64_t cow_size = status.cow_partition_size() + status.cow_file_size();

    writer->SetSnapshotDevice(std::move(fd), cow_size);