blob: 34231b3c11a6420e241de3c4e7fb6a3618569374 [file]
// Copyright 2023 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 "src/graphics/display/lib/framebuffer-display/framebuffer-display.h"
#include <fidl/fuchsia.sysmem2/cpp/wire.h>
#include <fidl/fuchsia.sysmem2/cpp/wire_test_base.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
#include <lib/async/cpp/wait.h>
#include <lib/driver/testing/cpp/scoped_global_logger.h>
#include <lib/fit/defer.h>
#include <lib/zx/object.h>
#include <lib/zx/result.h>
#include <zircon/assert.h>
#include <zircon/errors.h>
#include <zircon/rights.h>
#include <list>
#include <memory>
#include <fake-mmio-reg/fake-mmio-reg.h>
#include <gtest/gtest.h>
#include "src/graphics/display/lib/api-protocols/cpp/display-engine-events-fidl.h"
#include "src/graphics/display/lib/api-types/cpp/driver-buffer-collection-id.h"
#include "src/graphics/display/lib/api-types/cpp/image-buffer-usage.h"
#include "src/graphics/display/lib/api-types/cpp/image-metadata.h"
#include "src/graphics/display/lib/api-types/cpp/image-tiling-type.h"
#include "src/graphics/display/lib/api-types/cpp/pixel-format.h"
#include "src/lib/fsl/handles/object_info.h"
#include "src/lib/testing/predicates/status.h"
namespace framebuffer_display {
namespace {
constexpr DisplayProperties kDisplayProperties{
.width_px = 800,
.height_px = 600,
.row_stride_px = 800,
.pixel_format = display::PixelFormat::kB8G8R8A8,
};
constexpr size_t kBytesPerPixel = 4;
constexpr size_t kImageByteSize = uint64_t{kDisplayProperties.row_stride_px} *
static_cast<uint64_t>(kDisplayProperties.height_px) *
kBytesPerPixel;
// TODO(https://fxbug.dev/42072949): Consider creating and using a unified set of sysmem
// testing doubles instead of writing mocks for each display driver test.
class FakeBufferCollection : public fidl::testing::WireTestBase<fuchsia_sysmem2::BufferCollection> {
public:
explicit FakeBufferCollection(zx::unowned_vmo framebuffer_vmo, size_t image_byte_size,
uint32_t num_buffers = 2)
: framebuffer_vmo_(std::move(framebuffer_vmo)),
image_byte_size_(image_byte_size),
num_buffers_(num_buffers) {}
void SetConstraints(::fuchsia_sysmem2::wire::BufferCollectionSetConstraintsRequest* request,
SetConstraintsCompleter::Sync& completer) override {}
void CheckAllBuffersAllocated(CheckAllBuffersAllocatedCompleter::Sync& completer) override {
completer.ReplySuccess();
}
void WaitForAllBuffersAllocated(WaitForAllBuffersAllocatedCompleter::Sync& completer) override {
fidl::Arena arena;
auto response =
fuchsia_sysmem2::wire::BufferCollectionWaitForAllBuffersAllocatedResponse::Builder(arena);
auto collection_info = fuchsia_sysmem2::wire::BufferCollectionInfo::Builder(arena);
auto single_buffer_settings = fuchsia_sysmem2::wire::SingleBufferSettings::Builder(arena);
auto buffer_memory_settings = fuchsia_sysmem2::wire::BufferMemorySettings::Builder(arena);
single_buffer_settings.buffer_settings(buffer_memory_settings.Build());
auto image_format_constraints = fuchsia_sysmem2::wire::ImageFormatConstraints::Builder(arena);
image_format_constraints.pixel_format(fuchsia_images2::wire::PixelFormat::kB8G8R8A8);
image_format_constraints.pixel_format_modifier(
fuchsia_images2::wire::PixelFormatModifier::kLinear);
single_buffer_settings.image_format_constraints(image_format_constraints.Build());
collection_info.settings(single_buffer_settings.Build());
fidl::VectorView<fuchsia_sysmem2::wire::VmoBuffer> buffers(arena, num_buffers_);
for (uint32_t i = 0; i < num_buffers_; i++) {
zx::vmo vmo;
if (i == 0 && framebuffer_vmo_->is_valid()) {
EXPECT_OK(framebuffer_vmo_->duplicate(ZX_RIGHT_SAME_RIGHTS, &vmo));
} else {
zx::vmo::create(image_byte_size_, 0, &vmo);
}
auto vmo_buffer = fuchsia_sysmem2::wire::VmoBuffer::Builder(arena);
vmo_buffer.vmo(std::move(vmo));
vmo_buffer.vmo_usable_start(0);
buffers[i] = vmo_buffer.Build();
}
collection_info.buffers(buffers);
response.buffer_collection_info(collection_info.Build());
completer.ReplySuccess(response.Build());
}
void NotImplemented_(const std::string& name, ::fidl::CompleterBase& completer) override {}
private:
zx::unowned_vmo framebuffer_vmo_;
size_t image_byte_size_;
uint32_t num_buffers_;
};
using BufferCollectionId = uint64_t;
class FakeSysmemBase {
public:
virtual BufferCollectionId AllocBufferCollectionId() = 0;
};
class MockAllocator : public fidl::testing::WireTestBase<fuchsia_sysmem2::Allocator> {
public:
explicit MockAllocator(FakeSysmemBase& parent, async_dispatcher_t* dispatcher,
zx::unowned_vmo framebuffer_vmo, size_t image_byte_size)
: parent_(parent),
dispatcher_(dispatcher),
framebuffer_vmo_(std::move(framebuffer_vmo)),
image_byte_size_(image_byte_size) {
ZX_ASSERT(dispatcher_);
}
void BindSharedCollection(BindSharedCollectionRequestView request,
BindSharedCollectionCompleter::Sync& completer) override {
auto buffer_collection_id = parent_.AllocBufferCollectionId();
active_buffer_collections_.emplace(
buffer_collection_id,
BufferCollection{.token_client = std::move(request->token()),
.unowned_collection_server = request->buffer_collection_request(),
.fake_buffer_collection =
FakeBufferCollection(framebuffer_vmo_->borrow(), image_byte_size_)});
fidl::BindServer(
dispatcher_, std::move(request->buffer_collection_request()),
&active_buffer_collections_.at(buffer_collection_id).fake_buffer_collection,
[this, buffer_collection_id](FakeBufferCollection*, fidl::UnbindInfo,
fidl::ServerEnd<fuchsia_sysmem2::BufferCollection>) {
inactive_buffer_collection_tokens_.push_back(
std::move(active_buffer_collections_.at(buffer_collection_id).token_client));
active_buffer_collections_.erase(buffer_collection_id);
});
}
std::vector<std::pair<fidl::UnownedClientEnd<fuchsia_sysmem2::BufferCollectionToken>,
fidl::UnownedServerEnd<fuchsia_sysmem2::BufferCollection>>>
GetBufferCollectionConnections() {
if (active_buffer_collections_.empty()) {
return {};
}
std::vector<std::pair<fidl::UnownedClientEnd<fuchsia_sysmem2::BufferCollectionToken>,
fidl::UnownedServerEnd<fuchsia_sysmem2::BufferCollection>>>
result;
for (const auto& kv : active_buffer_collections_) {
result.emplace_back(kv.second.token_client, kv.second.unowned_collection_server);
}
return result;
}
void SetDebugClientInfo(SetDebugClientInfoRequestView request,
SetDebugClientInfoCompleter::Sync& completer) override {
EXPECT_EQ(request->name().get().find("framebuffer-display"), 0u);
}
void NotImplemented_(const std::string& name, fidl::CompleterBase& completer) override {
fdf::error("{} not implemented", name);
EXPECT_TRUE(false);
}
private:
struct BufferCollection {
fidl::ClientEnd<fuchsia_sysmem2::BufferCollectionToken> token_client;
fidl::UnownedServerEnd<fuchsia_sysmem2::BufferCollection> unowned_collection_server;
FakeBufferCollection fake_buffer_collection;
};
FakeSysmemBase& parent_;
std::unordered_map<BufferCollectionId, BufferCollection> active_buffer_collections_;
std::vector<fidl::ClientEnd<fuchsia_sysmem2::BufferCollectionToken>>
inactive_buffer_collection_tokens_;
async_dispatcher_t* dispatcher_ = nullptr;
zx::unowned_vmo framebuffer_vmo_;
size_t image_byte_size_ = 0;
};
class FakeSysmem : public FakeSysmemBase {
public:
explicit FakeSysmem(async_dispatcher_t* dispatcher, zx::unowned_vmo framebuffer_vmo,
uint64_t first_buffer_collection_id, size_t collection_image_byte_size)
: dispatcher_(dispatcher),
framebuffer_vmo_(std::move(framebuffer_vmo)),
next_buffer_collection_id_(first_buffer_collection_id),
collection_image_byte_size_(collection_image_byte_size) {
EXPECT_TRUE(dispatcher_);
}
fit::result<zx_status_t, fidl::WireSyncClient<fuchsia_sysmem2::Allocator>>
MakeFakeSysmemAllocator() {
auto [sysmem_client, sysmem_server] = fidl::Endpoints<fuchsia_sysmem2::Allocator>::Create();
mock_allocators_.emplace_front(*this, dispatcher_, framebuffer_vmo_->borrow(),
collection_image_byte_size_);
auto it = mock_allocators_.begin();
fidl::BindServer(dispatcher_, std::move(sysmem_server), &*it);
return fit::ok(fidl::WireSyncClient(std::move(sysmem_client)));
}
std::list<MockAllocator>& mock_allocators() { return mock_allocators_; }
BufferCollectionId AllocBufferCollectionId() override { return next_buffer_collection_id_++; }
private:
friend class MockAllocator;
std::list<MockAllocator> mock_allocators_;
async_dispatcher_t* dispatcher_ = nullptr;
zx::unowned_vmo framebuffer_vmo_ = {};
BufferCollectionId next_buffer_collection_id_ = 0;
size_t collection_image_byte_size_ = 0;
};
class FakeMmio {
public:
FakeMmio() {
mmio_ = std::make_unique<ddk_fake::FakeMmioRegRegion>(sizeof(uint32_t), kRegArrayLength);
}
fdf::MmioBuffer MmioBuffer() { return mmio_->GetMmioBuffer(); }
ddk_fake::FakeMmioReg& FakeRegister(size_t address) { return (*mmio_)[address]; }
private:
static constexpr size_t kMmioBufferSize = 0x5000;
static constexpr size_t kRegArrayLength = kMmioBufferSize / sizeof(uint32_t);
std::unique_ptr<ddk_fake::FakeMmioRegRegion> mmio_;
};
class FramebufferDisplayTest : public ::testing::Test {
protected:
fdf_testing::ScopedGlobalLogger logger_;
display::DisplayEngineEventsFidl engine_events_;
};
void ExpectHandlesArePaired(zx_handle_t lhs, zx_handle_t rhs) {
auto [lhs_koid, lhs_related_koid] = fsl::GetKoids(lhs);
auto [rhs_koid, rhs_related_koid] = fsl::GetKoids(rhs);
EXPECT_NE(lhs_koid, ZX_KOID_INVALID);
EXPECT_NE(lhs_related_koid, ZX_KOID_INVALID);
EXPECT_NE(rhs_koid, ZX_KOID_INVALID);
EXPECT_NE(rhs_related_koid, ZX_KOID_INVALID);
EXPECT_EQ(lhs_koid, rhs_related_koid);
EXPECT_EQ(rhs_koid, lhs_related_koid);
}
template <typename T>
void ExpectObjectsArePaired(zx::unowned<T> lhs, zx::unowned<T> rhs) {
return ExpectHandlesArePaired(lhs->get(), rhs->get());
}
TEST_F(FramebufferDisplayTest, ImportBufferCollection) {
async::Loop env_loop(&kAsyncLoopConfigAttachToCurrentThread);
FakeSysmem fake_sysmem(env_loop.dispatcher(), /*framebuffer_vmo=*/{}, 0, kImageByteSize);
FakeMmio fake_mmio;
auto sysmem_client_result = fake_sysmem.MakeFakeSysmemAllocator();
ASSERT_TRUE(sysmem_client_result.is_ok());
auto& sysmem_client = sysmem_client_result.value();
async::Loop display_loop(&kAsyncLoopConfigNeverAttachToThread);
display_loop.StartThread("framebuffer-display-loop");
FramebufferDisplay display(&engine_events_, std::move(sysmem_client), fake_mmio.MmioBuffer(),
kDisplayProperties, display_loop.dispatcher());
auto token1_endpoints = fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();
auto token2_endpoints = fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();
// Test ImportBufferCollection().
const display::DriverBufferCollectionId kValidCollectionId(1);
EXPECT_OK(display.ImportBufferCollection(kValidCollectionId, std::move(token1_endpoints.client)));
// `collection_id` must be unused.
EXPECT_STATUS(
display.ImportBufferCollection(kValidCollectionId, std::move(token2_endpoints.client)),
zx::error(ZX_ERR_ALREADY_EXISTS));
env_loop.RunUntilIdle();
EXPECT_EQ(fake_sysmem.mock_allocators().size(), 1u);
auto& allocator = fake_sysmem.mock_allocators().front();
// Verify that the current buffer collection token is used.
{
const std::vector buffer_collection_connections = allocator.GetBufferCollectionConnections();
ASSERT_EQ(buffer_collection_connections.size(), 1u);
const auto& buffer_collection_server = buffer_collection_connections[0].second;
const auto& buffer_collection_client =
display.GetBufferCollectionsForTesting().at(kValidCollectionId).client_end();
ExpectObjectsArePaired(buffer_collection_server.handle(), buffer_collection_client.handle());
const auto& buffer_collection_token_server = token1_endpoints.server;
const auto& buffer_collection_token_client = buffer_collection_connections[0].first;
ExpectObjectsArePaired(buffer_collection_token_server.handle(),
buffer_collection_token_client.handle());
}
// Test ReleaseBufferCollection().
const display::DriverBufferCollectionId kInvalidCollectionId(2);
EXPECT_STATUS(display.ReleaseBufferCollection(kInvalidCollectionId), zx::error(ZX_ERR_NOT_FOUND));
EXPECT_OK(display.ReleaseBufferCollection(kValidCollectionId));
env_loop.RunUntilIdle();
// Verify that the current buffer collection token is released.
{
const std::vector buffer_collection_connections = allocator.GetBufferCollectionConnections();
ASSERT_EQ(buffer_collection_connections.size(), 0u);
}
// Shutdown the loop before destroying the FakeSysmem and MockAllocator which
// may still have pending callbacks.
env_loop.Shutdown();
display_loop.Shutdown();
}
TEST_F(FramebufferDisplayTest, ImportImage) {
const display::DriverBufferCollectionId kBufferCollectionId(1);
// `framebuffer_vmo` must outlive `fake_sysmem`.
zx::vmo framebuffer_vmo;
EXPECT_OK(zx::vmo::create(kImageByteSize, 0, &framebuffer_vmo));
async::Loop env_loop(&kAsyncLoopConfigNeverAttachToThread);
FakeSysmem fake_sysmem(env_loop.dispatcher(), framebuffer_vmo.borrow(),
kBufferCollectionId.value(), kImageByteSize);
FakeMmio fake_mmio;
env_loop.StartThread("env-loop");
auto sysmem_client_result = fake_sysmem.MakeFakeSysmemAllocator();
ASSERT_TRUE(sysmem_client_result.is_ok());
auto& sysmem_client = sysmem_client_result.value();
async::Loop display_loop(&kAsyncLoopConfigNeverAttachToThread);
display_loop.StartThread("framebuffer-display-loop");
FramebufferDisplay display(&engine_events_, std::move(sysmem_client), fake_mmio.MmioBuffer(),
kDisplayProperties, display_loop.dispatcher());
auto token_endpoints = fidl::Endpoints<fuchsia_sysmem2::BufferCollectionToken>::Create();
// Import BufferCollection.
EXPECT_OK(display.ImportBufferCollection(kBufferCollectionId, std::move(token_endpoints.client)));
// Set Buffer collection constraints.
static constexpr display::ImageBufferUsage kDisplayUsage({
.tiling_type = display::ImageTilingType::kLinear,
});
EXPECT_OK(display.SetBufferCollectionConstraints(kDisplayUsage, kBufferCollectionId));
static constexpr display::ImageMetadata kDisplayImageMetadata({
.width = kDisplayProperties.width_px,
.height = kDisplayProperties.height_px,
.tiling_type = display::ImageTilingType::kLinear,
});
// Invalid import: bad collection id.
display::DriverBufferCollectionId kInvalidCollectionId(100);
EXPECT_STATUS(display.ImportImage(kDisplayImageMetadata, kInvalidCollectionId, 0),
zx::error(ZX_ERR_NOT_FOUND));
// Invalid import: bad index.
EXPECT_STATUS(display.ImportImage(kDisplayImageMetadata, kBufferCollectionId, 100),
zx::error(ZX_ERR_OUT_OF_RANGE));
// Invalid import: bad width.
static constexpr display::ImageMetadata kImageMetadataWithIncorrectWidth({
.width = kDisplayProperties.width_px * 2,
.height = kDisplayProperties.height_px,
.tiling_type = display::ImageTilingType::kLinear,
});
EXPECT_STATUS(display.ImportImage(kImageMetadataWithIncorrectWidth, kBufferCollectionId, 0),
zx::error(ZX_ERR_INVALID_ARGS));
// Invalid import: bad height.
static constexpr display::ImageMetadata kImageMetadataWithIncorrectHeight({
.width = kDisplayProperties.width_px,
.height = kDisplayProperties.height_px * 2,
.tiling_type = display::ImageTilingType::kLinear,
});
EXPECT_STATUS(display.ImportImage(kImageMetadataWithIncorrectHeight, kBufferCollectionId, 0),
zx::error(ZX_ERR_INVALID_ARGS));
// Valid import: buffer_index 0.
zx::result<display::DriverImageId> import0_result =
display.ImportImage(kDisplayImageMetadata, kBufferCollectionId, 0);
ASSERT_OK(import0_result);
EXPECT_NE(display::kInvalidDriverImageId, import0_result.value());
// Valid import: buffer_index 1.
zx::result<display::DriverImageId> import1_result =
display.ImportImage(kDisplayImageMetadata, kBufferCollectionId, 1);
ASSERT_OK(import1_result);
EXPECT_NE(display::kInvalidDriverImageId, import1_result.value());
// Each import gets a unique image ID.
EXPECT_NE(import0_result.value(), import1_result.value());
display.ReleaseImage(import0_result.value());
display.ReleaseImage(import1_result.value());
// Release buffer collection.
EXPECT_OK(display.ReleaseBufferCollection(kBufferCollectionId));
env_loop.RunUntilIdle();
// Shutdown the loop before destroying the FakeSysmem and MockAllocator which
// may still have pending callbacks.
env_loop.Shutdown();
display_loop.Shutdown();
}
TEST_F(FramebufferDisplayTest, DestructionCancelsVsyncTask) {
FakeMmio fake_mmio;
async::Loop display_loop(&kAsyncLoopConfigNeverAttachToThread);
{
FramebufferDisplay display(&engine_events_, /*sysmem_client=*/{}, fake_mmio.MmioBuffer(),
kDisplayProperties, display_loop.dispatcher());
EXPECT_OK(display.Initialize());
}
// Running the loop after display is destroyed should not invoke callbacks
// on the destroyed object or crash.
display_loop.RunUntilIdle();
display_loop.Shutdown();
}
TEST_F(FramebufferDisplayTest, DeinitializeWithoutInitializeIsNoOp) {
FakeMmio fake_mmio;
async::Loop display_loop(&kAsyncLoopConfigNeverAttachToThread);
FramebufferDisplay display(&engine_events_, /*sysmem_client=*/{}, fake_mmio.MmioBuffer(),
kDisplayProperties, display_loop.dispatcher());
// Calling Deinitialize() on an uninitialized display is safe and is a no-op.
display.Deinitialize();
}
TEST_F(FramebufferDisplayTest, DeinitializeMultipleTimesIsSafe) {
FakeMmio fake_mmio;
async::Loop display_loop(&kAsyncLoopConfigNeverAttachToThread);
FramebufferDisplay display(&engine_events_, /*sysmem_client=*/{}, fake_mmio.MmioBuffer(),
kDisplayProperties, display_loop.dispatcher());
EXPECT_OK(display.Initialize());
// Calling Deinitialize() multiple times is safe and subsequent calls are no-ops.
display.Deinitialize();
display.Deinitialize();
display_loop.RunUntilIdle();
display_loop.Shutdown();
}
} // namespace
} // namespace framebuffer_display