virtio_gpu_frontend.cpp

// Copyright (C) 2024 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 "virtio_gpu_frontend.h"

#ifdef GFXSTREAM_BUILD_WITH_SNAPSHOT_FRONTEND_SUPPORT
#include <fcntl.h>

#include <filesystem>
// X11 defines status as a preprocessor define which messes up
// anyone with a `Status` type.
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <google/protobuf/text_format.h>
#endif  // ifdef GFXSTREAM_BUILD_WITH_SNAPSHOT_FRONTEND_SUPPORT

#include <vulkan/vulkan.h>

#include <cerrno>
#include <cstdint>
#include <cstring>

#include "frame_buffer.h"
#include "gfxstream/host/address_space_operations.h"
#include "gfxstream/host/framework_formats.h"
#include "vulkan/vk_common_operations.h"
// TODO: remove after moving save/load interface to ops.
#include "gfxstream/common/logging.h"
#include "gfxstream/host/address_space_graphics.h"
#include "gfxstream/host/file_stream.h"
#include "gfxstream/host/tracing.h"
#include "gfxstream/memory/SharedMemory.h"
#include "gfxstream/threads/WorkerThread.h"
#include "virtgpu_gfxstream_protocol.h"
#include "virtio_gpu_timelines.h"

namespace gfxstream {
namespace host {
namespace {

using gfxstream::base::DescriptorType;
using gfxstream::base::SharedMemory;
#ifdef GFXSTREAM_BUILD_WITH_SNAPSHOT_FRONTEND_SUPPORT
using gfxstream::host::snapshot::VirtioGpuContextSnapshot;
using gfxstream::host::snapshot::VirtioGpuFrontendSnapshot;
using gfxstream::host::snapshot::VirtioGpuResourceSnapshot;
#endif  // ifdef GFXSTREAM_BUILD_WITH_SNAPSHOT_FRONTEND_SUPPORT

// Helper for printing very detailed debug logs
#define D(...)                            \
    do {                                  \
        if (mLogCalls) {                  \
            GFXSTREAM_DEBUG(__VA_ARGS__); \
        }                                 \
    } while (0)

struct VirtioGpuCmd {
    uint32_t op;
    uint32_t cmdSize;
    unsigned char buf[0];
} __attribute__((packed));

static uint64_t convert32to64(uint32_t lo, uint32_t hi) {
    return ((uint64_t)lo) | (((uint64_t)hi) << 32);
}

}  // namespace

class CleanupThread {
   public:
    using GenericCleanup = std::function<void()>;

    CleanupThread()
        : mWorker(
              []() { GFXSTREAM_TRACE_NAME_THREAD("Gfxstream Virtio Gpu Frontend Cleanup Thread"); },
              [](CleanupTask task) {
                  return std::visit(
                      [](auto&& work) {
                          using T = std::decay_t<decltype(work)>;
                          if constexpr (std::is_same_v<T, GenericCleanup>) {
                              work();
                              return gfxstream::base::WorkerProcessingResult::Continue;
                          } else if constexpr (std::is_same_v<T, Exit>) {
                              return gfxstream::base::WorkerProcessingResult::Stop;
                          }
                      },
                      std::move(task));
              }) {
        mWorker.start();
    }

    ~CleanupThread() { stop(); }

    // CleanupThread is neither copyable nor movable.
    CleanupThread(const CleanupThread& other) = delete;
    CleanupThread& operator=(const CleanupThread& other) = delete;
    CleanupThread(CleanupThread&& other) = delete;
    CleanupThread& operator=(CleanupThread&& other) = delete;

    void enqueueCleanup(GenericCleanup command) { mWorker.enqueue(std::move(command)); }

    void waitForPendingCleanups() {
        std::promise<void> pendingCleanupsCompletedSignal;
        std::future<void> pendingCleanupsCompltedWaitable =
            pendingCleanupsCompletedSignal.get_future();
        enqueueCleanup([&]() { pendingCleanupsCompletedSignal.set_value(); });
        pendingCleanupsCompltedWaitable.wait();
    }

    void stop() {
        mWorker.enqueue(Exit{});
        mWorker.join();
    }

