From bf6dbb642ab9f35e849f72ba5b5c367499bf3c76 Mon Sep 17 00:00:00 2001 From: ahmad Date: Fri, 9 Oct 2026 23:02:25 +0300 Subject: [PATCH] feat(vkbridge): emulation layer + VK_KHR_maintenance5 for drivers without it Zink (Mesa 26.2) and DXVK 2.7 refuse a Vulkan 1.3 device without maintenance5. The server installs dispatch-table wrappers: flags2 folded into 32-bit flags, inline shader modules, BindIndexBuffer2/area granularity/subresource layout 2, VK_REMAINING_ARRAY_LAYERS and VK_WHOLE_SIZE resolved from tracked images/buffers. Host: Zink glxgears in gamescope at 144 fps with the driver's maintenance5 hidden and the API capped at 1.3. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01KZqR8XUE8czvGzEpgSCVQR --- app/src/main/cpp/vkbridge/server_emu.c | 28 +- app/src/main/cpp/vkbridge/server_emu.h | 49 +- .../main/cpp/vkbridge/server_emu_features.c | 31 ++ app/src/main/cpp/vkbridge/server_emu_layer.c | 435 +++++++++++++++++- tools/vkbridge/client/emu.c | 12 +- tools/vkbridge/common/vkb_proto.h | 1 + tools/vkbridge/host/gamescope_test.sh | 2 +- 7 files changed, 535 insertions(+), 23 deletions(-) create mode 100644 app/src/main/cpp/vkbridge/server_emu_features.c diff --git a/app/src/main/cpp/vkbridge/server_emu.c b/app/src/main/cpp/vkbridge/server_emu.c index 02474ec20..7a1961b8c 100644 --- a/app/src/main/cpp/vkbridge/server_emu.c +++ b/app/src/main/cpp/vkbridge/server_emu.c @@ -11,6 +11,14 @@ #include #include +static int token(const char *list, const char *t) +{ + size_t n = strlen(t); + for (const char *p = list; p && (p = strstr(p, t)); p += n) + if ((p == list || p[-1] == ',') && (p[n] == ',' || p[n] == 0)) return 1; + return 0; +} + static int env_off(const char *name) { const char *v = getenv(name); @@ -25,24 +33,31 @@ uint32_t vkb_emu_detect(const vkb_dispatch *idt, VkPhysicalDevice pd) idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, NULL); VkExtensionProperties *e = calloc(n ? n : 1, sizeof(*e)); idt->vkEnumerateDeviceExtensionProperties(pd, NULL, &n, e); - int divisor = 0, depth_clip = 0; + int divisor = 0, depth_clip = 0, maint5 = 0; for (uint32_t i = 0; i < n; i++) { if (!strcmp(e[i].extensionName, "VK_EXT_vertex_attribute_divisor") || !strcmp(e[i].extensionName, "VK_KHR_vertex_attribute_divisor")) divisor = 1; if (!strcmp(e[i].extensionName, "VK_EXT_depth_clip_enable")) depth_clip = 1; + if (!strcmp(e[i].extensionName, "VK_KHR_maintenance5")) maint5 = 1; } free(e); /* VKBRIDGE_FAKE_MISSING=bc,divisor,clip,cull,depthclip pretends the GPU lacks them (host tests). */ const char *fake = getenv("VKBRIDGE_FAKE_MISSING"); if (fake) { - if (strstr(fake, "bc")) f.textureCompressionBC = VK_FALSE; - if (strstr(fake, "divisor")) divisor = 0; - if (strstr(fake, "clip")) f.shaderClipDistance = VK_FALSE; - if (strstr(fake, "cull")) f.shaderCullDistance = VK_FALSE; - if (strstr(fake, "depthclip")) depth_clip = 0; + if (token(fake, "bc")) f.textureCompressionBC = VK_FALSE; + if (token(fake, "divisor")) divisor = 0; + if (token(fake, "clip")) f.shaderClipDistance = VK_FALSE; + if (token(fake, "cull")) f.shaderCullDistance = VK_FALSE; + if (token(fake, "depthclip")) depth_clip = 0; + if (token(fake, "maint5")) maint5 = 0; } uint32_t emu = 0; + VkPhysicalDeviceProperties props; + idt->vkGetPhysicalDeviceProperties(pd, &props); + /* Vulkan 1.4 has maintenance5 in core. */ + if (!maint5 && (props.apiVersion < VK_API_VERSION_1_4 || (fake && token(fake, "maint5"))) && !env_off("VKBRIDGE_EMU_MAINT5")) + emu |= VKB_EMU_MAINT5; if (!f.textureCompressionBC && vkb_emu_bcn_supported(idt, pd) && !env_off("VKBRIDGE_EMU_BCN")) emu |= VKB_EMU_BCN; if (!divisor && !env_off("VKBRIDGE_EMU_DIVISOR")) emu |= VKB_EMU_DIVISOR; if (!f.shaderClipDistance && !env_off("VKBRIDGE_EMU_CLIP")) emu |= VKB_EMU_CLIP_DISTANCE; @@ -87,6 +102,7 @@ void vkb_emu_device_create_info(vkb_srv_table *inst, VkPhysicalDevice pd, uint32 } if (emu & VKB_EMU_DIVISOR) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT); if (emu & VKB_EMU_DEPTH_CLIP) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT); + if (emu & VKB_EMU_MAINT5) chain_remove(ci, VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES); (void)a; } diff --git a/app/src/main/cpp/vkbridge/server_emu.h b/app/src/main/cpp/vkbridge/server_emu.h index 24395e817..a10d6eda3 100644 --- a/app/src/main/cpp/vkbridge/server_emu.h +++ b/app/src/main/cpp/vkbridge/server_emu.h @@ -5,20 +5,59 @@ #include "vkb_server.h" /* Emulations that are implemented (the rest are never offered to the client). */ -#ifndef VKB_EMU_IMPLEMENTED -#define VKB_EMU_IMPLEMENTED 0u -#endif +#define VKB_EMU_IMPLEMENTED (VKB_EMU_MAINT5) + +#define VKB_EMU_BUCKETS 1024 + +typedef struct vkb_emu_image { + VkImage image; + VkImageType type; + VkFormat format; /* what the driver holds */ + VkFormat client_format; /* what the app asked for (differs for emulated formats) */ + VkExtent3D extent; + uint32_t mips, layers; + void *emu; /* per-emulation state (BCn: decode resources) */ + struct vkb_emu_image *next; +} vkb_emu_image; + +typedef struct vkb_emu_buffer { + VkBuffer buffer; + VkDeviceSize size; + struct vkb_emu_buffer *next; +} vkb_emu_buffer; typedef struct vkb_emu_device { uint32_t flags; vkb_srv_table *dev; pthread_mutex_t lock; - void *bcn; /* server_emu_bcn.c state */ - void *shaders; /* server_emu_shader.c state */ + vkb_emu_image *images[VKB_EMU_BUCKETS]; + vkb_emu_buffer *buffers[VKB_EMU_BUCKETS]; + void *bcn; /* server_emu_bcn.c */ + void *shaders; /* server_emu_shader.c */ } vkb_emu_device; +/* layer (server_emu_layer.c) */ +vkb_emu_device *vkb_emu_cur(void); +const vkb_dispatch *vkb_emu_real(void); +void *vkb_emu_chain_take(const void *head, VkStructureType t); +vkb_emu_image *vkb_emu_find_image(vkb_emu_device *e, VkImage img); +void vkb_emu_track_image(vkb_emu_device *e, VkImage img, const VkImageCreateInfo *ci, VkFormat client_format); + +/* feature hooks (server_emu_features.c and friends) */ int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd); void vkb_emu_install(vkb_srv_table *dev); void vkb_emu_uninstall(vkb_srv_table *dev); +void vkb_emu_install_features(vkb_srv_table *dev); +void vkb_emu_uninstall_features(vkb_srv_table *dev); +void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci); +void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img); +void vkb_emu_graphics_pipeline_info(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci); +/* 1 = handled (the emulation recorded its own commands instead). */ +int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, + uint32_t n, const VkImageCopy *regions); +int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info); +int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n, + const VkBufferImageCopy *regions); +int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info); #endif diff --git a/app/src/main/cpp/vkbridge/server_emu_features.c b/app/src/main/cpp/vkbridge/server_emu_features.c new file mode 100644 index 000000000..90be0cd2b --- /dev/null +++ b/app/src/main/cpp/vkbridge/server_emu_features.c @@ -0,0 +1,31 @@ +/* SPDX-License-Identifier: GPL-3.0-or-later + * + * Hooks of the feature emulations that are not implemented yet: everything passes through. + */ +#define _GNU_SOURCE +#include "server_emu.h" + +int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd) { (void)idt; (void)pd; return 0; } +void vkb_emu_install_features(vkb_srv_table *dev) { (void)dev; } +void vkb_emu_uninstall_features(vkb_srv_table *dev) { (void)dev; } +void vkb_emu_image_create_info(vkb_emu_device *e, VkImageCreateInfo *ci) { (void)e; (void)ci; } +void vkb_emu_image_release(vkb_emu_device *e, vkb_emu_image *img) { (void)e; (void)img; } +void vkb_emu_graphics_pipeline_info(vkb_emu_device *e, VkGraphicsPipelineCreateInfo *ci) { (void)e; (void)ci; } +int vkb_emu_copy_image(vkb_emu_device *e, VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, + uint32_t n, const VkImageCopy *regions) +{ + (void)e; (void)cb; (void)src; (void)sl; (void)dst; (void)dl; (void)n; (void)regions; + return 0; +} +int vkb_emu_copy_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyImageInfo2 *info) { (void)e; (void)cb; (void)info; return 0; } +int vkb_emu_copy_buffer_to_image(vkb_emu_device *e, VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n, + const VkBufferImageCopy *regions) +{ + (void)e; (void)cb; (void)src; (void)dst; (void)dl; (void)n; (void)regions; + return 0; +} +int vkb_emu_copy_buffer_to_image2(vkb_emu_device *e, VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info) +{ + (void)e; (void)cb; (void)info; + return 0; +} diff --git a/app/src/main/cpp/vkbridge/server_emu_layer.c b/app/src/main/cpp/vkbridge/server_emu_layer.c index d453d69a6..94732828e 100644 --- a/app/src/main/cpp/vkbridge/server_emu_layer.c +++ b/app/src/main/cpp/vkbridge/server_emu_layer.c @@ -1,23 +1,444 @@ /* SPDX-License-Identifier: GPL-3.0-or-later * - * Emulation wrappers installed into a device's dispatch table. + * Emulation wrappers installed into a device's dispatch table, like a Vulkan layer: the generated + * handlers call c->dt, which for an emulating device points here first. The device is found + * through the per-call table the connection loop sets (vkb_srv_current_table). + * + * VK_KHR_maintenance5 (Zink and DXVK 2.7 refuse a Vulkan 1.3 device without it): + * - 64-bit flags structures (pipeline create flags 2, buffer usage 2) folded into the 32-bit + * fields, which hold every bit a 1.3 driver knows; + * - shader modules given inline (VkShaderModuleCreateInfo chained to a stage) created and + * destroyed around the pipeline; + * - vkCmdBindIndexBuffer2, vkGetRenderingAreaGranularity, vkGetImageSubresourceLayout2 and + * vkGetDeviceImageSubresourceLayout on their 1.0 equivalents; + * - VK_REMAINING_ARRAY_LAYERS in copy regions and VK_WHOLE_SIZE in vertex buffer sizes, resolved + * from the image/buffer the server keeps a record of. */ #define _GNU_SOURCE #include "server_emu.h" -int vkb_emu_bcn_supported(const vkb_dispatch *idt, VkPhysicalDevice pd) +#include +#include + +/* ------------------------------------------------------------------ resource records */ + +static unsigned rh(uint64_t k) { - (void)idt; - (void)pd; - return 0; + k ^= k >> 29; + k *= 0xbf58476d1ce4e5b9ull; + return (unsigned)(k >> 52) & (VKB_EMU_BUCKETS - 1); } +void vkb_emu_track_image(vkb_emu_device *e, VkImage img, const VkImageCreateInfo *ci, VkFormat client_format) +{ + vkb_emu_image *r = calloc(1, sizeof(*r)); + r->image = img; + r->type = ci->imageType; + r->format = ci->format; + r->client_format = client_format; + r->extent = ci->extent; + r->mips = ci->mipLevels; + r->layers = ci->arrayLayers; + pthread_mutex_lock(&e->lock); + unsigned h = rh((uint64_t)img); + r->next = e->images[h]; + e->images[h] = r; + pthread_mutex_unlock(&e->lock); +} + +vkb_emu_image *vkb_emu_find_image(vkb_emu_device *e, VkImage img) +{ + pthread_mutex_lock(&e->lock); + vkb_emu_image *r = e->images[rh((uint64_t)img)]; + while (r && r->image != img) r = r->next; + pthread_mutex_unlock(&e->lock); + return r; +} + +static void untrack_image(vkb_emu_device *e, VkImage img) +{ + pthread_mutex_lock(&e->lock); + vkb_emu_image **pp = &e->images[rh((uint64_t)img)]; + while (*pp && (*pp)->image != img) pp = &(*pp)->next; + vkb_emu_image *r = *pp; + if (r) *pp = r->next; + pthread_mutex_unlock(&e->lock); + if (r) { + vkb_emu_image_release(e, r); + free(r); + } +} + +static void track_buffer(vkb_emu_device *e, VkBuffer b, VkDeviceSize size) +{ + vkb_emu_buffer *r = calloc(1, sizeof(*r)); + r->buffer = b; + r->size = size; + pthread_mutex_lock(&e->lock); + unsigned h = rh((uint64_t)b); + r->next = e->buffers[h]; + e->buffers[h] = r; + pthread_mutex_unlock(&e->lock); +} + +static VkDeviceSize buffer_size(vkb_emu_device *e, VkBuffer b) +{ + pthread_mutex_lock(&e->lock); + vkb_emu_buffer *r = e->buffers[rh((uint64_t)b)]; + while (r && r->buffer != b) r = r->next; + VkDeviceSize s = r ? r->size : 0; + pthread_mutex_unlock(&e->lock); + return s; +} + +static void untrack_buffer(vkb_emu_device *e, VkBuffer b) +{ + pthread_mutex_lock(&e->lock); + vkb_emu_buffer **pp = &e->buffers[rh((uint64_t)b)]; + while (*pp && (*pp)->buffer != b) pp = &(*pp)->next; + vkb_emu_buffer *r = *pp; + if (r) *pp = r->next; + pthread_mutex_unlock(&e->lock); + free(r); +} + +vkb_emu_device *vkb_emu_cur(void) +{ + vkb_srv_table *t = vkb_srv_current_table(); + return t ? t->emu : NULL; +} + +const vkb_dispatch *vkb_emu_real(void) +{ + return &vkb_srv_current_table()->real; +} + +/* Removes the first structure of type t from a chain we own (decoded into the call's arena). */ +void *vkb_emu_chain_take(const void *head_const, VkStructureType t) +{ + VkBaseOutStructure *prev = (VkBaseOutStructure *)head_const; + while (prev->pNext) { + if (prev->pNext->sType == t) { + VkBaseOutStructure *found = prev->pNext; + prev->pNext = found->pNext; + return found; + } + prev = prev->pNext; + } + return NULL; +} + +/* ------------------------------------------------------------------ resources */ + +static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) +{ + vkb_emu_device *e = vkb_emu_cur(); + VkBufferCreateInfo *ci = (VkBufferCreateInfo *)pCreateInfo; + if (e->flags & VKB_EMU_MAINT5) { + VkBufferUsageFlags2CreateInfo *u = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO); + if (u) ci->usage = (VkBufferUsageFlags)u->usage; + } + VkResult r = vkb_emu_real()->vkCreateBuffer(device, ci, pAllocator, pBuffer); + if (r == VK_SUCCESS) track_buffer(e, *pBuffer, ci->size); + return r; +} + +static VKAPI_ATTR void VKAPI_CALL emu_DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *pAllocator) +{ + if (buffer) untrack_buffer(vkb_emu_cur(), buffer); + vkb_emu_real()->vkDestroyBuffer(device, buffer, pAllocator); +} + +static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkBufferView *pView) +{ + if (vkb_emu_cur()->flags & VKB_EMU_MAINT5) vkb_emu_chain_take(pCreateInfo, VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO); + return vkb_emu_real()->vkCreateBufferView(device, pCreateInfo, pAllocator, pView); +} + +static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, + const VkAllocationCallbacks *pAllocator, VkImage *pImage) +{ + vkb_emu_device *e = vkb_emu_cur(); + VkImageCreateInfo *ci = (VkImageCreateInfo *)pCreateInfo; + VkFormat client_format = ci->format; + vkb_emu_image_create_info(e, ci); + VkResult r = vkb_emu_real()->vkCreateImage(device, ci, pAllocator, pImage); + if (r == VK_SUCCESS) vkb_emu_track_image(e, *pImage, ci, client_format); + return r; +} + +static VKAPI_ATTR void VKAPI_CALL emu_DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *pAllocator) +{ + if (image) untrack_image(vkb_emu_cur(), image); + vkb_emu_real()->vkDestroyImage(device, image, pAllocator); +} + +/* ------------------------------------------------------------------ pipelines */ + +/* Fold flags2 and create inline shader modules; temporaries are recorded in mods[]. */ +static void prep_stage(VkDevice device, VkPipelineShaderStageCreateInfo *st, VkShaderModule *mods, uint32_t *nmods, uint32_t cap) +{ + if (st->module) return; + VkShaderModuleCreateInfo *smci = vkb_emu_chain_take(st, VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO); + if (!smci) return; + VkShaderModule m = VK_NULL_HANDLE; + smci->pNext = NULL; + if (vkb_emu_real()->vkCreateShaderModule(device, smci, NULL, &m) == VK_SUCCESS) { + st->module = m; + if (*nmods < cap) mods[(*nmods)++] = m; + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t n, + const VkGraphicsPipelineCreateInfo *infos, + const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) +{ + vkb_emu_device *e = vkb_emu_cur(); + VkShaderModule mods[64]; + uint32_t nmods = 0; + for (uint32_t i = 0; i < n; i++) { + VkGraphicsPipelineCreateInfo *ci = (VkGraphicsPipelineCreateInfo *)&infos[i]; + if (e->flags & VKB_EMU_MAINT5) { + VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO); + if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags; + for (uint32_t s = 0; s < ci->stageCount; s++) + prep_stage(device, (VkPipelineShaderStageCreateInfo *)&ci->pStages[s], mods, &nmods, 64); + } + vkb_emu_graphics_pipeline_info(e, ci); + } + VkResult r = vkb_emu_real()->vkCreateGraphicsPipelines(device, cache, n, infos, pAllocator, pPipelines); + for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL); + return r; +} + +static VKAPI_ATTR VkResult VKAPI_CALL emu_CreateComputePipelines(VkDevice device, VkPipelineCache cache, uint32_t n, + const VkComputePipelineCreateInfo *infos, + const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) +{ + vkb_emu_device *e = vkb_emu_cur(); + VkShaderModule mods[64]; + uint32_t nmods = 0; + for (uint32_t i = 0; i < n; i++) { + VkComputePipelineCreateInfo *ci = (VkComputePipelineCreateInfo *)&infos[i]; + if (e->flags & VKB_EMU_MAINT5) { + VkPipelineCreateFlags2CreateInfo *f2 = vkb_emu_chain_take(ci, VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO); + if (f2) ci->flags = (VkPipelineCreateFlags)f2->flags; + prep_stage(device, &ci->stage, mods, &nmods, 64); + } + } + VkResult r = vkb_emu_real()->vkCreateComputePipelines(device, cache, n, infos, pAllocator, pPipelines); + for (uint32_t i = 0; i < nmods; i++) vkb_emu_real()->vkDestroyShaderModule(device, mods[i], NULL); + return r; +} + +/* ------------------------------------------------------------------ maintenance5 entry points */ + +static VKAPI_ATTR void VKAPI_CALL emu_CmdBindIndexBuffer2(VkCommandBuffer cb, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, + VkIndexType type) +{ + (void)size; + vkb_emu_real()->vkCmdBindIndexBuffer(cb, buffer, offset, type); +} + +static VKAPI_ATTR void VKAPI_CALL emu_GetRenderingAreaGranularity(VkDevice device, const VkRenderingAreaInfo *info, VkExtent2D *g) +{ + (void)device; + (void)info; + g->width = 1; + g->height = 1; +} + +static VKAPI_ATTR void VKAPI_CALL emu_GetImageSubresourceLayout2(VkDevice device, VkImage image, const VkImageSubresource2 *sub, + VkSubresourceLayout2 *layout) +{ + vkb_emu_real()->vkGetImageSubresourceLayout(device, image, &sub->imageSubresource, &layout->subresourceLayout); +} + +static VKAPI_ATTR void VKAPI_CALL emu_GetDeviceImageSubresourceLayout(VkDevice device, const VkDeviceImageSubresourceInfo *info, + VkSubresourceLayout2 *layout) +{ + VkImage img; + memset(&layout->subresourceLayout, 0, sizeof(layout->subresourceLayout)); + if (vkb_emu_real()->vkCreateImage(device, info->pCreateInfo, NULL, &img) != VK_SUCCESS) return; + vkb_emu_real()->vkGetImageSubresourceLayout(device, img, &info->pSubresource->imageSubresource, &layout->subresourceLayout); + vkb_emu_real()->vkDestroyImage(device, img, NULL); +} + +/* VK_REMAINING_ARRAY_LAYERS in a copy region, resolved against the image. */ +static void fix_layers(vkb_emu_device *e, VkImage img, VkImageSubresourceLayers *l) +{ + if (l->layerCount != VK_REMAINING_ARRAY_LAYERS) return; + vkb_emu_image *r = vkb_emu_find_image(e, img); + l->layerCount = r && r->layers > l->baseArrayLayer ? r->layers - l->baseArrayLayer : 1; +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, + uint32_t n, const VkImageCopy *regions) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < n; i++) { + fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].srcSubresource); + fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].dstSubresource); + } + if (vkb_emu_copy_image(e, cb, src, sl, dst, dl, n, regions)) return; + vkb_emu_real()->vkCmdCopyImage(cb, src, sl, dst, dl, n, regions); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImage2(VkCommandBuffer cb, const VkCopyImageInfo2 *info) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < info->regionCount; i++) { + fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource); + fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource); + } + if (vkb_emu_copy_image2(e, cb, info)) return; + vkb_emu_real()->vkCmdCopyImage2(cb, info); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdBlitImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, + uint32_t n, const VkImageBlit *regions, VkFilter filter) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < n; i++) { + fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].srcSubresource); + fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].dstSubresource); + } + vkb_emu_real()->vkCmdBlitImage(cb, src, sl, dst, dl, n, regions, filter); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdBlitImage2(VkCommandBuffer cb, const VkBlitImageInfo2 *info) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < info->regionCount; i++) { + fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource); + fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource); + } + vkb_emu_real()->vkCmdBlitImage2(cb, info); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdResolveImage(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkImage dst, VkImageLayout dl, + uint32_t n, const VkImageResolve *regions) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < n; i++) { + fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].srcSubresource); + fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].dstSubresource); + } + vkb_emu_real()->vkCmdResolveImage(cb, src, sl, dst, dl, n, regions); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdResolveImage2(VkCommandBuffer cb, const VkResolveImageInfo2 *info) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < info->regionCount; i++) { + fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].srcSubresource); + fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].dstSubresource); + } + vkb_emu_real()->vkCmdResolveImage2(cb, info); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyBufferToImage(VkCommandBuffer cb, VkBuffer src, VkImage dst, VkImageLayout dl, uint32_t n, + const VkBufferImageCopy *regions) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < n; i++) fix_layers(e, dst, (VkImageSubresourceLayers *)®ions[i].imageSubresource); + if (vkb_emu_copy_buffer_to_image(e, cb, src, dst, dl, n, regions)) return; + vkb_emu_real()->vkCmdCopyBufferToImage(cb, src, dst, dl, n, regions); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyBufferToImage2(VkCommandBuffer cb, const VkCopyBufferToImageInfo2 *info) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < info->regionCount; i++) + fix_layers(e, info->dstImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource); + if (vkb_emu_copy_buffer_to_image2(e, cb, info)) return; + vkb_emu_real()->vkCmdCopyBufferToImage2(cb, info); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer(VkCommandBuffer cb, VkImage src, VkImageLayout sl, VkBuffer dst, uint32_t n, + const VkBufferImageCopy *regions) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < n; i++) fix_layers(e, src, (VkImageSubresourceLayers *)®ions[i].imageSubresource); + vkb_emu_real()->vkCmdCopyImageToBuffer(cb, src, sl, dst, n, regions); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdCopyImageToBuffer2(VkCommandBuffer cb, const VkCopyImageToBufferInfo2 *info) +{ + vkb_emu_device *e = vkb_emu_cur(); + for (uint32_t i = 0; i < info->regionCount; i++) + fix_layers(e, info->srcImage, (VkImageSubresourceLayers *)&info->pRegions[i].imageSubresource); + vkb_emu_real()->vkCmdCopyImageToBuffer2(cb, info); +} + +static VKAPI_ATTR void VKAPI_CALL emu_CmdBindVertexBuffers2(VkCommandBuffer cb, uint32_t first, uint32_t n, const VkBuffer *buffers, + const VkDeviceSize *offsets, const VkDeviceSize *sizes, + const VkDeviceSize *strides) +{ + vkb_emu_device *e = vkb_emu_cur(); + if (sizes) { + VkDeviceSize *s = (VkDeviceSize *)sizes; + for (uint32_t i = 0; i < n; i++) { + if (s[i] != VK_WHOLE_SIZE || !buffers[i]) continue; + VkDeviceSize total = buffer_size(e, buffers[i]); + s[i] = total > offsets[i] ? total - offsets[i] : 0; + } + } + vkb_emu_real()->vkCmdBindVertexBuffers2(cb, first, n, buffers, offsets, sizes, strides); +} + +/* ------------------------------------------------------------------ install */ + void vkb_emu_install(vkb_srv_table *dev) { - (void)dev; + vkb_emu_device *e = dev->emu; + vkb_dispatch *dt = &dev->dt; + /* Resource records are needed by every emulation. */ + dt->vkCreateBuffer = emu_CreateBuffer; + dt->vkDestroyBuffer = emu_DestroyBuffer; + dt->vkCreateImage = emu_CreateImage; + dt->vkDestroyImage = emu_DestroyImage; + dt->vkCreateGraphicsPipelines = emu_CreateGraphicsPipelines; + dt->vkCreateComputePipelines = emu_CreateComputePipelines; + dt->vkCmdCopyImage = emu_CmdCopyImage; + dt->vkCmdCopyBufferToImage = emu_CmdCopyBufferToImage; + if (dev->real.vkCmdCopyImage2) dt->vkCmdCopyImage2 = emu_CmdCopyImage2; + if (dev->real.vkCmdCopyBufferToImage2) dt->vkCmdCopyBufferToImage2 = emu_CmdCopyBufferToImage2; + if (e->flags & VKB_EMU_MAINT5) { + dt->vkCreateBufferView = emu_CreateBufferView; + dt->vkCmdBindIndexBuffer2 = emu_CmdBindIndexBuffer2; + dt->vkGetRenderingAreaGranularity = emu_GetRenderingAreaGranularity; + dt->vkGetImageSubresourceLayout2 = emu_GetImageSubresourceLayout2; + dt->vkGetDeviceImageSubresourceLayout = emu_GetDeviceImageSubresourceLayout; + dt->vkCmdBlitImage = emu_CmdBlitImage; + dt->vkCmdResolveImage = emu_CmdResolveImage; + dt->vkCmdCopyImageToBuffer = emu_CmdCopyImageToBuffer; + if (dev->real.vkCmdBlitImage2) dt->vkCmdBlitImage2 = emu_CmdBlitImage2; + if (dev->real.vkCmdResolveImage2) dt->vkCmdResolveImage2 = emu_CmdResolveImage2; + if (dev->real.vkCmdCopyImageToBuffer2) dt->vkCmdCopyImageToBuffer2 = emu_CmdCopyImageToBuffer2; + if (dev->real.vkCmdBindVertexBuffers2) dt->vkCmdBindVertexBuffers2 = emu_CmdBindVertexBuffers2; + } + vkb_emu_install_features(dev); + VKB_INFO("device %u: emulation 0x%x installed", dev->id, e->flags); } void vkb_emu_uninstall(vkb_srv_table *dev) { - (void)dev; + vkb_emu_device *e = dev->emu; + vkb_emu_uninstall_features(dev); + for (int i = 0; i < VKB_EMU_BUCKETS; i++) { + while (e->images[i]) { + vkb_emu_image *r = e->images[i]; + e->images[i] = r->next; + vkb_emu_image_release(e, r); + free(r); + } + while (e->buffers[i]) { + vkb_emu_buffer *r = e->buffers[i]; + e->buffers[i] = r->next; + free(r); + } + } } diff --git a/tools/vkbridge/client/emu.c b/tools/vkbridge/client/emu.c index f892cadda..90ca1594b 100644 --- a/tools/vkbridge/client/emu.c +++ b/tools/vkbridge/client/emu.c @@ -7,9 +7,12 @@ const VkExtensionProperties *vkb_emu_extensions(vkb_physdev *pd, uint32_t *n) { - (void)pd; - *n = 0; - return NULL; + static const VkExtensionProperties maint5 = {"VK_KHR_maintenance5", 1}; + static __thread VkExtensionProperties list[8]; + uint32_t c = 0; + if (pd->info.emu & VKB_EMU_MAINT5) list[c++] = maint5; + *n = c; + return list; } void vkb_emu_patch_limits(vkb_physdev *pd, VkPhysicalDeviceProperties *p) { (void)pd; (void)p; } @@ -17,7 +20,8 @@ void vkb_emu_patch_properties_chain(vkb_physdev *pd, VkBaseOutStructure *b) { (v void vkb_emu_patch_features(vkb_physdev *pd, VkPhysicalDeviceFeatures *f) { (void)pd; (void)f; } void vkb_emu_patch_features_chain(vkb_physdev *pd, VkBaseOutStructure *b) { - (void)pd; + if ((pd->info.emu & VKB_EMU_MAINT5) && b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES) + ((VkPhysicalDeviceMaintenance5Features *)b)->maintenance5 = VK_TRUE; /* Host image copy hands the driver host pointers: never offered across the bridge. */ if (b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES) ((VkPhysicalDeviceVulkan14Features *)b)->hostImageCopy = VK_FALSE; if (b->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES) ((VkPhysicalDeviceHostImageCopyFeatures *)b)->hostImageCopy = VK_FALSE; diff --git a/tools/vkbridge/common/vkb_proto.h b/tools/vkbridge/common/vkb_proto.h index 375e2f2e5..0fe0d8358 100644 --- a/tools/vkbridge/common/vkb_proto.h +++ b/tools/vkbridge/common/vkb_proto.h @@ -34,6 +34,7 @@ static inline const char *vkb_mem_strategy_name(uint32_t s) #define VKB_EMU_CULL_DISTANCE (1u << 3) /* shaderCullDistance (accepted, not applied) */ #define VKB_EMU_POINT_SIZE (1u << 4) /* strip PointSize from geometry/tessellation stages */ #define VKB_EMU_DEPTH_CLIP (1u << 5) /* VK_EXT_depth_clip_enable via depthClamp */ +#define VKB_EMU_MAINT5 (1u << 6) /* VK_KHR_maintenance5 on a driver without it */ /* vkbQueryServer reply (per physical device). */ typedef struct vkb_server_pd_info { diff --git a/tools/vkbridge/host/gamescope_test.sh b/tools/vkbridge/host/gamescope_test.sh index 4bf9525f4..75879b0e6 100755 --- a/tools/vkbridge/host/gamescope_test.sh +++ b/tools/vkbridge/host/gamescope_test.sh @@ -9,5 +9,5 @@ exec docker run --rm ${VKB_DOCKER_EXTRA:-} --tmpfs /run/xdg:mode=0700 \ -e XDG_RUNTIME_DIR=/run/xdg -e WAYLAND_DISPLAY=host-wayland -e HOME=/root \ -v "$R/${WAYLAND_DISPLAY:-wayland-0}:/run/host-wayland" -v "$VKBRIDGE_SOCKET:/run/vkbridge.sock" \ -v "$host/out:$host/out" -v "$host/out/shots:/shots" -e VK_DRIVER_FILES=$host/out/vkbridge_icd.json -e VKBRIDGE_SOCKET=/run/vkbridge.sock \ - -e VKBRIDGE_DRM_RENDER=${VKBRIDGE_DRM_RENDER:-} -e VKBRIDGE_LOG_LEVEL=${VKBRIDGE_LOG_LEVEL:-2} -e VKBRIDGE_WSI_DUMP=${VKBRIDGE_WSI_DUMP:-} \ + -e VKBRIDGE_DRM_RENDER=${VKBRIDGE_DRM_RENDER:-} -e VKBRIDGE_HIDE_EXTS=${VKBRIDGE_HIDE_EXTS:-} -e VKBRIDGE_MAX_API=${VKBRIDGE_MAX_API:-} -e VKBRIDGE_LOG_LEVEL=${VKBRIDGE_LOG_LEVEL:-2} -e VKBRIDGE_WSI_DUMP=${VKBRIDGE_WSI_DUMP:-} \ vkb-arch-gamescope bash -c "ln -s /run/host-wayland /run/xdg/host-wayland; gamescope --backend wayland --expose-wayland -W 960 -H 540 -w 960 -h 540 -- $cmd"