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

Commit cf311bd0 authored by David Anderson's avatar David Anderson
Browse files

libsnapshot: Remove direct accesses of CowOperation::source and compression. 

For the remaining use cases of accessing CowOperation::source and
compression, directly, introduce helper functions, since these fields
will be removed in the v3 format.

Bug: 280529365
Test: cow_api_test
Change-Id: I07031e8968525a7c1314ca45c284e476b51d8104
parent 09ccef49

fs_mgr/libsnapshot/include/libsnapshot/cow_format.h

+7 −0
Original line number Original line Diff line number Diff line
@@ -166,6 +166,13 @@ static constexpr uint8_t kCowReadAheadNotStarted = 0; 
static constexpr uint8_t kCowReadAheadInProgress = 1;

static constexpr uint8_t kCowReadAheadInProgress = 1;

static constexpr uint8_t kCowReadAheadDone = 2;

static constexpr uint8_t kCowReadAheadDone = 2;





static inline uint64_t GetCowOpSourceInfoData(const CowOperation* op) {

    return op->source;

}

static inline bool GetCowOpSourceInfoCompression(const CowOperation* op) {

    return op->compression != kCowCompressNone;

}



struct CowFooter {

struct CowFooter {

    CowFooterOperation op;

    CowFooterOperation op;

    uint8_t unused[64];

    uint8_t unused[64];

fs_mgr/libsnapshot/include/libsnapshot/cow_reader.h

+1 −0
Original line number Original line Diff line number Diff line
@@ -168,6 +168,7 @@ class CowReader final : public ICowReader { 
    bool ParseOps(std::optional<uint64_t> label);

    bool ParseOps(std::optional<uint64_t> label);

    bool PrepMergeOps();

    bool PrepMergeOps();

    uint64_t FindNumCopyops();

    uint64_t FindNumCopyops();

    uint8_t GetCompressionType(const CowOperation* op);





    android::base::unique_fd owned_fd_;

    android::base::unique_fd owned_fd_;

    android::base::borrowed_fd fd_;

    android::base::borrowed_fd fd_;

fs_mgr/libsnapshot/libsnapshot_cow/cow_reader.cpp

+10 −6
Original line number Original line Diff line number Diff line
@@ -517,7 +517,7 @@ bool CowReader::GetRawBytes(const CowOperation* op, void* buffer, size_t len, si 
        case kCowSequenceOp:

        case kCowSequenceOp:

        case kCowReplaceOp:

        case kCowReplaceOp:

        case kCowXorOp:

        case kCowXorOp:

            return GetRawBytes(op->source, buffer, len, read);

            return GetRawBytes(GetCowOpSourceInfoData(op), buffer, len, read);

        default:

        default:

            LOG(ERROR) << "Cannot get raw bytes of non-data op: " << *op;

            LOG(ERROR) << "Cannot get raw bytes of non-data op: " << *op;

            return false;

            return false;
@@ -574,10 +574,14 @@ class CowDataStream final : public IByteStream { 
    size_t remaining_;

    size_t remaining_;

};

};





uint8_t CowReader::GetCompressionType(const CowOperation* op) {

    return op->compression;

}



ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,

ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_size,

                            size_t ignore_bytes) {

                            size_t ignore_bytes) {

    std::unique_ptr<IDecompressor> decompressor;

    std::unique_ptr<IDecompressor> decompressor;

    switch (op->compression) {

    switch (GetCompressionType(op)) {

        case kCowCompressNone:

        case kCowCompressNone:

            break;

            break;

        case kCowCompressGz:

        case kCowCompressGz:
@@ -597,7 +601,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_ 
            }

            }

            break;

            break;

        default:

        default:

            LOG(ERROR) << "Unknown compression type: " << op->compression;

            LOG(ERROR) << "Unknown compression type: " << GetCompressionType(op);

            return -1;

            return -1;

    }

    }
@@ -605,7 +609,7 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_ 
    if (op->type == kCowXorOp) {

    if (op->type == kCowXorOp) {

        offset = data_loc_->at(op->new_block);

        offset = data_loc_->at(op->new_block);

    } else {

    } else {

        offset = op->source;

        offset = GetCowOpSourceInfoData(op);

    }

    }