   private:
    struct Exit {};
    using CleanupTask = std::variant<GenericCleanup, Exit>;
    gfxstream::base::WorkerThread<CleanupTask> mWorker;
};

VirtioGpuFrontend::VirtioGpuFrontend() {
#ifdef CONFIG_AEMU
    // For Android emulator, use existing verbose logging controls to enable extra debug logs
    mLogCalls = (gfxstream::base::getEnvironmentVariable("ANDROID_EMU_VIRTIO_DEBUG") == "1");
#else
    mLogCalls = true;
#endif
}

int VirtioGpuFrontend::init(RendererPtr renderer, void* cookie,
                            const gfxstream::host::FeatureSet& features,
                            stream_renderer_fence_callback fence_callback) {
    GFXSTREAM_DEBUG("cookie: %p", cookie);
    mRenderer = renderer;
    mCookie = cookie;
    mFeatures = features;
    mFenceCallback = fence_callback;
    mVirtioGpuTimelines = VirtioGpuTimelines::create(getFenceCompletionCallback());

#if !defined(_WIN32)
    mPageSize = getpagesize();
#endif

    mCleanupThread.reset(new CleanupThread());

    return 0;
}

void VirtioGpuFrontend::teardown() {
    destroyVirtioGpuObjects();

    mCleanupThread.reset();

    if (mRenderer) {
        mRenderer->finish();

        bool success = mRenderer->destroyOpenGLSubwindow();
        if (!success) {
            GFXSTREAM_WARNING("Failed to destroy renderer window.");
        }

        mRenderer->stop(/*wait*/ true);
        mRenderer.reset();
    }
}

int VirtioGpuFrontend::createContext(VirtioGpuCtxId contextId, uint32_t nlen, const char* name,
                                     uint32_t contextInit) {
    std::string contextName(name, nlen);

    GFXSTREAM_DEBUG("ctxid: %u len: %u name: %s", contextId, nlen, contextName.c_str());

    auto contextOpt = VirtioGpuContext::Create(mRenderer, contextId, contextName, contextInit);
    if (!contextOpt) {
        GFXSTREAM_ERROR("Failed to create context %u.", contextId);
        return -EINVAL;
    }
    mContexts[contextId] = std::move(*contextOpt);
    return 0;
}

VirtioGpuTimelines::FenceCompletionCallback VirtioGpuFrontend::getFenceCompletionCallback() {
    // Forwards fence completions from VirtioGpuTimelines to the client (VMM).
    return [this](const VirtioGpuTimelines::Ring& ring, VirtioGpuTimelines::FenceId fenceId) {
        struct stream_renderer_fence fence = {0};
        fence.fence_id = fenceId;
        fence.flags = STREAM_RENDERER_FLAG_FENCE;
        if (const auto* contextSpecificRing = std::get_if<VirtioGpuRingContextSpecific>(&ring)) {
            fence.flags |= STREAM_RENDERER_FLAG_FENCE_RING_IDX;
            fence.ctx_id = contextSpecificRing->mCtxId;
            fence.ring_idx = contextSpecificRing->mRingIdx;
        }
        mFenceCallback(mCookie, &fence);
    };
}

int VirtioGpuFrontend::destroyContext(VirtioGpuCtxId contextId) {
    GFXSTREAM_DEBUG("ctxid: %u", contextId);

    auto contextIt = mContexts.find(contextId);
    if (contextIt == mContexts.end()) {
        GFXSTREAM_ERROR("failed to destroy context %d: context not found", contextId);
        return -EINVAL;
    }
    auto& context = contextIt->second;

    context.Destroy(get_gfxstream_address_space_ops());

    mContexts.erase(contextIt);
    return 0;
}

template <typename T>
bool SafeDecode(T& out, const uint8_t* buffer, uint32_t buffer_size) {
    if (buffer_size < sizeof(T)) {
        GFXSTREAM_ERROR("failed to decode: need %u bytes but have %u bytes)",
                        sizeof(T), buffer_size);
        return false;
    }
    std::memcpy(&out, buffer, sizeof(T));
    return true;
}

int VirtioGpuFrontend::processAddressSpaceCommand(VirtioGpuCtxId ctxId, const uint8_t* cmd_buffer, uint32_t cmd_buffer_size) {
    gfxstream::gfxstreamHeader header = {};
    if (!SafeDecode(header, cmd_buffer, cmd_buffer_size)) {
        GFXSTREAM_ERROR("failed to decode header");
        return -EINVAL;
    }

    auto contextIt = mContexts.find(ctxId);
    if (contextIt == mContexts.end()) {
        GFXSTREAM_ERROR("ctx id %u not found", ctxId);
        return -EINVAL;
    }
    auto& context = contextIt->second;

    switch (header.opCode) {
        case GFXSTREAM_CONTEXT_CREATE: {
            gfxstream::gfxstreamContextCreate contextCreate = {};
            if (!SafeDecode(contextCreate, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode contextCreate");
                return -EINVAL;
            }

            auto resourceIt = mResources.find(contextCreate.resourceId);
            if (resourceIt == mResources.end()) {
                GFXSTREAM_ERROR("ASG coherent resource %u not found", contextCreate.resourceId);
                return -EINVAL;
            }
            auto& resource = resourceIt->second;

            return context.CreateAddressSpaceGraphicsInstance(get_gfxstream_address_space_ops(),
                                                              resource);
        }
        case GFXSTREAM_CONTEXT_PING: {
            gfxstream::gfxstreamContextPing contextPing = {};
            if (!SafeDecode(contextPing, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode contextPing");
                return -EINVAL;
            }

            return context.PingAddressSpaceGraphicsInstance(get_gfxstream_address_space_ops(),
                                                            contextPing.resourceId);
        }
        default:
            break;
    }

    return 0;
}

int VirtioGpuFrontend::processCommand(const struct stream_renderer_command* cmd) {
    if (!cmd) {
        GFXSTREAM_ERROR("missing command");
        return -EINVAL;
    }

    const uint8_t* cmd_buffer = cmd->cmd;
    if (!cmd_buffer) {
        GFXSTREAM_ERROR("missing command buffer");
        return -EINVAL;
    }

    const uint32_t cmd_buffer_size = cmd->cmd_size;
    if (cmd_buffer_size < 4) {
        GFXSTREAM_ERROR("not enough bytes (got %d)", cmd_buffer_size);
        return -EINVAL;
    }

    VirtioGpuRing ring = VirtioGpuRingGlobal{};
    D("ctx: %u, ring: %s cmd_buffer: %p size: %d", cmd->ctx_id,
      to_string(ring).c_str(), cmd_buffer, cmd_buffer_size);

    gfxstream::gfxstreamHeader header = {};
    if (!SafeDecode(header, cmd_buffer, cmd_buffer_size)) {
        GFXSTREAM_ERROR("failed to decode command header");
        return -EINVAL;
    }

    switch (header.opCode) {
        case GFXSTREAM_CONTEXT_CREATE:
        case GFXSTREAM_CONTEXT_PING:
        case GFXSTREAM_CONTEXT_PING_WITH_RESPONSE: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_CONTEXT_[CREATE|PING]");

            if (processAddressSpaceCommand(cmd->ctx_id, cmd_buffer, cmd->cmd_size)) {
                return -EINVAL;
            }
            break;
        }
        case GFXSTREAM_CREATE_EXPORT_SYNC: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_CREATE_EXPORT_SYNC");

            // Make sure the context-specific ring is used
            ring = VirtioGpuRingContextSpecific{
                .mCtxId = cmd->ctx_id,
                .mRingIdx = 0,
            };

            gfxstream::gfxstreamCreateExportSync exportSync = {};
            if (!SafeDecode(exportSync, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode exportSync");
                return -EINVAL;
            }

            uint64_t sync_handle = convert32to64(exportSync.syncHandleLo, exportSync.syncHandleHi);

            D("wait for gpu ring %s", to_string(ring).c_str());
            auto taskId = mVirtioGpuTimelines->enqueueTask(ring);
#if GFXSTREAM_ENABLE_HOST_GLES
            FrameBuffer::getFB()->asyncWaitForGpuWithCb(
                sync_handle, [this, taskId] { mVirtioGpuTimelines->notifyTaskCompletion(taskId); });
#endif
            break;
        }
        case GFXSTREAM_CREATE_EXPORT_SYNC_VK:
        case GFXSTREAM_CREATE_IMPORT_SYNC_VK: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_CREATE_[IMPORT|EXPORT]_SYNC_VK");

            gfxstream::gfxstreamCreateExportSyncVK exportSyncVK = {};
            if (!SafeDecode(exportSyncVK, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode exportSyncVK");
                return -EINVAL;
            }

            // The guest sync export assumes fence context support and always uses
            // VIRTGPU_EXECBUF_RING_IDX. With this, the task created here must use
            // the same ring as the fence created for the virtio gpu command or the
            // fence may be signaled without properly waiting for the task to complete.
            ring = VirtioGpuRingContextSpecific{
                .mCtxId = cmd->ctx_id,
                .mRingIdx = 0,
            };

            uint64_t device_handle =
                convert32to64(exportSyncVK.deviceHandleLo, exportSyncVK.deviceHandleHi);

            uint64_t fence_handle =
                convert32to64(exportSyncVK.fenceHandleLo, exportSyncVK.fenceHandleHi);

            D("wait for gpu ring %s", to_string(ring).c_str());
            auto taskId = mVirtioGpuTimelines->enqueueTask(ring);
            FrameBuffer::getFB()->asyncWaitForGpuVulkanWithCb(
                device_handle, fence_handle,
                [this, taskId] { mVirtioGpuTimelines->notifyTaskCompletion(taskId); });
            break;
        }
        case GFXSTREAM_CREATE_QSRI_EXPORT_VK: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_CREATE_QSRI_EXPORT_VK");

            gfxstream::gfxstreamCreateQSRIExportVK exportQSRI = {};
            if (!SafeDecode(exportQSRI, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode exportQSRI");
                return -EINVAL;
            }

            // The guest QSRI export assumes fence context support and always uses
            // VIRTGPU_EXECBUF_RING_IDX. With this, the task created here must use
            // the same ring as the fence created for the virtio gpu command or the
            // fence may be signaled without properly waiting for the task to complete.
            ring = VirtioGpuRingContextSpecific{
                .mCtxId = cmd->ctx_id,
                .mRingIdx = 0,
            };

            uint64_t image_handle =
                convert32to64(exportQSRI.imageHandleLo, exportQSRI.imageHandleHi);

            D("wait for gpu vk qsri ring %s image 0x%llx", to_string(ring).c_str(),
              (unsigned long long)image_handle);
            auto taskId = mVirtioGpuTimelines->enqueueTask(ring);
            FrameBuffer::getFB()->asyncWaitForGpuVulkanQsriWithCb(image_handle, [this, taskId] {
                mVirtioGpuTimelines->notifyTaskCompletion(taskId);
            });
            break;
        }
        case GFXSTREAM_RESOURCE_CREATE_3D: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_RESOURCE_CREATE_3D");

            gfxstream::gfxstreamResourceCreate3d create3d = {};
            if (!SafeDecode(create3d, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode create3d");
                return -EINVAL;
            }
            struct stream_renderer_resource_create_args rc3d = {};
            rc3d.target = create3d.target;
            rc3d.format = create3d.format;
            rc3d.bind = create3d.bind;
            rc3d.width = create3d.width;
            rc3d.height = create3d.height;
            rc3d.depth = create3d.depth;
            rc3d.array_size = create3d.arraySize;
            rc3d.last_level = create3d.lastLevel;
            rc3d.nr_samples = create3d.nrSamples;
            rc3d.flags = create3d.flags;

            auto contextIt = mContexts.find(cmd->ctx_id);
            if (contextIt == mContexts.end()) {
                GFXSTREAM_ERROR("ctx id %u is not found", cmd->ctx_id);
                return -EINVAL;
            }
            auto& context = contextIt->second;

            return context.AddPendingBlob(create3d.blobId, rc3d);
        }
        case GFXSTREAM_ACQUIRE_SYNC: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_ACQUIRE_SYNC");

            gfxstream::gfxstreamAcquireSync acquireSync = {};
            if (!SafeDecode(acquireSync, cmd_buffer, cmd_buffer_size)) {
                GFXSTREAM_ERROR("failed to decode acquireSync");
                return -EINVAL;
            }

            auto contextIt = mContexts.find(cmd->ctx_id);
            if (contextIt == mContexts.end()) {
                GFXSTREAM_ERROR("ctx id %u is not found", cmd->ctx_id);
                return -EINVAL;
            }
            auto& context = contextIt->second;
            return context.AcquireSync(acquireSync.syncId);
        }
        case GFXSTREAM_PLACEHOLDER_COMMAND_VK: {
            GFXSTREAM_TRACE_EVENT(GFXSTREAM_TRACE_STREAM_RENDERER_CATEGORY,
                                  "GFXSTREAM_PLACEHOLDER_COMMAND_VK");

            // Do nothing, this is a placeholder command
            break;
        }
        default:
            return -EINVAL;
    }

    return 0;
}

int VirtioGpuFrontend::createFence(uint64_t fence_id, const VirtioGpuRing& ring) {
    D("fenceid: %llu ring: %s", (unsigned long long)fence_id, to_string(ring).c_str());

    mVirtioGpuTimelines->enqueueFence(ring, fence_id);

    return 0;
}

int VirtioGpuFrontend::acquireContextFence(uint32_t contextId, uint64_t fenceId) {
    auto contextIt = mContexts.find(contextId);
    if (contextIt == mContexts.end()) {
        GFXSTREAM_ERROR("failed to acquire context %u fence: context not found", contextId);
        return -EINVAL;
    }
    auto& context = contextIt->second;

    auto syncInfoOpt = context.TakeSync();
    if (!syncInfoOpt) {
        GFXSTREAM_ERROR("failed to acquire context %u fence: no sync acquired", contextId);
        return -EINVAL;
    }

    mSyncMap[fenceId] = std::make_shared<SyncDescriptorInfo>(std::move(*syncInfoOpt));

    return 0;
}

void VirtioGpuFrontend::poll() { mVirtioGpuTimelines->poll(); }

int VirtioGpuFrontend::createResource(struct stream_renderer_resource_create_args* args,
                                      struct iovec* iov, uint32_t num_iovs) {
    auto resourceOpt = VirtioGpuResource::Create(args, iov, num_iovs);
    if (!resourceOpt) {
        GFXSTREAM_ERROR("Failed to create resource %u.", args->handle);
        return -EINVAL;
    }
    mResources[args->handle] = std::move(*resourceOpt);
    return 0;
}

int VirtioGpuFrontend::importResource(uint32_t res_handle,
                                      const struct stream_renderer_handle* import_handle,
                                      const struct stream_renderer_import_data* import_data) {
    if (!import_handle) {
        GFXSTREAM_ERROR("import_handle was not provided in call to importResource for handle: %d",
                        res_handle);
        return -EINVAL;
    } else if (!import_data) {
        GFXSTREAM_ERROR("import_data was not provided in call to importResource for handle: %d",
                        res_handle);
        return -EINVAL;
    } else if (!(import_data->flags & STREAM_RENDERER_IMPORT_FLAG_RESOURCE_EXISTS)) {
        GFXSTREAM_ERROR(
            "import_data::flags did not specify STREAM_RENDERER_IMPORT_FLAG_RESOURCE_EXISTS. "
            "Implementation only supports importing to a resource that already exists (res_handle: "
            "%d)",
            res_handle);
        return -EINVAL;
    }

    auto resourceIt = mResources.find(res_handle);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR(
            "import_data::flags specified STREAM_RENDERER_IMPORT_FLAG_RESOURCE_EXISTS, but "
            "internal resource does not already exist",
            res_handle);
        return -EINVAL;
    }

