Files
DroidDeck/tools/venus/layer/mali_compat.h
T
The412Banner b0c694d9e1 Non-Adreno round 8: bridge sharing fallback and crash detail, Venus diagnostics and 1.2 gate, compositor disconnect reasons, RADV upstream
- Mali bridge: the self-test fails "memory sharing" when the server offers
  no host-visible memory type (no sharing method passed, RP4 Pro G77); the
  session then falls back to the PanVK pair like a failed draw, and Setup
  says the bridge cannot share memory with that driver. Without a pair to
  fall back on, the log says so.
- Mali bridge: a guarded driver crash now logs the sub-command it was in,
  the fault address and pc (library + offset via dladdr), the command
  buffer's level, begin flags, pool flags and state, and the last 32
  replayed commands. Begin on an executable buffer from a pool without
  RESET_COMMAND_BUFFER_BIT is logged once (implicit reset).
- Venus: vulkan-summary.txt gets the device extension list and key
  features (full vulkaninfo in vulkan-full.txt); a failed GL probe runs
  once with VN_DEBUG=init,result, ZINK_DEBUG=mem, MESA_LOG_LEVEL=debug and
  the layer trace into glprobe-trace.txt. The Mali compatibility layer's
  trace covers every pre-device query (devices, memory, queue families,
  formats, image formats, external handles) and names the extensions.
- Venus: off when the phone's driver reports Vulkan below 1.2 (gamescope
  skips such a device); Setup and the graphics report say why and the
  session uses the PanVK pair.
- Compositor: libwayland's own disconnect reasons go to wayland.log, and a
  client's buffer may grow to 1 MB before a slow reader is dropped. A
  session that ended without teardown records Android's exit reasons.
- Drivers: RADV-Xclipse upstream (radv-xclipse-upstream) is a manual
  choice for Xclipse; Auto keeps radv-xclipse.
2026-10-15 18:53:40 -04:00

302 lines
17 KiB
C