    if (!decompressor) {

    if (!decompressor) {
@@ -621,10 +625,10 @@ ssize_t CowReader::ReadData(const CowOperation* op, void* buffer, size_t buffer_ 
bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {

bool CowReader::GetSourceOffset(const CowOperation* op, uint64_t* source_offset) {

    switch (op->type) {

    switch (op->type) {

        case kCowCopyOp:

        case kCowCopyOp:

            *source_offset = op->source * header_.block_size;

            *source_offset = GetCowOpSourceInfoData(op) * header_.block_size;

            return true;

            return true;

        case kCowXorOp:

        case kCowXorOp:

            *source_offset = op->source;

            *source_offset = GetCowOpSourceInfoData(op);

            return true;

            return true;

        default:

        default:

            return false;

            return false;

fs_mgr/libsnapshot/libsnapshot_cow/test_v2.cpp

+8 −8
Original line number Original line Diff line number Diff line
@@ -145,7 +145,7 @@ TEST_F(CowTest, ReadWrite) { 
    op = iter->Get();

    op = iter->Get();





    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->compression, kCowCompressNone);

    ASSERT_FALSE(GetCowOpSourceInfoCompression(op));

    ASSERT_EQ(op->data_length, 4096);

    ASSERT_EQ(op->data_length, 4096);

    ASSERT_EQ(op->new_block, 50);

    ASSERT_EQ(op->new_block, 50);

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -224,10 +224,10 @@ TEST_F(CowTest, ReadWriteXor) { 
    op = iter->Get();

    op = iter->Get();





    ASSERT_EQ(op->type, kCowXorOp);

    ASSERT_EQ(op->type, kCowXorOp);

    ASSERT_EQ(op->compression, kCowCompressNone);

    ASSERT_FALSE(GetCowOpSourceInfoCompression(op));

    ASSERT_EQ(op->data_length, 4096);

    ASSERT_EQ(op->data_length, 4096);

    ASSERT_EQ(op->new_block, 50);

    ASSERT_EQ(op->new_block, 50);

    ASSERT_EQ(op->source, 98314);  // 4096 * 24 + 10

    ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_EQ(sink, data);

    ASSERT_EQ(sink, data);
@@ -283,7 +283,7 @@ TEST_F(CowTest, CompressGz) { 
    std::string sink(data.size(), '\0');

    std::string sink(data.size(), '\0');





    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->compression, kCowCompressGz);

    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));

    ASSERT_EQ(op->data_length, 56);  // compressed!

    ASSERT_EQ(op->data_length, 56);  // compressed!

    ASSERT_EQ(op->new_block, 50);

    ASSERT_EQ(op->new_block, 50);

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -339,7 +339,7 @@ TEST_P(CompressionTest, ThreadedBatchWrites) { 
            total_blocks += 1;

            total_blocks += 1;

            std::string sink(xor_data.size(), '\0');

            std::string sink(xor_data.size(), '\0');

            ASSERT_EQ(op->new_block, 50);

            ASSERT_EQ(op->new_block, 50);

            ASSERT_EQ(op->source, 98314);  // 4096 * 24 + 10

            ASSERT_EQ(GetCowOpSourceInfoData(op), 98314);  // 4096 * 24 + 10

            ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

            ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

            ASSERT_EQ(sink, xor_data);

            ASSERT_EQ(sink, xor_data);

        }

        }
@@ -528,7 +528,7 @@ TEST_F(CowTest, ClusterCompressGz) { 
    std::string sink(data.size(), '\0');

    std::string sink(data.size(), '\0');





    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->compression, kCowCompressGz);

    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));

    ASSERT_EQ(op->data_length, 56);  // compressed!

    ASSERT_EQ(op->data_length, 56);  // compressed!

    ASSERT_EQ(op->new_block, 50);

    ASSERT_EQ(op->new_block, 50);

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -546,7 +546,7 @@ TEST_F(CowTest, ClusterCompressGz) { 




    sink = {};

    sink = {};

    sink.resize(data2.size(), '\0');

    sink.resize(data2.size(), '\0');

    ASSERT_EQ(op->compression, kCowCompressGz);

    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));

    ASSERT_EQ(op->data_length, 41);  // compressed!

    ASSERT_EQ(op->data_length, 41);  // compressed!

    ASSERT_EQ(op->new_block, 51);

    ASSERT_EQ(op->new_block, 51);

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));
@@ -591,7 +591,7 @@ TEST_F(CowTest, CompressTwoBlocks) { 




    auto op = iter->Get();

    auto op = iter->Get();

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->type, kCowReplaceOp);

    ASSERT_EQ(op->compression, kCowCompressGz);

    ASSERT_TRUE(GetCowOpSourceInfoCompression(op));

    ASSERT_EQ(op->new_block, 51);

    ASSERT_EQ(op->new_block, 51);

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

    ASSERT_TRUE(ReadData(reader, op, sink.data(), sink.size()));

}

}

fs_mgr/libsnapshot/snapuserd/dm-snapshot-merge/snapuserd.cpp

+1 −1
Original line number Original line Diff line number Diff line
@@ -508,7 +508,7 @@ bool Snapuserd::ReadMetadata() { 
            // the merge of operations are done based on the ops present

            // the merge of operations are done based on the ops present

            // in the file.

            // in the file.

            //===========================================================

            //===========================================================

            uint64_t block_source = cow_op->source;

            uint64_t block_source = GetCowOpSourceInfoData(cow_op);

            if (prev_id.has_value()) {

            if (prev_id.has_value()) {

                if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {

                if (dest_blocks.count(cow_op->new_block) || source_blocks.count(block_source)) {

                    break;

                    break;