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

Commit 771b17f5 authored by Akilesh Kailash's avatar Akilesh Kailash
Browse files

libsnapshot:snapuserd: Add 2MB scratch space in COW file 



Add 2MB scratch space in the COW file. This is a preparation
patch for read-ahead patch. This just add the buffer
space right after the header. Bump up the version number
in the header in order to distiguish between older and newer
COW formats.

No operation is done on this buffer with this patch-set.

Scratch space option is disabled by default.

Bug: 183863613
Test: 1: Create Full OTA with the new COW format.
2: Incremental OTA with older COW format.
3: vts_libsnapshot_test

Signed-off-by: default avatarAkilesh Kailash <akailash@google.com>
Change-Id: I42a535a48ec22adb893dfe6f86a4f51650e1f88a
parent 31e04264

fs_mgr/libsnapshot/cow_reader.cpp

+21 −12
Original line number Diff line number Diff line
@@ -94,11 +94,6 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab 
                   << "Expected: " << kCowMagicNumber;

        return false;

    }

    if (header_.header_size != sizeof(CowHeader)) {

        LOG(ERROR) << "Header size unknown, read " << header_.header_size << ", expected "

                   << sizeof(CowHeader);

        return false;

    }

    if (header_.footer_size != sizeof(CowFooter)) {

        LOG(ERROR) << "Footer size unknown, read " << header_.footer_size << ", expected "

                   << sizeof(CowFooter);
@@ -123,8 +118,7 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab 
        return false;

    }



    if ((header_.major_version != kCowVersionMajor) ||

        (header_.minor_version != kCowVersionMinor)) {

    if ((header_.major_version > kCowVersionMajor) || (header_.minor_version != kCowVersionMinor)) {

        LOG(ERROR) << "Header version mismatch";

        LOG(ERROR) << "Major version: " << header_.major_version

                   << "Expected: " << kCowVersionMajor;
@@ -137,11 +131,26 @@ bool CowReader::Parse(android::base::borrowed_fd fd, std::optional<uint64_t> lab 
}



bool CowReader::ParseOps(std::optional<uint64_t> label) {

    uint64_t pos = lseek(fd_.get(), sizeof(header_), SEEK_SET);

    if (pos != sizeof(header_)) {

    uint64_t pos;



    // Skip the scratch space

    if (header_.major_version >= 2 && (header_.buffer_size > 0)) {

        LOG(DEBUG) << " Scratch space found of size: " << header_.buffer_size;

        size_t init_offset = header_.header_size + header_.buffer_size;

        pos = lseek(fd_.get(), init_offset, SEEK_SET);

        if (pos != init_offset) {

            PLOG(ERROR) << "lseek ops failed";

            return false;

        }

    } else {

        pos = lseek(fd_.get(), header_.header_size, SEEK_SET);

        if (pos != header_.header_size) {

            PLOG(ERROR) << "lseek ops failed";

            return false;

        }

        // Reading a v1 version of COW which doesn't have buffer_size.

        header_.buffer_size = 0;

    }



    auto ops_buffer = std::make_shared<std::vector<CowOperation>>();

    uint64_t current_op_num = 0;
@@ -470,7 +479,7 @@ std::unique_ptr<ICowOpReverseIter> CowReader::GetRevOpIter() { 


bool CowReader::GetRawBytes(uint64_t offset, void* buffer, size_t len, size_t* read) {

    // Validate the offset, taking care to acknowledge possible overflow of offset+len.

    if (offset < sizeof(header_) || offset >= fd_size_ - sizeof(CowFooter) || len >= fd_size_ ||

    if (offset < header_.header_size || offset >= fd_size_ - sizeof(CowFooter) || len >= fd_size_ ||

        offset + len > fd_size_ - sizeof(CowFooter)) {

        LOG(ERROR) << "invalid data offset: " << offset << ", " << len << " bytes";

        return false;

fs_mgr/libsnapshot/cow_writer.cpp

+26 −1
Original line number Diff line number Diff line
@@ -94,6 +94,7 @@ void CowWriter::SetupHeaders() { 
    header_.block_size = options_.block_size;

    header_.num_merge_ops = 0;

    header_.cluster_ops = options_.cluster_ops;

    header_.buffer_size = 0;

    footer_ = {};

    footer_.op.data_length = 64;

    footer_.op.type = kCowFooterOp;
@@ -166,7 +167,7 @@ bool CowWriter::InitializeAppend(android::base::borrowed_fd fd, uint64_t label) 
}



void CowWriter::InitPos() {

    next_op_pos_ = sizeof(header_);

    next_op_pos_ = sizeof(header_) + header_.buffer_size;

    cluster_size_ = header_.cluster_ops * sizeof(CowOperation);

    if (header_.cluster_ops) {

        next_data_pos_ = next_op_pos_ + cluster_size_;
@@ -190,6 +191,10 @@ bool CowWriter::OpenForWrite() { 
        return false;

    }



    if (options_.scratch_space) {

        header_.buffer_size = BUFFER_REGION_DEFAULT_SIZE;

    }



    // Headers are not complete, but this ensures the file is at the right

    // position.

    if (!android::base::WriteFully(fd_, &header_, sizeof(header_))) {
@@ -197,7 +202,27 @@ bool CowWriter::OpenForWrite() { 
        return false;

    }



    if (options_.scratch_space) {

        // Initialize the scratch space

        std::string data(header_.buffer_size, 0);

        if (!android::base::WriteFully(fd_, data.data(), header_.buffer_size)) {

            PLOG(ERROR) << "writing scratch space failed";

            return false;

        }

    }



    if (!Sync()) {

        LOG(ERROR) << "Header sync failed";

        return false;

    }



    if (lseek(fd_.get(), sizeof(header_) + header_.buffer_size, SEEK_SET) < 0) {

        PLOG(ERROR) << "lseek failed";

        return false;

    }



    InitPos();



    return true;

}

fs_mgr/libsnapshot/include/libsnapshot/cow_format.h

+10 −1
Original line number Diff line number Diff line
@@ -21,11 +21,14 @@ namespace android { 
namespace snapshot {



static constexpr uint64_t kCowMagicNumber = 0x436f77634f572121ULL;

static constexpr uint32_t kCowVersionMajor = 1;

static constexpr uint32_t kCowVersionMajor = 2;

static constexpr uint32_t kCowVersionMinor = 0;



static constexpr uint32_t kCowVersionManifest = 1;



static constexpr uint32_t BLOCK_SZ = 4096;

static constexpr uint32_t BLOCK_SHIFT = (__builtin_ffs(BLOCK_SZ) - 1);



// This header appears as the first sequence of bytes in the COW. All fields

// in the layout are little-endian encoded. The on-disk layout is:

//
@@ -70,6 +73,9 @@ struct CowHeader { 


    // Tracks merge operations completed

    uint64_t num_merge_ops;



    // Scratch space used during merge

    uint32_t buffer_size;

} __attribute__((packed));



// This structure is the same size of a normal Operation, but is repurposed for the footer.
@@ -151,6 +157,9 @@ struct CowFooter { 
    CowFooterData data;

} __attribute__((packed));



// 2MB Scratch space used for read-ahead

static constexpr uint64_t BUFFER_REGION_DEFAULT_SIZE = (1ULL << 21);



std::ostream& operator<<(std::ostream& os, CowOperation const& arg);



int64_t GetNextOpOffset(const CowOperation& op, uint32_t cluster_size);

fs_mgr/libsnapshot/include/libsnapshot/cow_writer.h

+2 −0
Original line number Diff line number Diff line
@@ -36,6 +36,8 @@ struct CowOptions { 


    // Number of CowOperations in a cluster. 0 for no clustering. Cannot be 1.

    uint32_t cluster_ops = 200;



    bool scratch_space = false;

};



// Interface for writing to a snapuserd COW. All operations are ordered; merges

fs_mgr/libsnapshot/include/libsnapshot/snapuserd_kernel.h

+0 −3
Original line number Diff line number Diff line
@@ -47,9 +47,6 @@ typedef sector_t chunk_t; 
static constexpr uint32_t CHUNK_SIZE = 8;

static constexpr uint32_t CHUNK_SHIFT = (__builtin_ffs(CHUNK_SIZE) - 1);



static constexpr uint32_t BLOCK_SZ = 4096;

static constexpr uint32_t BLOCK_SHIFT = (__builtin_ffs(BLOCK_SZ) - 1);



#define DIV_ROUND_UP(n, d) (((n) + (d)-1) / (d))



// This structure represents the kernel COW header.