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

Commit 7bd9162b authored by David Anderson's avatar David Anderson Committed by Gerrit Code Review
Browse files

Merge changes Ic18443d4,I9e9af999,I10e099fe,I00cf6ec9,Ia1ea4ba7 into main 

* changes:
  snapuserd: Reduce size of COWs in tests.
  snapuserd: Add unit tests for ReadWorker::ReadAlignedSector.
  snapuesrd: Build snapuserd_test on host.
  snapuserd: Add an ITestHarness implementation for hosts.
  snapuserd: Don't specify a path to TemporaryFile.
parents 9c525ff0 1333d87b

fs_mgr/libsnapshot/snapuserd/Android.bp

+3 −0
Original line number Diff line number Diff line
@@ -90,6 +90,7 @@ cc_library_static { 
    ramdisk_available: true,

    vendor_ramdisk_available: true,

    recovery_available: true,

    host_supported: true,

}



cc_defaults {
@@ -222,6 +223,7 @@ cc_test { 
    srcs: [

        "testing/dm_user_harness.cpp",

        "testing/harness.cpp",

        "testing/host_harness.cpp",

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

    ],

    shared_libs: [
@@ -255,4 +257,5 @@ cc_test { 
    },

    auto_gen_config: true,

    require_root: false,

    host_supported: true,

}

fs_mgr/libsnapshot/snapuserd/include/snapuserd/snapuserd_kernel.h

+4 −2
Original line number Diff line number Diff line
@@ -14,6 +14,8 @@ 


#pragma once



#include <linux/types.h>



namespace android {

namespace snapshot {
@@ -70,7 +72,7 @@ struct disk_header { 


    /* In sectors */

    uint32_t chunk_size;

} __packed;

} __attribute__((packed));



// A disk exception is a mapping of old_chunk to new_chunk

// old_chunk is the chunk ID of a dm-snapshot device.
@@ -78,7 +80,7 @@ struct disk_header { 
struct disk_exception {

    uint64_t old_chunk;

    uint64_t new_chunk;

} __packed;

} __attribute__((packed));



// Control structures to communicate with dm-user

// It comprises of header and a payload

fs_mgr/libsnapshot/snapuserd/testing/host_harness.cpp

0 → 100644
+112 −0
Original line number Diff line number Diff line 
// Copyright (C) 2023 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.



#include "host_harness.h"



#include "snapuserd_logging.h"



namespace android {

namespace snapshot {



void TestBlockServerQueue::WaitForShutdown() {

    std::unique_lock lock(m_);

    if (shutdown_) {

        return;

    }

    cv_.wait(lock, [this]() -> bool { return shutdown_; });

}



void TestBlockServerQueue::Shutdown() {

    std::unique_lock lock(m_);

    shutdown_ = true;

    cv_.notify_all();

}



TestBlockServer::TestBlockServer(std::shared_ptr<TestBlockServerQueue> queue,

                                 const std::string& misc_name)

    : queue_(queue), misc_name_(misc_name) {}



bool TestBlockServer::ProcessRequests() {

    queue_->WaitForShutdown();

    return false;

}



void* TestBlockServer::GetResponseBuffer(size_t size, size_t to_write) {

    std::string buffer(size, '\0');

    buffered_.emplace_back(std::move(buffer), to_write);

    return buffered_.back().first.data();

}



bool TestBlockServer::SendBufferedIo() {

    for (const auto& [data, to_write] : buffered_) {

        sent_io_ += data.substr(0, to_write);

    }

    buffered_.clear();

    return true;

}



TestBlockServerOpener::TestBlockServerOpener(std::shared_ptr<TestBlockServerQueue> queue,

                                             const std::string& misc_name)

    : queue_(queue), misc_name_(misc_name) {}



std::unique_ptr<IBlockServer> TestBlockServerOpener::Open(IBlockServer::Delegate*, size_t) {

    return std::make_unique<TestBlockServer>(queue_, misc_name_);

}



std::shared_ptr<TestBlockServerOpener> TestBlockServerFactory::CreateTestOpener(

        const std::string& misc_name) {

    if (queues_.count(misc_name)) {

        LOG(ERROR) << "Cannot create opener for " << misc_name << ", already exists";

        return nullptr;

    }

    auto queue = std::make_shared<TestBlockServerQueue>();

    queues_.emplace(misc_name, queue);

    return std::make_shared<TestBlockServerOpener>(queue, misc_name);

}



std::shared_ptr<IBlockServerOpener> TestBlockServerFactory::CreateOpener(

        const std::string& misc_name) {

    return CreateTestOpener(misc_name);

}



bool TestBlockServerFactory::DeleteQueue(const std::string& misc_name) {

    auto iter = queues_.find(misc_name);

    if (iter == queues_.end()) {

        LOG(ERROR) << "Cannot delete queue " << misc_name << ", not found";

        return false;

    }

    iter->second->Shutdown();

    queues_.erase(iter);

    return true;

}



HostUserDevice::HostUserDevice(TestBlockServerFactory* factory, const std::string& misc_name)

    : factory_(factory), misc_name_(misc_name) {}



bool HostUserDevice::Destroy() {

    return factory_->DeleteQueue(misc_name_);

}



std::unique_ptr<IUserDevice> HostTestHarness::CreateUserDevice(const std::string&,

                                                               const std::string& misc_name,

                                                               uint64_t) {

    return std::make_unique<HostUserDevice>(&factory_, misc_name);

}



IBlockServerFactory* HostTestHarness::GetBlockServerFactory() {

    return &factory_;

}



}  // namespace snapshot

}  // namespace android

fs_mgr/libsnapshot/snapuserd/testing/host_harness.h

0 → 100644
+105 −0
Original line number Diff line number Diff line 
// Copyright (C) 2023 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 <condition_variable>

#include <mutex>

#include <string>

#include <unordered_map>

#include <utility>

#include <vector>



#include "harness.h"



namespace android {

namespace snapshot {



class TestBlockServerQueue final {

  public:

    void WaitForShutdown();

    void Shutdown();



  private:

    std::mutex m_;

    std::condition_variable cv_;

    bool shutdown_ = false;

};



class TestBlockServer final : public IBlockServer {

  public:

    TestBlockServer(std::shared_ptr<TestBlockServerQueue> queue, const std::string& misc_name);

    bool ProcessRequests() override;

    void* GetResponseBuffer(size_t size, size_t to_write) override;

    bool SendBufferedIo() override;



    std::string&& sent_io() { return std::move(sent_io_); }



  private:

    std::shared_ptr<TestBlockServerQueue> queue_;

    std::string misc_name_;

    std::string sent_io_;

    std::vector<std::pair<std::string, size_t>> buffered_;

};



class TestBlockServerOpener final : public IBlockServerOpener {

  public:

    TestBlockServerOpener(std::shared_ptr<TestBlockServerQueue> queue,

                          const std::string& misc_name);

    std::unique_ptr<IBlockServer> Open(IBlockServer::Delegate* delegate,

                                       size_t buffer_size) override;



  private:

    std::shared_ptr<TestBlockServerQueue> queue_;

    std::string misc_name_;

};



class TestBlockServerFactory final : public IBlockServerFactory {

  public:

    std::shared_ptr<IBlockServerOpener> CreateOpener(const std::string& misc_name) override;

    std::shared_ptr<TestBlockServerOpener> CreateTestOpener(const std::string& misc_name);

    bool DeleteQueue(const std::string& misc_name);



  private:

    std::unordered_map<std::string, std::shared_ptr<TestBlockServerQueue>> queues_;

};



class TestBlockServerFactory;



class HostUserDevice final : public IUserDevice {

  public:

    HostUserDevice(TestBlockServerFactory* factory, const std::string& misc_name);

    const std::string& GetPath() override { return empty_path_; }

    bool Destroy();



  private:

    TestBlockServerFactory* factory_;

    std::string misc_name_;

    std::string empty_path_;

};



class HostTestHarness final : public ITestHarness {

  public:

    std::unique_ptr<IUserDevice> CreateUserDevice(const std::string& dev_name,

                                                  const std::string& misc_name,

                                                  uint64_t num_sectors) override;

    IBlockServerFactory* GetBlockServerFactory() override;

    bool HasUserDevice() override { return false; }



  private:

    TestBlockServerFactory factory_;

};



}  // namespace snapshot

}  // namespace android

fs_mgr/libsnapshot/snapuserd/user-space-merge/read_worker.h

+3 −1
Original line number Diff line number Diff line
@@ -33,9 +33,11 @@ class ReadWorker : public Worker, public IBlockServer::Delegate { 
    bool Run();

    bool Init() override;

    void CloseFds() override;

    bool RequestSectors(uint64_t sector, uint64_t size) override;



    IBlockServer* block_server() const { return block_server_.get(); }



  private:

    bool RequestSectors(uint64_t sector, uint64_t size) override;

    bool SendBufferedIo();



    bool ProcessCowOp(const CowOperation* cow_op, void* buffer);