    return resourceIt->second.ImportHandle(import_handle, import_data);
}

void VirtioGpuFrontend::unrefResource(uint32_t resourceId) {
    D("resource: %u", resourceId);

    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) return;
    auto& resource = resourceIt->second;

    auto attachedContextIds = resource.GetAttachedContexts();
    for (auto contextId : attachedContextIds) {
        detachResource(contextId, resourceId);
    }

    resource.Destroy();

    mResources.erase(resourceIt);
}

int VirtioGpuFrontend::attachIov(int resourceId, struct iovec* iov, int num_iovs) {
    D("resource:%d numiovs: %d", resourceId, num_iovs);

    auto it = mResources.find(resourceId);
    if (it == mResources.end()) {
        GFXSTREAM_ERROR("failed to attach iov: resource %u not found.", resourceId);
        return ENOENT;
    }
    auto& resource = it->second;
    resource.AttachIov(iov, num_iovs);
    return 0;
}

void VirtioGpuFrontend::detachIov(int resourceId) {
    D("resource:%d", resourceId);

    auto it = mResources.find(resourceId);
    if (it == mResources.end()) {
        GFXSTREAM_ERROR("failed to detach iov: resource %u not found.", resourceId);
        return;
    }
    auto& resource = it->second;
    resource.DetachIov();
}

