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

Commit 419e336b authored by Akilesh Kailash's avatar Akilesh Kailash Committed by Automerger Merge Worker
Browse files

Merge "snapuserd: Remove assertions from daemon" am: fcd105d5 am: c362b175... 

Merge "snapuserd: Remove assertions from daemon" am: fcd105d5 am: c362b175 am: d46c4a6c am: 3055d4b7

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

Change-Id: I71ef9a58f9cae3d80518c30d86a30215e1524f1c
parents 22d49dc5 3055d4b7

fs_mgr/libsnapshot/cow_reader.cpp

+0 −1
Original line number Diff line number Diff line
@@ -377,7 +377,6 @@ void CowReader::InitializeMerge() { 
              });



    if (header_.num_merge_ops > 0) {

        CHECK(ops_->size() >= header_.num_merge_ops);

        ops_->erase(ops_.get()->begin(), ops_.get()->begin() + header_.num_merge_ops);

    }

fs_mgr/libsnapshot/snapuserd.cpp

+13 −3
Original line number Diff line number Diff line
@@ -90,7 +90,10 @@ void Snapuserd::PrepareReadAhead() { 
}



bool Snapuserd::GetRABuffer(std::unique_lock<std::mutex>* lock, uint64_t block, void* buffer) {

    CHECK(lock->owns_lock());

    if (!lock->owns_lock()) {

        SNAP_LOG(ERROR) << "GetRABuffer - Lock not held";

        return false;

    }

    std::unordered_map<uint64_t, void*>::iterator it = read_ahead_buffer_map_.find(block);



    // This will be true only for IO's generated as part of reading a root
@@ -344,7 +347,10 @@ bool Snapuserd::ReadMetadata() { 
        return false;

    }



    CHECK(header.block_size == BLOCK_SZ);

    if (!(header.block_size == BLOCK_SZ)) {

        SNAP_LOG(ERROR) << "Invalid header block size found: " << header.block_size;

        return false;

    }



    reader_->InitializeMerge();

    SNAP_LOG(DEBUG) << "Merge-ops: " << header.num_merge_ops;
@@ -610,7 +616,11 @@ bool Snapuserd::ReadMetadata() { 
                    SNAP_LOG(DEBUG) << "ReadMetadata() completed; Number of Areas: " << vec_.size();

                }



                CHECK(pending_copy_ops == 0);

                if (!(pending_copy_ops == 0)) {

                    SNAP_LOG(ERROR)

                            << "Invalid pending_copy_ops: expected: 0 found: " << pending_copy_ops;

                    return false;

                }

                pending_copy_ops = exceptions_per_area_;

            }

fs_mgr/libsnapshot/snapuserd_readahead.cpp

+6 −3
Original line number Diff line number Diff line
@@ -257,7 +257,12 @@ bool ReadAheadThread::ReconstructDataFromCow() { 
            // Verify that we have covered all the ops which were re-constructed

            // from COW device - These are the ops which are being

            // re-constructed after crash.

            CHECK(num_ops == 0);

            if (!(num_ops == 0)) {

                SNAP_LOG(ERROR) << "ReconstructDataFromCow failed. Not all ops recoverd "

                                << " Pending ops: " << num_ops;

                snapuserd_->ReadAheadIOFailed();

                return false;

            }

            break;

        }

    }
@@ -370,8 +375,6 @@ bool ReadAheadThread::ReadAheadIOStart() { 
        bm->file_offset = 0;



        buffer_offset += io_size;

        CHECK(offset == buffer_offset);

        CHECK((file_offset - snapuserd_->GetBufferDataOffset()) == offset);

    }



    snapuserd_->SetTotalRaBlocksMerged(total_blocks_merged);

fs_mgr/libsnapshot/snapuserd_server.cpp

+4 −1
Original line number Diff line number Diff line
@@ -378,7 +378,10 @@ std::shared_ptr<DmUserHandler> SnapuserdServer::AddHandler(const std::string& mi 
}



