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

Commit fb964a1f authored by Akilesh Kailash's avatar Akilesh Kailash
Browse files

snapuserd: Refactor buffer allocation code 



Since there is no change in the buffer allocation
code with respect to snapshots in user-space, refactor
it so that we have a common code base.

Bug: 193863397
Test: Build
Signed-off-by: default avatarAkilesh Kailash <akailash@google.com>
Change-Id: I3a7b3d319f6d1532b1bb63af9884b64e1346bb50
parent 228f6a09

fs_mgr/libsnapshot/snapuserd/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -61,6 +61,7 @@ cc_defaults { 
        "dm-snapshot-merge/snapuserd_worker.cpp",

        "dm-snapshot-merge/snapuserd_readahead.cpp",

        "snapuserd_daemon.cpp",

	"snapuserd_buffer.cpp",

	"user-space-merge/snapuserd_core.cpp",

	"user-space-merge/snapuserd_dm_user.cpp",

	"user-space-merge/snapuserd_merge.cpp",
@@ -109,6 +110,7 @@ cc_test { 
        "dm-snapshot-merge/cow_snapuserd_test.cpp",

        "dm-snapshot-merge/snapuserd.cpp",

        "dm-snapshot-merge/snapuserd_worker.cpp",

	"snapuserd_buffer.cpp",

    ],

    cflags: [

        "-Wall",

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

+1 −0
Original line number Diff line number Diff line
@@ -33,6 +33,7 @@ 
#include <libdm/dm.h>

#include <libdm/loop_control.h>

#include <libsnapshot/cow_writer.h>

#include <snapuserd/snapuserd_buffer.h>

#include <snapuserd/snapuserd_client.h>

#include <storage_literals/storage_literals.h>

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

+1 −33
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ 
#include <libdm/dm.h>

#include <libsnapshot/cow_reader.h>

#include <libsnapshot/cow_writer.h>

#include <snapuserd/snapuserd_buffer.h>

#include <snapuserd/snapuserd_kernel.h>



namespace android {
@@ -89,39 +90,6 @@ enum class READ_AHEAD_IO_TRANSITION { 
    READ_AHEAD_FAILURE,

};



class BufferSink : public IByteSink {

  public:

    void Initialize(size_t size);

    void* GetBufPtr() { return buffer_.get(); }

    void Clear() { memset(GetBufPtr(), 0, buffer_size_); }

    void* GetPayloadBuffer(size_t size);

    void* GetBuffer(size_t requested, size_t* actual) override;

    void UpdateBufferOffset(size_t size) { buffer_offset_ += size; }

    struct dm_user_header* GetHeaderPtr();

    bool ReturnData(void*, size_t) override { return true; }

    void ResetBufferOffset() { buffer_offset_ = 0; }

    void* GetPayloadBufPtr();



  private:

    std::unique_ptr<uint8_t[]> buffer_;

    loff_t buffer_offset_;

    size_t buffer_size_;

};



class XorSink : public IByteSink {

  public:

    void Initialize(BufferSink* sink, size_t size);

    void Reset();

    void* GetBuffer(size_t requested, size_t* actual) override;

    bool ReturnData(void* buffer, size_t len) override;



  private:

    BufferSink* bufsink_;

    std::unique_ptr<uint8_t[]> buffer_;

    size_t buffer_size_;

    size_t returned_;

};



class Snapuserd;



class ReadAheadThread {

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

+0 −72
Original line number Diff line number Diff line
@@ -32,78 +32,6 @@ using android::base::unique_fd; 
#define SNAP_LOG(level) LOG(level) << misc_name_ << ": "

#define SNAP_PLOG(level) PLOG(level) << misc_name_ << ": "



void BufferSink::Initialize(size_t size) {

    buffer_size_ = size;

    buffer_offset_ = 0;

    buffer_ = std::make_unique<uint8_t[]>(size);

}



void* BufferSink::GetPayloadBuffer(size_t size) {

    if ((buffer_size_ - buffer_offset_) < size) return nullptr;



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

    struct dm_user_message* msg = (struct dm_user_message*)(&(buffer[0]));

    return (char*)msg->payload.buf + buffer_offset_;

}



void* BufferSink::GetBuffer(size_t requested, size_t* actual) {

    void* buf = GetPayloadBuffer(requested);

    if (!buf) {

        *actual = 0;

        return nullptr;

    }

    *actual = requested;

    return buf;

}



struct dm_user_header* BufferSink::GetHeaderPtr() {

    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;

}



void* BufferSink::GetPayloadBufPtr() {

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

    struct dm_user_message* msg = reinterpret_cast<struct dm_user_message*>(&(buffer[0]));

    return msg->payload.buf;

}



void XorSink::Initialize(BufferSink* sink, size_t size) {

    bufsink_ = sink;

    buffer_size_ = size;

    returned_ = 0;

    buffer_ = std::make_unique<uint8_t[]>(size);

}



void XorSink::Reset() {

    returned_ = 0;

}



void* XorSink::GetBuffer(size_t requested, size_t* actual) {

    if (requested > buffer_size_) {

        *actual = buffer_size_;

    } else {

        *actual = requested;

    }

    return buffer_.get();

}



bool XorSink::ReturnData(void* buffer, size_t len) {

    uint8_t* xor_data = reinterpret_cast<uint8_t*>(buffer);

    uint8_t* buff = reinterpret_cast<uint8_t*>(bufsink_->GetPayloadBuffer(len + returned_));

    if (buff == nullptr) {

        return false;

    }

    for (size_t i = 0; i < len; i++) {

        buff[returned_ + i] ^= xor_data[i];

    }

    returned_ += len;

    return true;

}



WorkerThread::WorkerThread(const std::string& cow_device, const std::string& backing_device,

                           const std::string& control_device, const std::string& misc_name,

                           std::shared_ptr<Snapuserd> snapuserd) {

fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_buffer.h

0 → 100644
+62 −0
Original line number Diff line number Diff line 
// Copyright (C) 2021 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.



#pragma once



#include <linux/types.h>

#include <stdint.h>

#include <stdlib.h>



#include <iostream>



#include <libsnapshot/cow_reader.h>



namespace android {

namespace snapshot {



class BufferSink : public IByteSink {

  public:

    void Initialize(size_t size);

    void* GetBufPtr() { return buffer_.get(); }

    void Clear() { memset(GetBufPtr(), 0, buffer_size_); }

    void* GetPayloadBuffer(size_t size);

    void* GetBuffer(size_t requested, size_t* actual) override;

    void UpdateBufferOffset(size_t size) { buffer_offset_ += size; }

    struct dm_user_header* GetHeaderPtr();

    bool ReturnData(void*, size_t) override { return true; }

    void ResetBufferOffset() { buffer_offset_ = 0; }

    void* GetPayloadBufPtr();



  private:

    std::unique_ptr<uint8_t[]> buffer_;

    loff_t buffer_offset_;

    size_t buffer_size_;

};



class XorSink : public IByteSink {

  public:

    void Initialize(BufferSink* sink, size_t size);

    void Reset();

    void* GetBuffer(size_t requested, size_t* actual) override;

    bool ReturnData(void* buffer, size_t len) override;



  private:

    BufferSink* bufsink_;

    std::unique_ptr<uint8_t[]> buffer_;

    size_t buffer_size_;

    size_t returned_;

};



}  // namespace snapshot

}  // namespace android