blob: 02c2e7ce9491c283028fd9e67e6284c69ee58583 [file]
// Copyright 2020 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.
namespace {
int g_hw_mb_count = 0;
} // namespace
// Replaces the hardware barrier so the UnsynchronizedOps test can count barriers; must stay above
// all includes.
#define mmio_hw_mb() (++g_hw_mb_count)
#include <lib/driver/mmio/cpp/mmio-buffer.h>
#include <lib/driver/mmio/cpp/mmio.h>
#include <lib/driver/mmio/testing/cpp/test-helper.h>
#include <lib/fake-bti/bti.h>
#include <lib/zx/vmo.h>
#include <zircon/assert.h>
#include <zircon/errors.h>
#include <zircon/syscalls.h>
#include <zircon/types.h>
#include <limits>
#include <optional>
#include <gtest/gtest.h>
#include <src/lib/testing/predicates/status.h>
namespace {
zx::vmo CreateVmoWithPolicy(size_t size, std::optional<uint32_t> cache_policy) {
zx::vmo vmo = {};
zx_status_t status = zx::vmo::create(size, /*options=*/0, &vmo);
ZX_ASSERT_MSG((status == ZX_OK), "creating vmo failed: %s", zx_status_get_string(status));
if (cache_policy.has_value()) {
status = vmo.set_cache_policy(*cache_policy);
ZX_ASSERT_MSG((status == ZX_OK), "setting vmo cache policy failed: %s",
zx_status_get_string(status));
}
return vmo;
}
zx::vmo CreateVmo(size_t size) { return CreateVmoWithPolicy(size, std::nullopt); }
zx::vmo DuplicateVmo(const zx::vmo& vmo) {
zx::vmo out_vmo = {};
zx_status_t status = vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &out_vmo);
ZX_ASSERT_MSG((status == ZX_OK), "duplicating vmo failed: %s", zx_status_get_string(status));
return out_vmo;
}
size_t VmoNumMappings(const zx::vmo& vmo) {
zx_info_vmo_t info;
zx_status_t status = vmo.get_info(ZX_INFO_VMO, &info, sizeof(info), nullptr, nullptr);
ZX_ASSERT_MSG((status == ZX_OK), "getting vmo info failed: %s", zx_status_get_string(status));
return info.num_mappings;
}
size_t PinnedVmoCount(const zx::bti& bti) {
size_t count = 0;
zx_status_t status = fake_bti_get_pinned_vmos(bti.get(), nullptr, 0, &count);
ZX_ASSERT_MSG((status == ZX_OK), "getting pinned vmos count failed: %s",
zx_status_get_string(status));
return count;
}
TEST(MmioBuffer, CreateInit) {
const size_t vmo_sz = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(vmo_sz);
auto create_status = [&](zx_off_t offset, size_t size, zx::vmo v, uint32_t policy) {
return fdf::MmioBuffer::Create(offset, size, std::move(v), policy).status_value();
};
// |offset| is invalid.
ASSERT_EQ(ZX_ERR_OUT_OF_RANGE, create_status(std::numeric_limits<zx_off_t>::max(), vmo_sz,
DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED));
ASSERT_EQ(ZX_ERR_OUT_OF_RANGE,
create_status(vmo_sz + 1, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED));
// |size| is invalid
ASSERT_EQ(ZX_ERR_INVALID_ARGS, create_status(0, 0, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED));
ASSERT_EQ(ZX_ERR_INVALID_ARGS,
create_status(vmo_sz / 2, 0, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED));
ASSERT_EQ(ZX_ERR_OUT_OF_RANGE,
create_status(0, vmo_sz + 1, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED));
// |size| + |offset| are collectively invalid.
ASSERT_EQ(ZX_ERR_OUT_OF_RANGE, create_status((vmo_sz / 2) + 1, vmo_sz / 2, DuplicateVmo(vmo),
ZX_CACHE_POLICY_UNCACHED));
// |vmo| is invalid
ASSERT_EQ(ZX_ERR_BAD_HANDLE, create_status(0, vmo_sz, zx::vmo(), ZX_CACHE_POLICY_UNCACHED));
// |cache_policy| is invalid.
ASSERT_EQ(ZX_ERR_INVALID_ARGS,
create_status(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_MASK + 1));
ASSERT_OK(create_status(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED));
}
TEST(MmioBuffer, UnalignedOffsetInitRelease) {
const size_t vmo_sz = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(vmo_sz);
// Unaligned offset.
zx::result<fdf::MmioBuffer> mb =
fdf::MmioBuffer::Create(vmo_sz / 2, vmo_sz / 2, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED);
ASSERT_OK(mb.status_value());
// Ensure the map was successful.
ASSERT_EQ(1u, VmoNumMappings(vmo));
mb->reset();
EXPECT_FALSE(mb->get_vmo()->is_valid());
// Ensure the unmap was successful.
ASSERT_EQ(0u, VmoNumMappings(vmo));
}
TEST(MmioBuffer, UnalignedSizeInitRelease) {
const size_t vmo_sz = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(vmo_sz);
// Unaligned size.
zx::result<fdf::MmioBuffer> mb =
fdf::MmioBuffer::Create(0, vmo_sz / 2, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED);
ASSERT_OK(mb.status_value());
// Ensure the map was successful.
ASSERT_EQ(1u, VmoNumMappings(vmo));
mb->reset();
EXPECT_FALSE(mb->get_vmo()->is_valid());
// Ensure the unmap was successful.
ASSERT_EQ(0u, VmoNumMappings(vmo));
}
TEST(MmioBuffer, CppLifecycle) {
const size_t vmo_sz = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(vmo_sz);
MMIO_PTR volatile uint8_t* ptr = nullptr;
{
zx::result<fdf::MmioBuffer> mmio =
fdf::MmioBuffer::Create(0, vmo_sz, std::move(vmo), ZX_CACHE_POLICY_UNCACHED_DEVICE);
ASSERT_OK(mmio.status_value());
ptr = reinterpret_cast<MMIO_PTR volatile uint8_t*>(mmio->get());
// This write should succeed.
MmioWrite8(0xA5, ptr);
}
// This should fault because the dtor of MmioBuffer unmapped the range.
ASSERT_DEATH(MmioWrite8(0xA5, ptr), "");
}
TEST(MmioBuffer, MoveAssignment) {
const size_t vmo_sz = zx_system_get_page_size();
MMIO_PTR volatile uint8_t* ptr1 = nullptr;
MMIO_PTR volatile uint8_t* ptr2 = nullptr;
{
zx::vmo vmo1 = CreateVmo(vmo_sz);
zx::vmo vmo2 = CreateVmo(vmo_sz);
auto mmio1 =
fdf::MmioBuffer::Create(0, vmo_sz, std::move(vmo1), ZX_CACHE_POLICY_UNCACHED_DEVICE);
auto mmio2 =
fdf::MmioBuffer::Create(0, vmo_sz, std::move(vmo2), ZX_CACHE_POLICY_UNCACHED_DEVICE);
ASSERT_OK(mmio1.status_value());
ASSERT_OK(mmio2.status_value());
ptr1 = reinterpret_cast<MMIO_PTR volatile uint8_t*>(mmio1->get());
ptr2 = reinterpret_cast<MMIO_PTR volatile uint8_t*>(mmio2->get());
// Move assign mmio2 into mmio1. mmio1's previous mapping should be unmapped.
*mmio1 = std::move(*mmio2);
// ptr2 should still be valid.
MmioWrite8(0x5A, ptr2);
EXPECT_EQ(0x5A, MmioRead8(ptr2));
}
// Both ptr1 and ptr2 should fault now after destruction.
ASSERT_DEATH(MmioWrite8(0xA5, ptr1), "");
ASSERT_DEATH(MmioWrite8(0xA5, ptr2), "");
}
TEST(MmioBuffer, AlreadyMapped) {
const size_t vmo_sz = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(vmo_sz);
zx::result<fdf::MmioBuffer> mb1 =
fdf::MmioBuffer::Create(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED);
ASSERT_OK(mb1.status_value());
// A second mapping with a different cache policy should fail.
ASSERT_EQ(
ZX_ERR_BAD_STATE,
fdf::MmioBuffer::Create(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_CACHED).status_value());
// The same cache policy should be fine in a second MmioBuffer.
ASSERT_EQ(ZX_OK, fdf::MmioBuffer::Create(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED)
.status_value());
}
TEST(MmioBuffer, AlreadySetVmoCachePolicy) {
const size_t vmo_sz = zx_system_get_page_size();
uint32_t policy = ZX_CACHE_POLICY_UNCACHED_DEVICE;
zx::vmo vmo = CreateVmoWithPolicy(vmo_sz, policy);
// Since the VMO isn't mapped yet the MmioBuffer policy can differ.
zx::result<fdf::MmioBuffer> mb1 =
fdf::MmioBuffer::Create(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED);
ASSERT_OK(mb1.status_value());
// Trying to map with another policy will fail.
ASSERT_EQ(ZX_ERR_BAD_STATE,
fdf::MmioBuffer::Create(0, vmo_sz, DuplicateVmo(vmo), policy).status_value());
// A second MmioBuffer with the existing policy will succeed.
ASSERT_OK(fdf::MmioBuffer::Create(0, vmo_sz, DuplicateVmo(vmo), ZX_CACHE_POLICY_UNCACHED)
.status_value());
}
TEST(MmioBuffer, TestMmioBuffer) {
ASSERT_DEATH(fdf_testing::CreateMmioBuffer(0), "");
ASSERT_DEATH(fdf_testing::CreateMmioBuffer(std::numeric_limits<size_t>::max()), "");
size_t size = zx_system_get_page_size();
auto buffer = fdf_testing::CreateMmioBuffer(size);
ASSERT_EQ(size, buffer.get_size());
auto view = buffer.View(0);
uint32_t test_val = 0xABCD;
zx_off_t offset = 0x60;
buffer.Write32(test_val, offset);
EXPECT_EQ(view.Read32(offset), test_val);
}
TEST(MmioBuffer, TestMmioBufferWithVmo) {
zx::vmo vmo;
size_t size = zx_system_get_page_size();
ASSERT_OK(zx::vmo::create(size, 0, &vmo));
ASSERT_DEATH(fdf_testing::CreateMmioBuffer(zx::vmo(ZX_HANDLE_INVALID)), "");
auto buffer = fdf_testing::CreateMmioBuffer(std::move(vmo));
ASSERT_EQ(size, buffer.get_size());
auto view = buffer.View(0);
uint32_t test_val = 0xABCD;
zx_off_t offset = 0x60;
buffer.Write32(test_val, offset);
EXPECT_EQ(view.Read32(offset), test_val);
}
TEST(MmioPinnedBuffer, MoveAssignment) {
zx::bti bti;
ASSERT_OK(fake_bti_create(bti.reset_and_get_address()));
const size_t page_size = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(page_size);
zx::result<fdf::MmioBuffer> buffer =
fdf::MmioBuffer::Create(0, page_size, std::move(vmo), ZX_CACHE_POLICY_UNCACHED_DEVICE);
ASSERT_OK(buffer.status_value());
zx::result<fdf::MmioPinnedBuffer> pinned1 = buffer->Pin(bti);
ASSERT_OK(pinned1.status_value());
EXPECT_EQ(1u, PinnedVmoCount(bti));
EXPECT_EQ(pinned1->get_paddr(), FAKE_BTI_PHYS_ADDR);
// Self-move-assignment for MmioPinnedBuffer: state remains valid.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wself-move"
*pinned1 = std::move(*pinned1);
#pragma clang diagnostic pop
EXPECT_EQ(pinned1->get_paddr(), FAKE_BTI_PHYS_ADDR);
EXPECT_EQ(1u, PinnedVmoCount(bti));
zx::result<fdf::MmioPinnedBuffer> pinned2 = buffer->Pin(bti);
ASSERT_OK(pinned2.status_value());
EXPECT_EQ(2u, PinnedVmoCount(bti));
// Move-assigning one pinned buffer over another unpins the destination.
*pinned1 = std::move(*pinned2);
EXPECT_EQ(1u, PinnedVmoCount(bti));
pinned1->reset();
EXPECT_EQ(0u, PinnedVmoCount(bti));
}
TEST(MmioBuffer, Pin) {
zx::bti bti;
ASSERT_OK(fake_bti_create(bti.reset_and_get_address()));
const size_t page_size = zx_system_get_page_size();
const size_t half_page = page_size / 2;
zx::vmo vmo = CreateVmo(page_size * 2);
zx::result<fdf::MmioBuffer> buffer = fdf::MmioBuffer::Create(half_page, page_size, std::move(vmo),
ZX_CACHE_POLICY_UNCACHED_DEVICE);
ASSERT_OK(buffer.status_value());
// Buffer at half-page offset -> paddr == FAKE_BTI_PHYS_ADDR + page / 2.
// Test zx::result<MmioPinnedBuffer> overload.
zx::result<fdf::MmioPinnedBuffer> pinned_res = buffer->Pin(bti);
ASSERT_OK(pinned_res.status_value());
EXPECT_EQ(pinned_res->get_paddr(), FAKE_BTI_PHYS_ADDR + half_page);
EXPECT_EQ(1u, PinnedVmoCount(bti));
// Assert the pinned VMO offset and size for the unaligned case.
fake_bti_pinned_vmo_info_t pinned_info = {};
size_t count = 0;
ASSERT_OK(fake_bti_get_pinned_vmos(bti.get(), &pinned_info, 1, &count));
zx::vmo pinned_vmo(pinned_info.vmo);
EXPECT_EQ(1u, count);
EXPECT_EQ(0u, pinned_info.offset);
EXPECT_EQ(page_size * 2, pinned_info.size);
// Test reset() unpins.
pinned_res->reset();
EXPECT_EQ(0u, PinnedVmoCount(bti));
// Test std::optional<MmioPinnedBuffer>* overload.
std::optional<fdf::MmioPinnedBuffer> opt_pinned;
ASSERT_OK(buffer->Pin(bti, &opt_pinned));
ASSERT_TRUE(opt_pinned.has_value());
EXPECT_EQ(opt_pinned->get_paddr(), FAKE_BTI_PHYS_ADDR + half_page);
EXPECT_EQ(1u, PinnedVmoCount(bti));
// Pin on a View(offset).
const size_t view_offset = page_size / 4;
fdf::MmioView view = buffer->View(view_offset);
zx::result<fdf::MmioPinnedBuffer> view_pinned = view.Pin(bti);
ASSERT_OK(view_pinned.status_value());
EXPECT_EQ(view_pinned->get_paddr(), FAKE_BTI_PHYS_ADDR + half_page + view_offset);
std::optional<fdf::MmioPinnedBuffer> opt_view_pinned;
ASSERT_OK(view.Pin(bti, &opt_view_pinned));
ASSERT_TRUE(opt_view_pinned.has_value());
EXPECT_EQ(opt_view_pinned->get_paddr(), FAKE_BTI_PHYS_ADDR + half_page + view_offset);
EXPECT_EQ(3u, PinnedVmoCount(bti));
// The view pin is page-rounded to offset 0 and size 2 pages.
fake_bti_pinned_vmo_info_t view_pinned_infos[3] = {};
ASSERT_OK(fake_bti_get_pinned_vmos(bti.get(), view_pinned_infos, 3, &count));
zx::vmo view_pinned_vmos[3] = {
zx::vmo(view_pinned_infos[0].vmo),
zx::vmo(view_pinned_infos[1].vmo),
zx::vmo(view_pinned_infos[2].vmo),
};
EXPECT_EQ(3u, count);
EXPECT_EQ(0u, view_pinned_infos[1].offset);
EXPECT_EQ(page_size * 2, view_pinned_infos[1].size);
EXPECT_EQ(0u, view_pinned_infos[2].offset);
EXPECT_EQ(page_size * 2, view_pinned_infos[2].size);
// Destruction unpins all.
opt_pinned.reset();
opt_view_pinned.reset();
view_pinned->reset();
EXPECT_EQ(0u, PinnedVmoCount(bti));
}
TEST(MmioView, LifecycleLeavesParentMappingIntact) {
const size_t size = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(size);
zx::vmo vmo_dup = DuplicateVmo(vmo);
zx::result<fdf::MmioBuffer> buffer =
fdf::MmioBuffer::Create(0, size, std::move(vmo), ZX_CACHE_POLICY_UNCACHED_DEVICE);
ASSERT_OK(buffer.status_value());
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
// Destroying a view leaves the parent mapping intact.
{
auto view = buffer->View(0);
view.Write32(0x12345678, 0);
}
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
EXPECT_EQ(0x12345678u, buffer->Read32(0));
buffer->Write32(0x87654321, 0);
EXPECT_EQ(0x87654321u, buffer->Read32(0));
// Resetting a view leaves the parent mapping intact.
{
auto view = buffer->View(0);
view.reset();
EXPECT_FALSE(view.get_vmo()->is_valid());
}
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
buffer->Write32(0xAABBCCDD, 0);
EXPECT_EQ(0xAABBCCDDu, buffer->Read32(0));
}
TEST(MmioBuffer, DirectReset) {
const size_t vmo_sz = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(vmo_sz);
zx::vmo vmo_dup = DuplicateVmo(vmo);
zx::result<fdf::MmioBuffer> buffer =
fdf::MmioBuffer::Create(0, vmo_sz, std::move(vmo), ZX_CACHE_POLICY_UNCACHED_DEVICE);
ASSERT_OK(buffer.status_value());
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
buffer->reset();
EXPECT_EQ(buffer->get(), nullptr);
EXPECT_EQ(0u, buffer->get_size());
EXPECT_FALSE(buffer->get_vmo()->is_valid());
EXPECT_EQ(0u, VmoNumMappings(vmo_dup));
// Calling reset() again is a no-op.
buffer->reset();
EXPECT_EQ(buffer->get(), nullptr);
EXPECT_EQ(0u, buffer->get_size());
EXPECT_FALSE(buffer->get_vmo()->is_valid());
EXPECT_EQ(0u, VmoNumMappings(vmo_dup));
}
TEST(MmioBuffer, AdoptingConstructorUnmapsOnDestruction) {
const size_t size = zx_system_get_page_size();
zx::vmo vmo = CreateVmo(size);
zx::vmo vmo_dup = DuplicateVmo(vmo);
uintptr_t vaddr = 0;
ASSERT_OK(
zx::vmar::root_self()->map(ZX_VM_PERM_READ | ZX_VM_PERM_WRITE, 0, vmo, 0, size, &vaddr));
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
{
fdf::MmioBuffer buffer(std::move(vmo), reinterpret_cast<MMIO_PTR void*>(vaddr), 0, size);
EXPECT_EQ(vaddr, reinterpret_cast<uintptr_t>(buffer.get()));
EXPECT_EQ(size, buffer.get_size());
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
buffer.Write32(0xA5A5A5A5, 0);
EXPECT_EQ(0xA5A5A5A5u, buffer.Read32(0));
}
// The buffer owns the mapping it adopted.
EXPECT_EQ(0u, VmoNumMappings(vmo_dup));
}
TEST(MmioView, ViewBounds) {
size_t size = zx_system_get_page_size();
auto buffer = fdf_testing::CreateMmioBuffer(size);
// Overflowing view size assertions.
ASSERT_DEATH(buffer.View(16, buffer.get_size() - 16 + 1), "");
// Boundary View(get_size()) behavior: single-arg View asserts offset < get_size().
ASSERT_DEATH(buffer.View(buffer.get_size()), "");
// Two-arg View(get_size(), 0) is valid: offset <= get_size() and size <= get_size() - offset.
auto empty_view = buffer.View(buffer.get_size(), 0);
EXPECT_EQ(0u, empty_view.get_size());
}
TEST(MmioBuffer, SetMmioBufferOps) {
size_t size = zx_system_get_page_size();
auto buffer = fdf_testing::CreateMmioBuffer(size);
EXPECT_EQ(fdf::MmioBuffer::GetDefaultOps(), &fdf::internal::kDefaultOps);
MMIO_PTR void* expected_vaddr = buffer.get();
size_t expected_size = buffer.get_size();
bool read_called = false;
static constexpr fdf::MmioBufferOps kCustomOps = {
.Read8 = [](const void* ctx, const fdf::MmioBuffer& mmio, zx_off_t offs) -> uint8_t {
*static_cast<bool*>(const_cast<void*>(ctx)) = true;
return 0x42;
},
.Read16 = nullptr,
.Read32 = nullptr,
.Read64 = nullptr,
.ReadBuffer = nullptr,
.Write8 = nullptr,
.Write16 = nullptr,
.Write32 = nullptr,
.Write64 = nullptr,
.WriteBuffer = nullptr,
};
buffer = fdf::SetMmioBufferOps(std::move(buffer), &kCustomOps, &read_called);
EXPECT_EQ(expected_vaddr, buffer.get());
EXPECT_EQ(expected_size, buffer.get_size());
EXPECT_EQ(0x42, buffer.Read8(0));
EXPECT_TRUE(read_called);
read_called = false;
fdf::MmioView direct_view(buffer, 0);
EXPECT_EQ(0x42, direct_view.Read8(0));
EXPECT_TRUE(read_called);
// Test resetting back to default ops.
buffer = fdf::SetMmioBufferOps(std::move(buffer));
buffer.Write8(0x77, 0);
EXPECT_EQ(0x77, buffer.Read8(0));
{
zx::vmo vmo = CreateVmo(size);
zx::vmo vmo_dup = DuplicateVmo(vmo);
auto src = fdf_testing::CreateMmioBuffer(std::move(vmo));
MMIO_PTR void* orig_vaddr = src.get();
auto swapped = fdf::SetMmioBufferOps(std::move(src), fdf::MmioBuffer::GetDefaultOps());
EXPECT_EQ(src.get(), nullptr);
EXPECT_EQ(orig_vaddr, swapped.get());
EXPECT_EQ(1u, VmoNumMappings(vmo_dup));
}
// A null ops pointer also selects the default ops.
buffer = fdf::SetMmioBufferOps(std::move(buffer), &kCustomOps, &read_called);
buffer = fdf::SetMmioBufferOps(std::move(buffer), nullptr);
read_called = false;
buffer.Write8(0x66, 0);
EXPECT_EQ(0x66, buffer.Read8(0));
EXPECT_FALSE(read_called);
}
TEST(MmioBuffer, UnsynchronizedOps) {
size_t size = zx_system_get_page_size();
EXPECT_EQ(fdf::MmioBuffer::GetUnsynchronizedOps(), &fdf::internal::kUnsynchronizedOps);
auto default_buffer = fdf_testing::CreateMmioBuffer(size);
auto unsync_buffer = fdf::SetMmioBufferOps(fdf_testing::CreateMmioBuffer(size),
fdf::MmioBuffer::GetUnsynchronizedOps());
g_hw_mb_count = 0;
default_buffer.Write32(0x12345678, 0);
EXPECT_EQ(0x12345678u, default_buffer.Read32(0));
EXPECT_GT(g_hw_mb_count, 0);
g_hw_mb_count = 0;
unsync_buffer.Write32(0x87654321, 0);
EXPECT_EQ(0x87654321u, unsync_buffer.Read32(0));
EXPECT_EQ(0, g_hw_mb_count);
}
} // namespace