namespace {

std::optional<std::vector<struct iovec>> AsVecOption(struct iovec* iov, int iovec_cnt) {
    if (iovec_cnt > 0) {
        std::vector<struct iovec> ret;
        ret.reserve(iovec_cnt);
        for (int i = 0; i < iovec_cnt; i++) {
            ret.push_back(iov[i]);
        }
        return ret;
    }
    return std::nullopt;
}

}  // namespace

int VirtioGpuFrontend::transferReadIov(int resId, uint64_t offset, stream_renderer_box* box,
                                       struct iovec* iov, int iovec_cnt) {
    auto it = mResources.find(resId);
    if (it == mResources.end()) {
        GFXSTREAM_ERROR("Failed to transfer: failed to find resource %d.", resId);
        return EINVAL;
    }
    auto& resource = it->second;
    return resource.TransferRead(offset, box, AsVecOption(iov, iovec_cnt));
}

int VirtioGpuFrontend::transferWriteIov(int resId, uint64_t offset, stream_renderer_box* box,
                                        struct iovec* iov, int iovec_cnt) {
    auto it = mResources.find(resId);
    if (it == mResources.end()) {
        GFXSTREAM_ERROR("Failed to transfer: failed to find resource %d.", resId);
        return EINVAL;
    }
    auto& resource = it->second;
    return resource.TransferWrite(offset, box, AsVecOption(iov, iovec_cnt));
}