bool SnapuserdServer::StartHandler(const std::shared_ptr<DmUserHandler>& handler) {

    CHECK(!handler->snapuserd()->IsAttached());

    if (handler->snapuserd()->IsAttached()) {

        LOG(ERROR) << "Handler already attached";

        return false;

    }



    handler->snapuserd()->AttachControlDevice();

fs_mgr/libsnapshot/snapuserd_worker.cpp

+114 −44
Original line number Diff line number Diff line
@@ -57,7 +57,9 @@ void* BufferSink::GetBuffer(size_t requested, size_t* actual) { 
}



struct dm_user_header* BufferSink::GetHeaderPtr() {

    CHECK(sizeof(struct dm_user_header) <= buffer_size_);

    if (!(sizeof(struct dm_user_header) <= buffer_size_)) {

        return nullptr;

    }

    char* buf = reinterpret_cast<char*>(GetBufPtr());

    struct dm_user_header* header = (struct dm_user_header*)(&(buf[0]));

    return header;
@@ -111,7 +113,6 @@ bool WorkerThread::InitReader() { 
// the header, zero out the remaining block.

void WorkerThread::ConstructKernelCowHeader() {

    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);

    CHECK(buffer != nullptr);



    memset(buffer, 0, BLOCK_SZ);
@@ -137,7 +138,10 @@ bool WorkerThread::ProcessReplaceOp(const CowOperation* cow_op) { 


bool WorkerThread::ReadFromBaseDevice(const CowOperation* cow_op) {

    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);

    CHECK(buffer != nullptr);

    if (buffer == nullptr) {

        SNAP_LOG(ERROR) << "ReadFromBaseDevice: Failed to get payload buffer";

        return false;

    }

    SNAP_LOG(DEBUG) << " ReadFromBaseDevice...: new-block: " << cow_op->new_block

                    << " Source: " << cow_op->source;

    if (!android::base::ReadFullyAtOffset(backing_store_fd_, buffer, BLOCK_SZ,
@@ -152,7 +156,10 @@ bool WorkerThread::ReadFromBaseDevice(const CowOperation* cow_op) { 


bool WorkerThread::GetReadAheadPopulatedBuffer(const CowOperation* cow_op) {

    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);

    CHECK(buffer != nullptr);

    if (buffer == nullptr) {

        SNAP_LOG(ERROR) << "GetReadAheadPopulatedBuffer: Failed to get payload buffer";

        return false;

    }



    if (!snapuserd_->GetReadAheadPopulatedBuffer(cow_op->new_block, buffer)) {

        return false;
@@ -178,14 +185,20 @@ bool WorkerThread::ProcessCopyOp(const CowOperation* cow_op) { 
bool WorkerThread::ProcessZeroOp() {

    // Zero out the entire block

    void* buffer = bufsink_.GetPayloadBuffer(BLOCK_SZ);

    CHECK(buffer != nullptr);

    if (buffer == nullptr) {

        SNAP_LOG(ERROR) << "ProcessZeroOp: Failed to get payload buffer";

        return false;

    }



    memset(buffer, 0, BLOCK_SZ);

    return true;

}



bool WorkerThread::ProcessCowOp(const CowOperation* cow_op) {

    CHECK(cow_op != nullptr);

    if (cow_op == nullptr) {

        SNAP_LOG(ERROR) << "ProcessCowOp: Invalid cow_op";

        return false;

    }



    switch (cow_op->type) {

        case kCowReplaceOp: {
@@ -216,7 +229,8 @@ int WorkerThread::ReadUnalignedSector( 
                    << " Aligned sector: " << it->first;



    if (!ProcessCowOp(it->second)) {

        SNAP_LOG(ERROR) << "ReadUnalignedSector: " << sector << " failed of size: " << size;

        SNAP_LOG(ERROR) << "ReadUnalignedSector: " << sector << " failed of size: " << size

                        << " Aligned sector: " << it->first;

        return -1;

    }
@@ -261,7 +275,10 @@ int WorkerThread::ReadData(sector_t sector, size_t size) { 
    it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(), std::make_pair(sector, nullptr),

                          Snapuserd::compare);



    CHECK(it != chunk_vec.end());

    if (!(it != chunk_vec.end())) {

        SNAP_LOG(ERROR) << "ReadData: Sector " << sector << " not found in chunk_vec";

        return -1;

    }



    // We didn't find the required sector; hence find the previous sector

    // as lower_bound will gives us the value greater than
@@ -334,7 +351,10 @@ bool WorkerThread::ZerofillDiskExceptions(size_t read_size) { 
    }



    void* buffer = bufsink_.GetPayloadBuffer(size);

    CHECK(buffer != nullptr);

    if (buffer == nullptr) {

        SNAP_LOG(ERROR) << "ZerofillDiskExceptions: Failed to get payload buffer";

        return false;

    }



    memset(buffer, 0, size);

    return true;
@@ -364,10 +384,17 @@ bool WorkerThread::ReadDiskExceptions(chunk_t chunk, size_t read_size) { 
    if (divresult.quot < vec.size()) {

        size = exceptions_per_area_ * sizeof(struct disk_exception);



        CHECK(read_size == size);

        if (read_size != size) {

            SNAP_LOG(ERROR) << "ReadDiskExceptions: read_size: " << read_size

                            << " does not match with size: " << size;

            return false;

        }



        void* buffer = bufsink_.GetPayloadBuffer(size);

        CHECK(buffer != nullptr);

        if (buffer == nullptr) {

            SNAP_LOG(ERROR) << "ReadDiskExceptions: Failed to get payload buffer of size: " << size;

            return false;

        }



        memcpy(buffer, vec[divresult.quot].get(), size);

    } else {
@@ -390,8 +417,19 @@ loff_t WorkerThread::GetMergeStartOffset(void* merged_buffer, void* unmerged_buf 


        // Unmerged op by the kernel

        if (merged_de->old_chunk != 0 || merged_de->new_chunk != 0) {

            CHECK(merged_de->old_chunk == cow_de->old_chunk);

            CHECK(merged_de->new_chunk == cow_de->new_chunk);

            if (!(merged_de->old_chunk == cow_de->old_chunk)) {

                SNAP_LOG(ERROR) << "GetMergeStartOffset: merged_de->old_chunk: "

                                << merged_de->old_chunk

                                << "cow_de->old_chunk: " << cow_de->old_chunk;

                return -1;

            }



            if (!(merged_de->new_chunk == cow_de->new_chunk)) {

                SNAP_LOG(ERROR) << "GetMergeStartOffset: merged_de->new_chunk: "

                                << merged_de->new_chunk

                                << "cow_de->new_chunk: " << cow_de->new_chunk;

                return -1;

            }



            offset += sizeof(struct disk_exception);

            *unmerged_exceptions += 1;
@@ -401,8 +439,6 @@ loff_t WorkerThread::GetMergeStartOffset(void* merged_buffer, void* unmerged_buf 
        break;

    }



    CHECK(!(*unmerged_exceptions == exceptions_per_area_));



    SNAP_LOG(DEBUG) << "Unmerged_Exceptions: " << *unmerged_exceptions << " Offset: " << offset;

    return offset;

}
@@ -421,8 +457,15 @@ int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffe 
        struct disk_exception* cow_de =

                reinterpret_cast<struct disk_exception*>((char*)unmerged_buffer + offset);



        CHECK(merged_de->new_chunk == 0);

        CHECK(merged_de->old_chunk == 0);

        if (!(merged_de->new_chunk == 0)) {

            SNAP_LOG(ERROR) << "GetNumberOfMergedOps: Invalid new-chunk: " << merged_de->new_chunk;

            return -1;

        }



        if (!(merged_de->old_chunk == 0)) {

            SNAP_LOG(ERROR) << "GetNumberOfMergedOps: Invalid old-chunk: " << merged_de->old_chunk;

            return -1;

        }



        if (cow_de->new_chunk != 0) {

            merged_ops_cur_iter += 1;
@@ -430,11 +473,18 @@ int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffe 
            auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),

                                       std::make_pair(ChunkToSector(cow_de->new_chunk), nullptr),

                                       Snapuserd::compare);

            CHECK(it != chunk_vec.end());

            CHECK(it->first == ChunkToSector(cow_de->new_chunk));



            if (!(it != chunk_vec.end())) {

                SNAP_LOG(ERROR) << "Sector not found: " << ChunkToSector(cow_de->new_chunk);

                return -1;

            }



            if (!(it->first == ChunkToSector(cow_de->new_chunk))) {

                SNAP_LOG(ERROR) << "Invalid sector: " << ChunkToSector(cow_de->new_chunk);

                return -1;

            }

            const CowOperation* cow_op = it->second;



            CHECK(cow_op != nullptr);

            if (snapuserd_->IsReadAheadFeaturePresent() && cow_op->type == kCowCopyOp) {

                *copy_op = true;

                // Every single copy operation has to come from read-ahead
@@ -453,7 +503,6 @@ int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffe 
                }

            }



            CHECK(cow_op->new_block == cow_de->old_chunk);

            // zero out to indicate that operation is merged.

            cow_de->old_chunk = 0;

            cow_de->new_chunk = 0;
@@ -463,7 +512,6 @@ int WorkerThread::GetNumberOfMergedOps(void* merged_buffer, void* unmerged_buffe 
            //

            // If the op was merged in previous cycle, we don't have

            // to count them.

            CHECK(cow_de->new_chunk == 0);

            break;

        } else {

            SNAP_LOG(ERROR) << "Error in merge operation. Found invalid metadata: "
@@ -488,18 +536,33 @@ bool WorkerThread::ProcessMergeComplete(chunk_t chunk, void* buffer) { 


    // ChunkID to vector index

    lldiv_t divresult = lldiv(chunk, stride);

    CHECK(divresult.quot < vec.size());



    if (!(divresult.quot < vec.size())) {

        SNAP_LOG(ERROR) << "ProcessMergeComplete: Invalid chunk: " << chunk

                        << " Metadata-Index: " << divresult.quot << " Area-size: " << vec.size();

        return false;

    }



    SNAP_LOG(DEBUG) << "ProcessMergeComplete: chunk: " << chunk

                    << " Metadata-Index: " << divresult.quot;



    int unmerged_exceptions = 0;

    loff_t offset = GetMergeStartOffset(buffer, vec[divresult.quot].get(), &unmerged_exceptions);



    if (offset < 0) {

        SNAP_LOG(ERROR) << "GetMergeStartOffset failed: unmerged_exceptions: "

                        << unmerged_exceptions;

        return false;

    }



    int merged_ops_cur_iter = GetNumberOfMergedOps(buffer, vec[divresult.quot].get(), offset,

                                                   unmerged_exceptions, &copy_op, &commit);



    // There should be at least one operation merged in this cycle

    CHECK(merged_ops_cur_iter > 0);

    if (!(merged_ops_cur_iter > 0)) {

        SNAP_LOG(ERROR) << "Merge operation failed: " << merged_ops_cur_iter;

        return false;

    }



    if (copy_op) {

        if (commit) {
@@ -570,8 +633,12 @@ bool WorkerThread::DmuserWriteRequest() { 
    // REQ_PREFLUSH flag set. Snapuser daemon doesn't have anything

    // to flush per se; hence, just respond back with a success message.

    if (header->sector == 0) {

        CHECK(header->len == 0);

        if (!(header->len == 0)) {

            header->type = DM_USER_RESP_ERROR;

        } else {

            header->type = DM_USER_RESP_SUCCESS;

        }



        if (!WriteDmUserPayload(0)) {

            return false;

        }
@@ -581,18 +648,20 @@ bool WorkerThread::DmuserWriteRequest() { 
    std::vector<std::pair<sector_t, const CowOperation*>>& chunk_vec = snapuserd_->GetChunkVec();

    size_t remaining_size = header->len;

    size_t read_size = std::min(PAYLOAD_SIZE, remaining_size);

    CHECK(read_size == BLOCK_SZ) << "DmuserWriteRequest: read_size: " << read_size;



    CHECK(header->sector > 0);

    chunk_t chunk = SectorToChunk(header->sector);

    auto it = std::lower_bound(chunk_vec.begin(), chunk_vec.end(),

                               std::make_pair(header->sector, nullptr), Snapuserd::compare);



    bool not_found = (it == chunk_vec.end() || it->first != header->sector);

    CHECK(not_found);



    if (not_found) {

        void* buffer = bufsink_.GetPayloadBuffer(read_size);

    CHECK(buffer != nullptr);

        if (buffer == nullptr) {

            SNAP_LOG(ERROR) << "DmuserWriteRequest: Failed to get payload buffer of size: "

                            << read_size;

            header->type = DM_USER_RESP_ERROR;

        } else {

            header->type = DM_USER_RESP_SUCCESS;



            if (!ReadDmUserPayload(buffer, read_size)) {
@@ -605,9 +674,11 @@ bool WorkerThread::DmuserWriteRequest() { 
                SNAP_LOG(ERROR) << "ProcessMergeComplete failed for chunk id: " << chunk

                                << "Sector: " << header->sector;

                header->type = DM_USER_RESP_ERROR;

            }

        }

    } else {

        SNAP_LOG(DEBUG) << "ProcessMergeComplete success for chunk id: " << chunk

                        << "Sector: " << header->sector;

        SNAP_LOG(ERROR) << "DmuserWriteRequest: Invalid sector received: header->sector";

        header->type = DM_USER_RESP_ERROR;

    }



    if (!WriteDmUserPayload(0)) {
@@ -636,7 +707,6 @@ bool WorkerThread::DmuserReadRequest() { 
        // never see multiple IO requests. Additionally this IO

        // will always be a single 4k.

        if (header->sector == 0) {

            CHECK(read_size == BLOCK_SZ) << " Sector 0 read request of size: " << read_size;

            ConstructKernelCowHeader();

            SNAP_LOG(DEBUG) << "Kernel header constructed";

        } else {