blob: 47169d0142fd2a6c9c021a2145e4979a8a2717a2 [file]
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <lib/dma-buffer/buffer.h>
#include <lib/dma-buffer/phys-iter.h>
#include <lib/fake-object/object.h>
#include <lib/zx/result.h>
#include <lib/zx/vmo.h>
#include <map>
#include <memory>
#include <mutex>
#include <gtest/gtest.h>
namespace {
const zx::bti kFakeBti(42);
struct VmoMetadata {
size_t size = 0;
uint32_t alignment_log2 = 0;
zx_handle_t bti_handle = ZX_HANDLE_INVALID;
uint32_t cache_policy = 0;
zx_paddr_t start_phys = 0;
void* virt = nullptr;
bool contiguous = false;
};
bool unpinned = false;
uint32_t last_cache_flush_options = 0;
size_t last_cache_flush_len = 0;
int cache_flush_call_count = 0;
class VmoWrapper : public fake_object::Object {
public:
explicit VmoWrapper(zx::vmo vmo) : fake_object::Object(ZX_OBJ_TYPE_VMO), vmo_(std::move(vmo)) {}
zx::unowned_vmo vmo() { return vmo_.borrow(); }
VmoMetadata& metadata() { return metadata_; }
private:
zx::vmo vmo_;
VmoMetadata metadata_ = {};
};
extern "C" {
zx_status_t zx_vmo_create_contiguous(zx_handle_t bti_handle, size_t size, uint32_t alignment_log2,
zx_handle_t* out) {
zx::vmo vmo = {};
zx_status_t status = _zx_vmo_create(size, 0, vmo.reset_and_get_address());
if (status != ZX_OK) {
return status;
}
auto vmo_wrapper = std::make_shared<VmoWrapper>(std::move(vmo));
vmo_wrapper->metadata().alignment_log2 = alignment_log2;
vmo_wrapper->metadata().bti_handle = bti_handle;
vmo_wrapper->metadata().size = size;
zx::result add_res = fake_object::FakeHandleTable().Add(std::move(vmo_wrapper));
if (add_res.is_ok()) {
*out = add_res.value();
}
return add_res.status_value();
}
zx_status_t zx_vmo_create(uint64_t size, uint32_t options, zx_handle_t* out) {
zx::vmo vmo = {};
zx_status_t status = _zx_vmo_create(size, options, vmo.reset_and_get_address());
if (status != ZX_OK) {
return status;
}
auto vmo_wrapper = std::make_shared<VmoWrapper>(std::move(vmo));
vmo_wrapper->metadata().size = size;
zx::result add_res = fake_object::FakeHandleTable().Add(std::move(vmo_wrapper));
if (add_res.is_ok()) {
*out = add_res.value();
}
return add_res.status_value();
}
zx_status_t zx_vmar_map(zx_handle_t vmar_handle, zx_vm_option_t options, uint64_t vmar_offset,
zx_handle_t vmo_handle, uint64_t vmo_offset, uint64_t len,
zx_vaddr_t* mapped_addr) {
zx::result get_res = fake_object::FakeHandleTable().Get(vmo_handle);
if (!get_res.is_ok()) {
return get_res.status_value();
}
std::shared_ptr<VmoWrapper> vmo = std::static_pointer_cast<VmoWrapper>(get_res.value());
zx_status_t status = _zx_vmar_map(vmar_handle, options, vmar_offset, vmo->vmo()->get(),
vmo_offset, len, mapped_addr);
if (status == ZX_OK) {
vmo->metadata().virt = reinterpret_cast<void*>(*mapped_addr);
}
return status;
}
zx_status_t zx_vmo_set_cache_policy(zx_handle_t handle, uint32_t cache_policy) {
zx::result get_res = fake_object::FakeHandleTable().Get(handle);
if (!get_res.is_ok()) {
return get_res.status_value();
}
std::shared_ptr<VmoWrapper> vmo = std::static_pointer_cast<VmoWrapper>(get_res.value());
vmo->metadata().cache_policy = cache_policy;
return ZX_OK;
}
zx_status_t zx_bti_pin(zx_handle_t bti_handle, uint32_t options, zx_handle_t vmo_handle,
uint64_t offset, uint64_t size, zx_paddr_t* addrs, size_t addrs_count,
zx_handle_t* out) {
static uint64_t current_phys = 0;
static std::mutex phys_lock;
if (bti_handle != kFakeBti.get()) {
return ZX_ERR_BAD_HANDLE;
}
if (options & ZX_BTI_CONTIGUOUS) {
if (addrs_count != 1) {
return ZX_ERR_INVALID_ARGS;
}
} else {
const auto num_pages =
fbl::round_up(size, zx_system_get_page_size()) / zx_system_get_page_size();
if (addrs_count != num_pages) {
return ZX_ERR_INVALID_ARGS;
}
}
zx::result get_res = fake_object::FakeHandleTable().Get(vmo_handle);
if (!get_res.is_ok()) {
return get_res.status_value();
}
std::shared_ptr<VmoWrapper> vmo = std::static_pointer_cast<VmoWrapper>(get_res.value());
std::lock_guard lock(phys_lock);
vmo->metadata().start_phys = current_phys;
*addrs = current_phys;
current_phys += vmo->metadata().size;
*out = ZX_HANDLE_INVALID;
return ZX_OK;
}
zx_status_t zx_pmt_unpin(zx_handle_t handle) {
if (handle == ZX_HANDLE_INVALID) {
unpinned = true;
}
return ZX_OK;
}
zx_status_t zx_cache_flush(const void* addr, size_t len, uint32_t options) {
last_cache_flush_options = options;
last_cache_flush_len = len;
cache_flush_call_count++;
return ZX_OK;
}
} // extern "C"
} // namespace
namespace dma_buffer {
TEST(DmaBufferTests, InitWithCacheEnabled) {
unpinned = false;
{
std::unique_ptr<ContiguousBuffer> buffer;
const size_t size = zx_system_get_page_size() * 4;
const size_t alignment = 2;
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, size, alignment, CacheOptions::kEnabled,
&buffer));
auto test_f = [&buffer, size](fake_object::Object* obj) -> bool {
auto vmo = static_cast<VmoWrapper*>(obj);
ZX_ASSERT(vmo->metadata().alignment_log2 == alignment);
ZX_ASSERT(vmo->metadata().bti_handle == kFakeBti.get());
ZX_ASSERT(vmo->metadata().cache_policy == 0);
ZX_ASSERT(vmo->metadata().size == size);
ZX_ASSERT(buffer->virt() == vmo->metadata().virt);
ZX_ASSERT(buffer->size() == vmo->metadata().size);
ZX_ASSERT(buffer->phys() == vmo->metadata().start_phys);
return false;
};
fake_object::FakeHandleTable().ForEach(ZX_OBJ_TYPE_VMO, test_f);
}
ASSERT_TRUE(unpinned);
}
TEST(DmaBufferTests, InitContiguousWithCacheDisabled) {
unpinned = false;
{
std::unique_ptr<ContiguousBuffer> buffer;
const size_t size = zx_system_get_page_size() * 4;
const size_t alignment = 2;
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, size, alignment, CacheOptions::kDisabled,
&buffer));
auto test_f = [&buffer, size](fake_object::Object* obj) -> bool {
auto vmo = static_cast<VmoWrapper*>(obj);
ZX_ASSERT(vmo->metadata().alignment_log2 == alignment);
ZX_ASSERT(vmo->metadata().bti_handle == kFakeBti.get());
ZX_ASSERT(vmo->metadata().cache_policy == ZX_CACHE_POLICY_UNCACHED_DEVICE);
ZX_ASSERT(vmo->metadata().size == size);
ZX_ASSERT(buffer->virt() == vmo->metadata().virt);
ZX_ASSERT(buffer->size() == vmo->metadata().size);
ZX_ASSERT(buffer->phys() == vmo->metadata().start_phys);
return false;
};
fake_object::FakeHandleTable().ForEach(ZX_OBJ_TYPE_VMO, test_f);
}
ASSERT_TRUE(unpinned);
}
TEST(DmaBufferTests, InitWithCacheDisabled) {
unpinned = false;
{
std::unique_ptr<PagedBuffer> buffer;
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreatePaged(kFakeBti, zx_system_get_page_size(),
CacheOptions::kDisabled, &buffer));
auto test_f = [&buffer](fake_object::Object* object) -> bool {
auto vmo = static_cast<VmoWrapper*>(object);
ZX_ASSERT(vmo->metadata().alignment_log2 == 0);
ZX_ASSERT(vmo->metadata().cache_policy == ZX_CACHE_POLICY_UNCACHED_DEVICE);
ZX_ASSERT(vmo->metadata().size == zx_system_get_page_size());
ZX_ASSERT(buffer->virt() == vmo->metadata().virt);
ZX_ASSERT(buffer->size() == vmo->metadata().size);
ZX_ASSERT(buffer->phys()[0] == vmo->metadata().start_phys);
return false;
};
fake_object::FakeHandleTable().ForEach(ZX_OBJ_TYPE_VMO, test_f);
}
ASSERT_TRUE(unpinned);
}
TEST(DmaBufferTests, InitCachedMultiPageBuffer) {
unpinned = false;
{
std::unique_ptr<ContiguousBuffer> buffer;
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, zx_system_get_page_size() * 4, 0,
CacheOptions::kEnabled, &buffer));
auto test_f = [&buffer](fake_object::Object* object) -> bool {
auto vmo = static_cast<VmoWrapper*>(object);
ZX_ASSERT(vmo->metadata().alignment_log2 == 0);
ZX_ASSERT(vmo->metadata().cache_policy == 0);
ZX_ASSERT(vmo->metadata().bti_handle == kFakeBti.get());
ZX_ASSERT(vmo->metadata().size == zx_system_get_page_size() * 4);
ZX_ASSERT(buffer->virt() == vmo->metadata().virt);
ZX_ASSERT(buffer->size() == vmo->metadata().size);
ZX_ASSERT(buffer->phys() == vmo->metadata().start_phys);
return false;
};
fake_object::FakeHandleTable().ForEach(ZX_OBJ_TYPE_VMO, test_f);
}
ASSERT_TRUE(unpinned);
}
TEST(DmaBufferTests, InitUncachedMultiPageBuffer) {
unpinned = false;
{
std::unique_ptr<ContiguousBuffer> buffer;
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, zx_system_get_page_size() * 4, 0,
CacheOptions::kDisabled, &buffer));
auto test_f = [&buffer](fake_object::Object* object) -> bool {
auto vmo = static_cast<VmoWrapper*>(object);
ZX_ASSERT(vmo->metadata().alignment_log2 == 0);
ZX_ASSERT(vmo->metadata().cache_policy == ZX_CACHE_POLICY_UNCACHED_DEVICE);
ZX_ASSERT(vmo->metadata().bti_handle == kFakeBti.get());
ZX_ASSERT(vmo->metadata().size == zx_system_get_page_size() * 4);
ZX_ASSERT(buffer->virt() == vmo->metadata().virt);
ZX_ASSERT(buffer->size() == vmo->metadata().size);
ZX_ASSERT(buffer->phys() == vmo->metadata().start_phys);
return false;
};
fake_object::FakeHandleTable().ForEach(ZX_OBJ_TYPE_VMO, test_f);
}
ASSERT_TRUE(unpinned);
}
using Param = struct {
// The description here will get rendered in the test name, along with a stringified variant of
// the testing input. In total, it can be used to identify each individual test case in the
// suite.
const char* test_desc;
// PhysIter ctor inputs.
zx_paddr_t* chunk_list;
uint64_t chunk_count;
size_t chunk_size;
zx_off_t vmo_offset;
size_t buf_length;
size_t max_length;
bool merge;
// Expected outputs.
uint loop_ct; // Number of times to increment iterator for full buffer.
zx_paddr_t* want_addr;
size_t* want_size;
};
const size_t kPageSize{4096}; // Page size, for maximum brevity.
const size_t kHalfPage{2048}; // Half a page.
// clang-format off
const auto kCases = testing::Values(
Param(/* test_desc */ "SimplePageBoundary",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize},
/* chunk_count */ 2,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 2,
/* want_addr */ (zx_paddr_t[]){kPageSize, 2 * kPageSize},
/* want_size */ (size_t[]){kPageSize, kPageSize}),
Param(/* test_desc */ "NonContiguousPages",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 3 * kPageSize,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* want_size */ (size_t[]){kPageSize, kPageSize, kPageSize}),
Param(/* test_desc */ "PartialFirstPageContiguous",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ kPageSize - 5,
/* buf_length */ 2 * kPageSize + 5,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){2 * kPageSize - 5, 2 * kPageSize, 3 * kPageSize},
/* want_size */ (size_t[]){5UL, kPageSize, kPageSize}),
Param(/* test_desc */ "PartialFirstPageNonContiguous",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ kPageSize - 5,
/* buf_length */ 2 * kPageSize + 5,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){2 * kPageSize - 5, 3 * kPageSize, 5 * kPageSize},
/* want_size */ (size_t[]){5UL, kPageSize, kPageSize}),
Param(/* test_desc */ "PartialLastPageContiguous",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize + 5,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize},
/* want_size */ (size_t[]){kPageSize, kPageSize, 5UL}),
Param(/* test_desc */ "PartialLastPageNonContiguous",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize + 5,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* want_size */ (size_t[]){kPageSize, kPageSize, 5UL}),
Param(/* test_desc */ "SubChunkMaxLength",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize},
/* chunk_count */ 2,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize,
/* max_length */ kHalfPage,
/* merge */ false,
/* loop_ct */ 4,
/* want_addr */ (zx_paddr_t[]){2 * kHalfPage, 3 * kHalfPage, 4 * kHalfPage, 5 * kHalfPage},
/* want_size */ (size_t[]){kHalfPage, kHalfPage, kHalfPage, kHalfPage}),
Param(/* test_desc */ "ZxBtiContiguousLargeBuffer",
/* chunk_list */ (zx_paddr_t[]){kPageSize},
/* chunk_count */ 1,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 1UL << 20, // 1MiB.
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 1,
/* want_addr */ (zx_paddr_t[]){kPageSize},
/* want_size */ (size_t[]){1UL << 20}),
Param(/* test_desc */ "ZxBtiCompressContiguous",
/* chunk_list */ (zx_paddr_t[]){kHalfPage, 2 * kHalfPage, 3 * kHalfPage},
/* chunk_count */ 3,
/* chunk_size */ kHalfPage,
/* vmo_offset */ 0,
/* buf_length */ 3 * kHalfPage,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kHalfPage, 2 * kHalfPage, 3 * kHalfPage},
/* want_size */ (size_t[]){kHalfPage, kHalfPage, kHalfPage}),
Param(/* test_desc */ "ZxBtiCompressNonContiguous",
/* chunk_list */ (zx_paddr_t[]){kHalfPage, 3 * kHalfPage, 5 * kHalfPage},
/* chunk_count */ 3,
/* chunk_size */ kHalfPage,
/* vmo_offset */ 0,
/* buf_length */ 3 * kHalfPage,
/* max_length */ UINT64_MAX,
/* merge */ false,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kHalfPage, 3 * kHalfPage, 5 * kHalfPage},
/* want_size */ (size_t[]){kHalfPage, kHalfPage, kHalfPage}),
Param(/* test_desc */ "ZxBtiContiguousSubChunkMaxLength",
/* chunk_list */ (zx_paddr_t[]){kPageSize},
/* chunk_count */ 1,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize,
/* max_length */ kHalfPage,
/* merge */ false,
/* loop_ct */ 4,
/* want_addr */ (zx_paddr_t[]){2 * kHalfPage, 3 * kHalfPage, 4 * kHalfPage, 5 * kHalfPage},
/* want_size */ (size_t[]){kHalfPage, kHalfPage, kHalfPage, kHalfPage}),
Param(/* test_desc */ "ZxBtiNonContiguousSubChunkMaxLength",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 3 * kPageSize},
/* chunk_count */ 2,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize,
/* max_length */ kHalfPage,
/* merge */ false,
/* loop_ct */ 4,
/* want_addr */ (zx_paddr_t[]){2 * kHalfPage, 3 * kHalfPage, 6 * kHalfPage, 7 * kHalfPage},
/* want_size */ (size_t[]){kHalfPage, kHalfPage, kHalfPage, kHalfPage}),
Param(/* test_desc */ "SimplePageBoundaryMerge",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize},
/* chunk_count */ 2,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize,
/* max_length */ UINT64_MAX,
/* merge */ true,
/* loop_ct */ 1,
/* want_addr */ (zx_paddr_t[]){kPageSize},
/* want_size */ (size_t[]){2 * kPageSize}),
Param(/* test_desc */ "NonContiguousPagesMerge",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 3 * kPageSize,
/* max_length */ UINT64_MAX,
/* merge */ true,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kPageSize, 3 * kPageSize, 5 * kPageSize},
/* want_size */ (size_t[]){kPageSize, kPageSize, kPageSize}),
Param(/* test_desc */ "MixedContiguousAndNonContiguousMerge",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 4 * kPageSize, 5 * kPageSize, 6 * kPageSize},
/* chunk_count */ 5,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 5 * kPageSize,
/* max_length */ UINT64_MAX,
/* merge */ true,
/* loop_ct */ 2,
/* want_addr */ (zx_paddr_t[]){kPageSize, 4 * kPageSize},
/* want_size */ (size_t[]){2 * kPageSize, 3 * kPageSize}),
Param(/* test_desc */ "PartialFirstPageContiguousMerge",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ kPageSize - 5,
/* buf_length */ 2 * kPageSize + 5,
/* max_length */ UINT64_MAX,
/* merge */ true,
/* loop_ct */ 1,
/* want_addr */ (zx_paddr_t[]){2 * kPageSize - 5},
/* want_size */ (size_t[]){2 * kPageSize + 5}),
Param(/* test_desc */ "PartialLastPageContiguousMerge",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize},
/* chunk_count */ 3,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 2 * kPageSize + 5,
/* max_length */ UINT64_MAX,
/* merge */ true,
/* loop_ct */ 1,
/* want_addr */ (zx_paddr_t[]){kPageSize},
/* want_size */ (size_t[]){2 * kPageSize + 5}),
Param(/* test_desc */ "MergeRespectsChunkAlignedMaxLength",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize, 4 * kPageSize},
/* chunk_count */ 4,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 4 * kPageSize,
/* max_length */ 2 * kPageSize,
/* merge */ true,
/* loop_ct */ 2,
/* want_addr */ (zx_paddr_t[]){kPageSize, 3 * kPageSize},
/* want_size */ (size_t[]){2 * kPageSize, 2 * kPageSize}),
Param(/* test_desc */ "MergeRespectsUnalignedMaxLength",
/* chunk_list */ (zx_paddr_t[]){kPageSize, 2 * kPageSize, 3 * kPageSize, 5 * kPageSize},
/* chunk_count */ 4,
/* chunk_size */ kPageSize,
/* vmo_offset */ 0,
/* buf_length */ 4 * kPageSize,
/* max_length */ kPageSize + kHalfPage,
/* merge */ true,
/* loop_ct */ 3,
/* want_addr */ (zx_paddr_t[]){kPageSize, 2 * kPageSize + kHalfPage, 5 * kPageSize},
/* want_size */ (size_t[]){kPageSize + kHalfPage, kPageSize + kHalfPage, kPageSize}),
Param(/* test_desc */ "ZxBtiCompressContiguousMerge",
/* chunk_list */ (zx_paddr_t[]){kHalfPage, 2 * kHalfPage, 3 * kHalfPage},
/* chunk_count */ 3,
/* chunk_size */ kHalfPage,
/* vmo_offset */ 0,
/* buf_length */ 3 * kHalfPage,
/* max_length */ UINT64_MAX,
/* merge */ true,
/* loop_ct */ 1,
/* want_addr */ (zx_paddr_t[]){kHalfPage},
/* want_size */ (size_t[]){3 * kHalfPage}),
Param(/* test_desc */ "PageAlignedLargeChunksNonContiguous",
/* chunk_list */ (zx_paddr_t[]){0x220000, 0x350000},
/* chunk_count */ 2,
/* chunk_size */ 0x100000,
/* vmo_offset */ 0xf8000,
/* buf_length */ 0x10000,
/* max_length */ 0x10000,
/* merge */ true,
/* loop_ct */ 2,
/* want_addr */ (zx_paddr_t[]){0x318000, 0x350000},
/* want_size */ (size_t[]){0x8000, 0x8000}),
Param(/* test_desc */ "PageAlignedLargeChunksContiguousMerge",
/* chunk_list */ (zx_paddr_t[]){0x220000, 0x320000},
/* chunk_count */ 2,
/* chunk_size */ 0x100000,
/* vmo_offset */ 0xf8000,
/* buf_length */ 0x10000,
/* max_length */ 0x10000,
/* merge */ true,
/* loop_ct */ 1,
/* want_addr */ (zx_paddr_t[]){0x318000},
/* want_size */ (size_t[]){0x10000}),
Param(/* test_desc */ "PageAlignedLargeChunksMultiStepAcrossBoundary",
/* chunk_list */ (zx_paddr_t[]){0x220000, 0x350000},
/* chunk_count */ 2,
/* chunk_size */ 0x100000,
/* vmo_offset */ 0xd8000,
/* buf_length */ 0x30000,
/* max_length */ 0x10000,
/* merge */ true,
/* loop_ct */ 4,
/* want_addr */ (zx_paddr_t[]){0x2f8000, 0x308000, 0x318000, 0x350000},
/* want_size */ (size_t[]){0x10000, 0x10000, 0x8000, 0x8000}));
// clang-format on
class Parameterized : public testing::TestWithParam<Param> {};
TEST_P(Parameterized, TestRun) {
auto p = GetParam();
PhysIter phys_iter{p.chunk_list, p.chunk_count, p.chunk_size, p.vmo_offset,
p.buf_length, p.max_length, p.merge};
auto itr = phys_iter.begin();
uint i;
for (i = 0; i < p.loop_ct; i++) {
EXPECT_NE(itr, phys_iter.end()) << "i=" << i << std::endl;
auto [addr, size] = *(itr++);
EXPECT_EQ(p.want_addr[i], addr) << "i=" << i << std::endl;
EXPECT_EQ(p.want_size[i], size) << "i=" << i << std::endl;
}
EXPECT_EQ(itr, phys_iter.end()) << "i=" << i << std::endl;
}
INSTANTIATE_TEST_SUITE_P(PhysIterTest, Parameterized, kCases,
[](const testing::TestParamInfo<Parameterized::ParamType>& info) {
std::stringstream test_name;
test_name << info.index << "_" << info.param.test_desc;
return test_name.str();
});
TEST(DmaBufferTests, ReadWriteAndCacheOperations) {
std::unique_ptr<ContiguousBuffer> buffer;
const size_t size = zx_system_get_page_size();
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, size, 0, CacheOptions::kEnabled, &buffer));
// Reset cache flush counter.
cache_flush_call_count = 0;
// Test Write and Read raw memory.
const uint8_t write_data[] = {0xDE, 0xAD, 0xBE, 0xEF};
uint8_t read_data[4] = {0};
EXPECT_TRUE(buffer->Write(write_data, 16, sizeof(write_data)).is_ok());
EXPECT_EQ(1, cache_flush_call_count);
EXPECT_EQ(ZX_CACHE_FLUSH_DATA, last_cache_flush_options);
cache_flush_call_count = 0;
EXPECT_TRUE(buffer->Read(16, sizeof(read_data), read_data).is_ok());
EXPECT_EQ(1, cache_flush_call_count);
EXPECT_EQ(static_cast<uint32_t>(ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE),
last_cache_flush_options);
EXPECT_EQ(0, std::memcmp(write_data, read_data, sizeof(write_data)));
// Test WriteStruct and ReadStruct.
struct TestPacket {
uint32_t magic;
uint16_t length;
uint8_t flags;
};
TestPacket out_pkt{.magic = 0x12345678, .length = 64, .flags = 0xFF};
EXPECT_TRUE(buffer->WriteStruct(out_pkt, 64).is_ok());
zx::result<TestPacket> in_pkt_res = buffer->ReadStruct<TestPacket>(64);
ASSERT_TRUE(in_pkt_res.is_ok());
EXPECT_EQ(out_pkt.magic, in_pkt_res->magic);
EXPECT_EQ(out_pkt.length, in_pkt_res->length);
EXPECT_EQ(out_pkt.flags, in_pkt_res->flags);
// Test Out-Of-Bounds handling.
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
buffer->Write(write_data, size - 2, sizeof(write_data)).error_value());
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
buffer->Read(size - 2, sizeof(read_data), read_data).error_value());
EXPECT_EQ(ZX_ERR_INVALID_ARGS, buffer->Write(nullptr, 0, 4).error_value());
// Test Cache operations directly.
EXPECT_TRUE(buffer->enable_cache());
cache_flush_call_count = 0;
EXPECT_TRUE(buffer->CacheFlush(0, 0).is_ok());
EXPECT_EQ(0, cache_flush_call_count);
EXPECT_TRUE(buffer->CacheFlush(0, 32).is_ok());
EXPECT_EQ(1, cache_flush_call_count);
EXPECT_EQ(ZX_CACHE_FLUSH_DATA, last_cache_flush_options);
cache_flush_call_count = 0;
EXPECT_TRUE(buffer->CacheFlushInvalidate(0, 0).is_ok());
EXPECT_EQ(0, cache_flush_call_count);
EXPECT_TRUE(buffer->CacheFlushInvalidate(0, 32).is_ok());
EXPECT_EQ(1, cache_flush_call_count);
EXPECT_EQ(static_cast<uint32_t>(ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE),
last_cache_flush_options);
// Test that cache flush operations are NOT called when enable_cache is false.
std::unique_ptr<ContiguousBuffer> uncached_buffer;
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, size, 0, CacheOptions::kDisabled,
&uncached_buffer));
EXPECT_FALSE(uncached_buffer->enable_cache());
cache_flush_call_count = 0;
EXPECT_TRUE(uncached_buffer->Write(write_data, 16, sizeof(write_data)).is_ok());
EXPECT_TRUE(uncached_buffer->Read(16, sizeof(read_data), read_data).is_ok());
EXPECT_TRUE(uncached_buffer->CacheFlush(0, 32).is_ok());
EXPECT_TRUE(uncached_buffer->CacheFlushInvalidate(0, 32).is_ok());
EXPECT_EQ(0, cache_flush_call_count);
}
TEST(DmaBufferTests, UncachedMemoryHelperAllCases) {
std::unique_ptr<ContiguousBuffer> buffer;
const size_t size = zx_system_get_page_size();
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, size, 0, CacheOptions::kDisabled, &buffer));
EXPECT_FALSE(buffer->enable_cache());
// 1. Zero length transfer.
uint8_t test_byte = 0x55;
EXPECT_TRUE(buffer->Write(&test_byte, 0, 0).is_ok());
EXPECT_TRUE(buffer->Read(0, 0, &test_byte).is_ok());
EXPECT_EQ(0x55, test_byte);
// 2. Setup pattern integrity verification.
std::vector<uint8_t> bg_pattern(size, 0xAA);
EXPECT_TRUE(buffer->Write(bg_pattern.data(), 0, size).is_ok());
auto verify_slice = [&](size_t offset, size_t length, uint8_t val) {
std::vector<uint8_t> read_back(size, 0);
EXPECT_TRUE(buffer->Read(0, size, read_back.data()).is_ok());
for (size_t i = 0; i < size; i++) {
if (i >= offset && i < offset + length) {
EXPECT_EQ(val, read_back[i]) << "Mismatch at modified index " << i;
} else {
EXPECT_EQ(0xAA, read_back[i]) << "Corruption at background index " << i;
}
}
};
// 3. Small unaligned transfer (< WordType size, e.g., 3 bytes at offset 1).
std::vector<uint8_t> small_data(3, 0x11);
EXPECT_TRUE(buffer->Write(small_data.data(), 1, 3).is_ok());
verify_slice(1, 3, 0x11);
// Restore background
EXPECT_TRUE(buffer->Write(bg_pattern.data(), 0, size).is_ok());
// 4. Unaligned head alignment (offset 3, length 24 - crossing word boundaries).
std::vector<uint8_t> head_data(24, 0x22);
EXPECT_TRUE(buffer->Write(head_data.data(), 3, 24).is_ok());
verify_slice(3, 24, 0x22);
EXPECT_TRUE(buffer->Write(bg_pattern.data(), 0, size).is_ok());
// 5. Unaligned tail alignment (offset 8, length 13 - starting aligned, ending unaligned).
std::vector<uint8_t> tail_data(13, 0x33);
EXPECT_TRUE(buffer->Write(tail_data.data(), 8, 13).is_ok());
verify_slice(8, 13, 0x33);
EXPECT_TRUE(buffer->Write(bg_pattern.data(), 0, size).is_ok());
// 6. Both unaligned head and unaligned tail (offset 5, length 19).
std::vector<uint8_t> mid_data(19, 0x44);
EXPECT_TRUE(buffer->Write(mid_data.data(), 5, 19).is_ok());
verify_slice(5, 19, 0x44);
EXPECT_TRUE(buffer->Write(bg_pattern.data(), 0, size).is_ok());
// 7. Exact word boundary transfer (offset 16, length 32).
std::vector<uint8_t> exact_data(32, 0x66);
EXPECT_TRUE(buffer->Write(exact_data.data(), 16, 32).is_ok());
verify_slice(16, 32, 0x66);
EXPECT_TRUE(buffer->Write(bg_pattern.data(), 0, size).is_ok());
// 8. Large transfer spanning multiple words across the entire buffer.
std::vector<uint8_t> large_data(size);
for (size_t i = 0; i < size; i++) {
large_data[i] = static_cast<uint8_t>((i * 7) & 0xFF);
}
EXPECT_TRUE(buffer->Write(large_data.data(), 0, size).is_ok());
std::vector<uint8_t> large_read(size, 0);
EXPECT_TRUE(buffer->Read(0, size, large_read.data()).is_ok());
EXPECT_EQ(0, std::memcmp(large_data.data(), large_read.data(), size));
}
TEST(DmaBufferTests, ExecuteOpsLambdaTests) {
std::unique_ptr<ContiguousBuffer> buffer;
const size_t size = zx_system_get_page_size();
auto factory = CreateBufferFactory();
ASSERT_EQ(ZX_OK, factory->CreateContiguous(kFakeBti, size, 0, CacheOptions::kEnabled, &buffer));
struct TestStruct {
uint32_t a;
uint32_t b;
};
// Test ExecuteWriteOps & ExecuteReadOps
cache_flush_call_count = 0;
zx::result<> status =
buffer->ExecuteWriteOps(16, 64, [](void* ptr) { std::memset(ptr, 0xAB, 64); });
EXPECT_TRUE(status.is_ok());
EXPECT_EQ(1, cache_flush_call_count);
EXPECT_EQ(static_cast<uint32_t>(ZX_CACHE_FLUSH_DATA), last_cache_flush_options);
cache_flush_call_count = 0;
bool read_verified = false;
status = buffer->ExecuteReadOps(16, 64, [&read_verified](const void* ptr) {
const uint8_t* bytes = static_cast<const uint8_t*>(ptr);
read_verified = (bytes[0] == 0xAB && bytes[63] == 0xAB);
});
EXPECT_TRUE(status.is_ok());
EXPECT_TRUE(read_verified);
EXPECT_EQ(1, cache_flush_call_count);
EXPECT_EQ(static_cast<uint32_t>(ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE),
last_cache_flush_options);
// Error case: Out of bounds
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
buffer->ExecuteWriteOps(size - 10, 20, [](void*) {}).status_value());
EXPECT_EQ(ZX_ERR_OUT_OF_RANGE,
buffer->ExecuteReadOps(size - 10, 20, [](const void*) {}).status_value());
}
} // namespace dma_buffer