void VirtioGpuFrontend::getCapset(uint32_t set, uint32_t* max_size) {
    switch (set) {
        case VIRTGPU_CAPSET_GFXSTREAM_VULKAN:
            *max_size = sizeof(struct gfxstream::vulkanCapset);
            break;
        case VIRTGPU_CAPSET_GFXSTREAM_GLES:
            *max_size = sizeof(struct gfxstream::glesCapset);
            break;
        case VIRTGPU_CAPSET_GFXSTREAM_COMPOSER:
            *max_size = sizeof(struct gfxstream::composerCapset);
            break;
        default:
            GFXSTREAM_ERROR("Incorrect capability set specified (%u)", set);
    }
}

void VirtioGpuFrontend::fillCaps(uint32_t set, void* caps) {
    switch (set) {
        case VIRTGPU_CAPSET_GFXSTREAM_VULKAN: {
            struct gfxstream::vulkanCapset* capset =
                reinterpret_cast<struct gfxstream::vulkanCapset*>(caps);

            memset(capset, 0, sizeof(*capset));

            capset->protocolVersion = 1;
            capset->ringSize = 12288;
            capset->bufferSize = 1048576;

            auto* fb = FrameBuffer::getFB();
            if (fb->hasEmulationVk()) {
                const auto info = fb->getRepresentativeColorBufferMemoryTypeInfo();
                capset->colorBufferMemoryIndex = info.guestMemoryTypeIndex;
                capset->deferredMapping = 1;
            }

            if (mFeatures.VulkanBatchedDescriptorSetUpdate.enabled()) {
                capset->vulkanBatchedDescriptorSetUpdate = 1;
            }
            capset->noRenderControlEnc = 1;
            capset->blobAlignment = mPageSize;

#if GFXSTREAM_UNSTABLE_VULKAN_BLOB_COLOR_BUFFER
            capset->alwaysBlob = 1;
#endif

#if GFXSTREAM_UNSTABLE_VULKAN_EXTERNAL_SYNC
            capset->externalSync = 1;
#endif

            memset(capset->virglSupportedFormats, 0, sizeof(capset->virglSupportedFormats));

            struct FormatWithName {
                uint32_t format;
                const char* name;
            };
#define MAKE_FORMAT_AND_NAME(x) \
    {                           \
        x, #x                   \
    }
            static const FormatWithName kPossibleFormats[] = {
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_B5G6R5_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_B8G8R8A8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_B8G8R8X8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_NV12),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_P010),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_P210),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R10G10B10A2_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R16_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R16G16B16A16_FLOAT),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8B8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8B8A8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_R8G8B8X8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_YV12),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z16_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z24_UNORM_S8_UINT),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z24X8_UNORM),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z32_FLOAT_S8X24_UINT),
                MAKE_FORMAT_AND_NAME(VIRGL_FORMAT_Z32_FLOAT),
            };