/*
* VK_LAYER_DROIDDECK_mali_compat: makes up for what Mali lacks and DXVK requires.
*
* DXVK refuses any GPU without fillModeNonSolid, multiViewport, shaderClipDistance,
* shaderCullDistance, textureCompressionBC and robustBufferAccess2, and Mali has none of them.
* The layer reports each missing feature as supported, keeps it out of the driver's device, and
* handles what uses it: polygon modes draw filled, only the first viewport is kept, clip distances
* become a varying the fragment shader discards on, cull distances are dropped, and BC textures
* are decoded on the CPU into uncompressed images as they are uploaded.
*/
#ifndef MALI_COMPAT_H
#define MALI_COMPAT_H
#include <pthread.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <vulkan/vk_layer.h>
#include <vulkan/vulkan.h>
enum gap {
GAP_FILL_MODE = 1u << 0,
GAP_MULTI_VIEWPORT = 1u << 1,
GAP_CLIP_DISTANCE = 1u << 2,
GAP_CULL_DISTANCE = 1u << 3,
GAP_ROBUSTNESS2 = 1u << 4,
GAP_BC = 1u << 5,
/* draw.c and pipeline.c (added for Mali-G57 and drivers without these, on top of David Cimo's six) */
GAP_MULTI_DRAW = 1u << 6, /* multiDrawIndirect: indirect draws looped one by one */
GAP_DEPTH_CLIP = 1u << 7, /* VK_EXT_depth_clip_enable: depthClipEnable off becomes depth clamp */
GAP_NULL_DESCRIPTOR = 1u << 8, /* VK_EXT_robustness2 missing entirely: nullDescriptor stand-ins */
};
#define GAPS_SHADER (GAP_CLIP_DISTANCE | GAP_CULL_DISTANCE)
#define GAPS_PIPELINE (GAP_FILL_MODE | GAP_MULTI_VIEWPORT | GAPS_SHADER | GAP_DEPTH_CLIP)
void layer_log(const char *format, ...) __attribute__((format(printf, 1, 2)));
/* Open addressing from a Vulkan handle to a pointer. Not locked: the owner holds its lock. */
struct handle_map {
uint64_t *keys;
void **values;
uint32_t capacity;
uint32_t count;
};
void *map_get(const struct handle_map *map, uint64_t key);
void map_put(struct handle_map *map, uint64_t key, void *value);
void *map_remove(struct handle_map *map, uint64_t key);
void map_free(struct handle_map *map);
struct physical_device {
VkPhysicalDevice handle;
uint32_t gaps;
};
struct instance {
void *key;
VkInstance handle;
bool active;
PFN_vkGetInstanceProcAddr gipa;
PFN_vkDestroyInstance DestroyInstance;
PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
PFN_vkGetPhysicalDeviceFeatures GetPhysicalDeviceFeatures;
PFN_vkGetPhysicalDeviceFeatures2 GetPhysicalDeviceFeatures2;
PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2;
PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
PFN_vkGetPhysicalDeviceFormatProperties GetPhysicalDeviceFormatProperties;
PFN_vkGetPhysicalDeviceFormatProperties2 GetPhysicalDeviceFormatProperties2;
PFN_vkGetPhysicalDeviceImageFormatProperties GetPhysicalDeviceImageFormatProperties;
PFN_vkGetPhysicalDeviceImageFormatProperties2 GetPhysicalDeviceImageFormatProperties2;
PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
PFN_vkGetPhysicalDeviceMemoryProperties2 GetPhysicalDeviceMemoryProperties2;
PFN_vkGetPhysicalDeviceQueueFamilyProperties GetPhysicalDeviceQueueFamilyProperties;
PFN_vkGetPhysicalDeviceQueueFamilyProperties2 GetPhysicalDeviceQueueFamilyProperties2;
PFN_vkGetPhysicalDeviceExternalBufferProperties GetPhysicalDeviceExternalBufferProperties;
PFN_vkGetPhysicalDeviceExternalSemaphoreProperties GetPhysicalDeviceExternalSemaphoreProperties;
PFN_vkGetPhysicalDeviceExternalFenceProperties GetPhysicalDeviceExternalFenceProperties;
pthread_mutex_t lock;
struct physical_device physical_devices[8];
uint32_t physical_device_count;
struct instance *next;
};
#define DEVICE_FUNCTIONS(X) \
X(DestroyDevice) \
X(CreateShaderModule) \
X(DestroyShaderModule) \
X(CreateGraphicsPipelines) \
X(CmdSetViewport) \
X(CmdSetScissor) \
X(CmdSetViewportWithCount) \
X(CmdSetScissorWithCount) \
X(CreateImage) \
X(DestroyImage) \
X(CreateImageView) \
X(GetDeviceImageMemoryRequirements) \
X(GetDeviceImageSparseMemoryRequirements) \
X(GetDeviceImageSubresourceLayout) \
X(CmdCopyBufferToImage) \
X(CmdCopyBufferToImage2) \
X(CmdCopyImageToBuffer) \
X(CmdCopyImageToBuffer2) \
X(CmdCopyImage) \
X(CmdCopyImage2) \
X(CreateBuffer) \
X(DestroyBuffer) \
X(GetBufferMemoryRequirements) \
X(BindBufferMemory) \
X(BindBufferMemory2) \
X(AllocateMemory) \
X(FreeMemory) \
X(MapMemory) \
X(MapMemory2) \
X(UnmapMemory) \
X(UnmapMemory2) \
X(AllocateCommandBuffers) \
X(FreeCommandBuffers) \
X(BeginCommandBuffer) \
X(ResetCommandBuffer) \
X(ResetCommandPool) \
X(DestroyCommandPool) \
X(CmdDrawIndirect) \
X(CmdDrawIndexedIndirect) \
X(GetImageMemoryRequirements) \
X(BindImageMemory) \
X(DestroyImageView) \
X(CreateBufferView) \
X(DestroyBufferView) \
X(UpdateDescriptorSets) \
X(CmdPushDescriptorSet) \
X(CreateDescriptorUpdateTemplate) \
X(DestroyDescriptorUpdateTemplate) \
X(UpdateDescriptorSetWithTemplate) \
X(CmdPushDescriptorSetWithTemplate) \
X(CmdBindVertexBuffers) \
X(CmdBindVertexBuffers2)
struct staging_block;
struct device {
void *key;
VkDevice handle;
PFN_vkGetDeviceProcAddr gdpa;
/* The gaps the application enabled a made-up feature for. */
uint32_t emulated;
/* Locations a clip distance varying may use, from the vertex output and fragment input limits. */
uint32_t max_varying_locations;
VkPhysicalDeviceMemoryProperties memory_properties;
#define DECLARE(name) PFN_vk##name name;
DEVICE_FUNCTIONS(DECLARE)
#undef DECLARE
pthread_mutex_t lock;
struct handle_map shader_modules; /* VkShaderModule -> struct spirv_code, for modules with distances */
struct handle_map images; /* VkImage -> struct bc_image */
struct handle_map buffers; /* VkBuffer -> struct bound_buffer */
struct handle_map memories; /* VkDeviceMemory -> struct mapped_memory */
struct handle_map command_buffers; /* VkCommandBuffer -> struct command_buffer */
struct staging_block *free_staging;
struct handle_map templates; /* VkDescriptorUpdateTemplate -> struct template_info (draw.c) */
/* nullDescriptor stand-ins (draw.c): 0 not made yet, 1 ready, -1 failed. */
int null_ready;
VkBuffer null_buffer;
VkDeviceMemory null_buffer_memory;
VkImage null_image;
VkDeviceMemory null_image_memory;
VkImageView null_view;
/* Texel-buffer stand-ins: RGBA8 for uniform (sampled) texel buffers, R32_UINT for storage. */
VkBufferView null_uniform_texel;
VkBufferView null_storage_texel;
struct device *next;
};
struct device *device_from_handle(const void *dispatchable);
struct spirv_code {
uint32_t *words;
size_t count;
};
/* spirv.c */
bool spirv_uses_distances(const uint32_t *words, size_t count);
/* The module with clip and cull distances taken out; false when it cannot be rewritten. */
bool spirv_strip_distances(const uint32_t *words, size_t count, struct spirv_code *out);
enum clip_role { CLIP_STRIP, CLIP_PRODUCER, CLIP_CONSUMER };
struct clip_info {
bool has_clip; /* a standalone ClipDistance variable this stage could hand on */
uint32_t clip_count; /* its array length */
uint32_t locations_used; /* one past the highest varying location, outputs or inputs per role */
};
void spirv_clip_info(const uint32_t *words, size_t count, enum clip_role role, struct clip_info *info);
/*
* Producer: the last stage before rasterization writes its clip distances to `location` instead.
* Consumer: the fragment shader reads them there and discards when any is negative.
* Both drop cull distances. False when the module cannot be rewritten.
*/
bool spirv_emulate_clip(const uint32_t *words, size_t count, enum clip_role role, uint32_t location,
uint32_t clip_count, struct spirv_code *out);
/* pipeline.c */
VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo *info,
const VkAllocationCallbacks *allocator, VkShaderModule *module);
VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(VkDevice device, VkShaderModule module,
const VkAllocationCallbacks *allocator);
VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(VkDevice device, VkPipelineCache cache, uint32_t count,
const VkGraphicsPipelineCreateInfo *infos,
const VkAllocationCallbacks *allocator, VkPipeline *pipelines);
VKAPI_ATTR void VKAPI_CALL CmdSetViewport(VkCommandBuffer cmd, uint32_t first, uint32_t count,
const VkViewport *viewports);
VKAPI_ATTR void VKAPI_CALL CmdSetScissor(VkCommandBuffer cmd, uint32_t first, uint32_t count,
const VkRect2D *scissors);
VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount(VkCommandBuffer cmd, uint32_t count,
const VkViewport *viewports);
VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount(VkCommandBuffer cmd, uint32_t count, const VkRect2D *scissors);
/* bc.c */
VkFormat bc_substitute(VkFormat format);
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(VkPhysicalDevice physical_device, VkFormat format,
VkFormatProperties *properties);
VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(VkPhysicalDevice physical_device, VkFormat format,
VkFormatProperties2 *properties);
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physical_device, VkFormat format, VkImageType type, VkImageTiling tiling,
VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *properties);
VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
VkPhysicalDevice physical_device, const VkPhysicalDeviceImageFormatInfo2 *info,
VkImageFormatProperties2 *properties);
VKAPI_ATTR VkResult VKAPI_CALL CreateImage(VkDevice device, const VkImageCreateInfo *info,
const VkAllocationCallbacks *allocator, VkImage *image);
VKAPI_ATTR void VKAPI_CALL DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks *allocator);
VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(VkDevice device, const VkImageViewCreateInfo *info,
const VkAllocationCallbacks *allocator, VkImageView *view);
VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements(VkDevice device,
const VkDeviceImageMemoryRequirements *info,
VkMemoryRequirements2 *requirements);
VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements(
VkDevice device, const VkDeviceImageMemoryRequirements *info, uint32_t *count,
VkSparseImageMemoryRequirements2 *requirements);
VKAPI_ATTR void VKAPI_CALL GetDeviceImageSubresourceLayout(VkDevice device,
const VkDeviceImageSubresourceInfo *info,
VkSubresourceLayout2 *layout);
VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(VkCommandBuffer cmd, VkBuffer buffer, VkImage image,
VkImageLayout layout, uint32_t count,
const VkBufferImageCopy *regions);
VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2(VkCommandBuffer cmd, const VkCopyBufferToImageInfo2 *info);
VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(VkCommandBuffer cmd, VkImage image, VkImageLayout layout,
VkBuffer buffer, uint32_t count, const VkBufferImageCopy *regions);
VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2(VkCommandBuffer cmd, const VkCopyImageToBufferInfo2 *info);
VKAPI_ATTR void VKAPI_CALL CmdCopyImage(VkCommandBuffer cmd, VkImage src, VkImageLayout src_layout, VkImage dst,
VkImageLayout dst_layout, uint32_t count, const VkImageCopy *regions);
VKAPI_ATTR void VKAPI_CALL CmdCopyImage2(VkCommandBuffer cmd, const VkCopyImageInfo2 *info);
VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory,
VkDeviceSize offset);
VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(VkDevice device, uint32_t count,
const VkBindBufferMemoryInfo *infos);
VKAPI_ATTR void VKAPI_CALL DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks *allocator);
VKAPI_ATTR void VKAPI_CALL FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks *allocator);
VKAPI_ATTR VkResult VKAPI_CALL MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset,
VkDeviceSize size, VkMemoryMapFlags flags, void **data);
VKAPI_ATTR VkResult VKAPI_CALL MapMemory2(VkDevice device, const VkMemoryMapInfo *info, void **data);
VKAPI_ATTR void VKAPI_CALL UnmapMemory(VkDevice device, VkDeviceMemory memory);
VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2(VkDevice device, const VkMemoryUnmapInfo *info);
VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *info,
VkCommandBuffer *buffers);
VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(VkDevice device, VkCommandPool pool, uint32_t count,
const VkCommandBuffer *buffers);
VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(VkCommandBuffer cmd, const VkCommandBufferBeginInfo *info);
VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(VkCommandBuffer cmd, VkCommandBufferResetFlags flags);
VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(VkDevice device, VkCommandPool pool, VkCommandPoolResetFlags flags);
VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(VkDevice device, VkCommandPool pool,
const VkAllocationCallbacks *allocator);
void bc_destroy_device(struct device *dev);
/* layer.c */
struct instance *instance_from_handle(const void *dispatchable);
/* What the GPU lacks of the features the layer can make up for. */
uint32_t physical_device_gaps(struct instance *inst, VkPhysicalDevice physical_device);
/* trace.c (DROIDDECK_MALI_COMPAT_TRACE=1) */
void trace_load(struct instance *inst);
PFN_vkVoidFunction trace_hook(struct instance *inst, const char *name);
void trace_extension_names(const VkExtensionProperties *ext, uint32_t n);
/* draw.c */
VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(VkCommandBuffer cmd, VkBuffer buffer, VkDeviceSize offset, uint32_t draw_count, uint32_t stride);
VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(VkCommandBuffer cmd, VkBuffer buffer, VkDeviceSize offset, uint32_t draw_count, uint32_t stride);
VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(VkDevice device, uint32_t write_count, const VkWriteDescriptorSet *writes, uint32_t copy_count, const VkCopyDescriptorSet *copies);
VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSet(VkCommandBuffer cmd, VkPipelineBindPoint bind_point, VkPipelineLayout layout, uint32_t set, uint32_t write_count, const VkWriteDescriptorSet *writes);
VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo *info, const VkAllocationCallbacks *allocator, VkDescriptorUpdateTemplate *tmpl);
VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate tmpl, const VkAllocationCallbacks *allocator);
VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet set, VkDescriptorUpdateTemplate tmpl, const void *data);
VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplate(VkCommandBuffer cmd, VkDescriptorUpdateTemplate tmpl, VkPipelineLayout layout, uint32_t set, const void *data);
VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(VkCommandBuffer cmd, uint32_t first, uint32_t count, const VkBuffer *buffers, const VkDeviceSize *offsets);
VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2(VkCommandBuffer cmd, uint32_t first, uint32_t count, const VkBuffer *buffers, const VkDeviceSize *offsets, const VkDeviceSize *sizes, const VkDeviceSize *strides);
void null_resources_destroy(struct device *dev);
#endif