#undef MAKE_FORMAT_AND_NAME

            if (!mFeatures.MinimalLogging.enabled()) {
                GFXSTREAM_INFO("Format support:");
            }
            for (std::size_t i = 0; i < std::size(kPossibleFormats); i++) {
                const FormatWithName& possibleFormat = kPossibleFormats[i];

                auto formatOpt = ToGfxstreamFormat(possibleFormat.format);
                if (!formatOpt) {
                    GFXSTREAM_FATAL("Unhandled format %s", possibleFormat.name);
                }
                auto format = *formatOpt;

                const bool supported = FrameBuffer::getFB()->isFormatSupported(format);
                set_virgl_format_supported(capset->virglSupportedFormats, possibleFormat.format,
                                           supported);

                if (!mFeatures.MinimalLogging.enabled()) {
                    GFXSTREAM_INFO(" %s: %s", possibleFormat.name,
                                   (supported ? "supported" : "unsupported"));
                }
            }

            capset->hasTraceAsyncCommand = 1;
            capset->hasSetMetadataCommand = 1;

            break;
        }
        case VIRTGPU_CAPSET_GFXSTREAM_GLES: {
            struct gfxstream::glesCapset* capset =
                reinterpret_cast<struct gfxstream::glesCapset*>(caps);

            capset->protocolVersion = 1;
            capset->ringSize = 12288;
            capset->bufferSize = 1048576;
            capset->blobAlignment = mPageSize;
            break;
        }
        case VIRTGPU_CAPSET_GFXSTREAM_COMPOSER: {
            struct gfxstream::composerCapset* capset =
                reinterpret_cast<struct gfxstream::composerCapset*>(caps);

            capset->protocolVersion = 1;
            capset->ringSize = 12288;
            capset->bufferSize = 1048576;
            capset->blobAlignment = mPageSize;
            break;
        }
        default:
            GFXSTREAM_ERROR("Incorrect capability set specified");
    }
}

void VirtioGpuFrontend::attachResource(uint32_t contextId, uint32_t resourceId) {
    D("ctxid: %u resid: %u", contextId, resourceId);

    auto contextIt = mContexts.find(contextId);
    if (contextIt == mContexts.end()) {
        GFXSTREAM_ERROR("failed to attach resource %u to context %u: context not found.",
                        resourceId, contextId);
        return;
    }
    auto& context = contextIt->second;

    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR("failed to attach resource %u to context %u: resource not found.",
                        resourceId, contextId);
        return;
    }
    auto& resource = resourceIt->second;

    context.AttachResource(resource);
}

void VirtioGpuFrontend::detachResource(uint32_t contextId, uint32_t resourceId) {
    D("ctxid: %u resid: %u", contextId, resourceId);

    auto contextIt = mContexts.find(contextId);
    if (contextIt == mContexts.end()) {
        GFXSTREAM_ERROR("failed to detach resource %u to context %u: context not found.",
                        resourceId, contextId);
        return;
    }
    auto& context = contextIt->second;

    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR("failed to attach resource %u to context %u: resource not found.",
                        resourceId, contextId);
        return;
    }
    auto& resource = resourceIt->second;

    auto resourceAsgOpt = context.TakeAddressSpaceGraphicsHandle(resourceId);
    if (resourceAsgOpt) {
        mCleanupThread->enqueueCleanup(
            [asgBlob = resource.ShareRingBlob(), asgHandle = *resourceAsgOpt]() {
                get_gfxstream_address_space_ops().destroy_handle(asgHandle);
            });
    }

    context.DetachResource(resource);
}

int VirtioGpuFrontend::getResourceInfo(uint32_t resourceId,
                                       struct stream_renderer_resource_info* info) {
    D("resource: %u", resourceId);

    if (!info) {
        GFXSTREAM_ERROR("Failed to get info: invalid info struct.");
        return EINVAL;
    }

    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR("Failed to get info: failed to find resource %d.", resourceId);
        return ENOENT;
    }
    auto& resource = resourceIt->second;
    return resource.GetInfo(info);
}

void VirtioGpuFrontend::flushResource(uint32_t res_handle) {
    auto taskId = mVirtioGpuTimelines->enqueueTask(VirtioGpuRingGlobal{});
    FrameBuffer::getFB()->postWithCallback(res_handle,
                                           [this, taskId](std::shared_future<void> waitForGpu) {
                                               waitForGpu.wait();
                                               mVirtioGpuTimelines->notifyTaskCompletion(taskId);
                                           });
}

int VirtioGpuFrontend::createBlob(uint32_t contextId, uint32_t resourceId,
                                  const struct stream_renderer_create_blob* createBlobArgs,
                                  const struct stream_renderer_handle* handle) {
    auto contextIt = mContexts.find(contextId);
    if (contextIt == mContexts.end()) {
        GFXSTREAM_ERROR("failed to create blob resource %u: context %u missing.", resourceId,
                        contextId);
        return -EINVAL;
    }
    auto& context = contextIt->second;

    auto createArgs = context.TakePendingBlob(createBlobArgs->blob_id);
    if (createArgs) {
        createArgs->handle = resourceId;
    }

    auto resourceOpt =
        VirtioGpuResource::Create(mFeatures, mPageSize, contextId, resourceId,
                                  createArgs ? &*createArgs : nullptr, createBlobArgs, handle);
    if (!resourceOpt) {
        GFXSTREAM_ERROR("failed to create blob resource %u.", resourceId);
        return -EINVAL;
    }
    mResources[resourceId] = std::move(*resourceOpt);
    return 0;
}

int VirtioGpuFrontend::resourceMap(uint32_t resourceId, void** hvaOut, uint64_t* sizeOut) {
    D("resource: %u", resourceId);

    if (mFeatures.ExternalBlob.enabled()) {
        GFXSTREAM_ERROR("Failed to map resource: external blob enabled.");
        return -EINVAL;
    }

    auto it = mResources.find(resourceId);
    if (it == mResources.end()) {
        if (hvaOut) *hvaOut = nullptr;
        if (sizeOut) *sizeOut = 0;

        GFXSTREAM_ERROR("Failed to map resource: unknown resource id %d.", resourceId);
        return -EINVAL;
    }

    auto& resource = it->second;
    return resource.Map(hvaOut, sizeOut);
}

int VirtioGpuFrontend::resourceUnmap(uint32_t resourceId) {
    D("resource: %u", resourceId);

    auto it = mResources.find(resourceId);
    if (it == mResources.end()) {
        GFXSTREAM_ERROR("Failed to map resource: unknown resource id %d.", resourceId);
        return -EINVAL;
    }

    // TODO(lfy): Good place to run any registered cleanup callbacks.
    // No-op for now.
    return 0;
}

void* VirtioGpuFrontend::platformCreateSharedEglContext() {
    void* ptr = nullptr;
#if GFXSTREAM_ENABLE_HOST_GLES
    ptr = FrameBuffer::getFB()->platformCreateSharedEglContext();
#endif
    return ptr;
}

int VirtioGpuFrontend::platformDestroySharedEglContext(void* context) {
    bool success = false;
#if GFXSTREAM_ENABLE_HOST_GLES
    success = FrameBuffer::getFB()->platformDestroySharedEglContext(context);
#endif
    return success ? 0 : -1;
}

int VirtioGpuFrontend::resourceMapInfo(uint32_t resourceId, uint32_t* map_info) {
    D("resource: %u", resourceId);

    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR("Failed to get resource map info: unknown resource %d.", resourceId);
        return -EINVAL;
    }

    const auto& resource = resourceIt->second;
    return resource.GetCaching(map_info);
}

int VirtioGpuFrontend::exportBlob(uint32_t resourceId, struct stream_renderer_handle* handle) {
    D("resource: %u", resourceId);

    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR("Failed to export blob: unknown resource %d.", resourceId);
        return -EINVAL;
    }
    auto& resource = resourceIt->second;
    return resource.ExportBlob(handle);
}

int VirtioGpuFrontend::exportFence(uint64_t fenceId, struct stream_renderer_handle* handle) {
    auto syncIt = mSyncMap.find(fenceId);
    if (syncIt == mSyncMap.end()) {
        return -EINVAL;
    }
    auto& sync = syncIt->second;

    auto rawDescriptorOpt = sync->descriptor.release();
    if (!rawDescriptorOpt) {
        return -EINVAL;
    }

    DescriptorType rawDescriptor = *rawDescriptorOpt;

    handle->handle_type = sync->streamHandleType;

#ifdef _WIN32
    handle->os_handle = static_cast<int64_t>(reinterpret_cast<intptr_t>(rawDescriptor));
#else
    handle->os_handle = static_cast<int64_t>(rawDescriptor);
#endif

    mSyncMap.erase(syncIt);

    return 0;
}

int VirtioGpuFrontend::vulkanInfo(uint32_t resourceId,
                                  struct stream_renderer_vulkan_info* vulkanInfo) {
    auto resourceIt = mResources.find(resourceId);
    if (resourceIt == mResources.end()) {
        GFXSTREAM_ERROR("failed to get vulkan info: failed to find resource %d", resourceId);
        return -EINVAL;
    }
    auto& resource = resourceIt->second;
    return resource.GetVulkanInfo(vulkanInfo);
}

int VirtioGpuFrontend::destroyVirtioGpuObjects() {
    {
        std::vector<VirtioGpuResourceId> resourceIds;
        resourceIds.reserve(mResources.size());
        for (auto& [resourceId, resource] : mResources) {
            const auto contextIds = resource.GetAttachedContexts();
            for (const VirtioGpuContextId contextId : contextIds) {
                detachResource(contextId, resourceId);
            }
            resourceIds.push_back(resourceId);
        }
        for (const VirtioGpuResourceId resourceId : resourceIds) {
            unrefResource(resourceId);
        }
        mResources.clear();
    }
    {
        std::vector<VirtioGpuContextId> contextIds;
        contextIds.reserve(mContexts.size());
        for (const auto& [contextId, _] : mContexts) {