KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

zink: print result code string on vulkan failure 

Reviewed-By: Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/17726>
This commit is contained in:
TSnake41 2022-07-28 18:05:21 +02:00 committed by Astie Teddy
parent 91c0d46afd
commit a02c026eb7
17 changed files with 145 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/gallium/drivers/zink/zink_batch.c
View File

@ -31,8 +31,9 @@ zink_reset_batch_state(struct zink_context *ctx, struct zink_batch_state *bs)
{ {
struct zink_screen *screen = zink_screen(ctx->base.screen); struct zink_screen *screen = zink_screen(ctx->base.screen);
if (VKSCR(ResetCommandPool)(screen->dev, bs->cmdpool, 0) != VK_SUCCESS) VkResult result = VKSCR(ResetCommandPool)(screen->dev, bs->cmdpool, 0);
mesa_loge("ZINK: vkResetCommandPool failed"); if (result != VK_SUCCESS)
mesa_loge("ZINK: vkResetCommandPool failed (%s)", vk_Result_to_str(result));
/* unref all used resources */ /* unref all used resources */
set_foreach_remove(bs->resources, entry) { set_foreach_remove(bs->resources, entry) {
@ -195,8 +196,11 @@ create_batch_state(struct zink_context *ctx)
VkCommandPoolCreateInfo cpci = {0}; VkCommandPoolCreateInfo cpci = {0};
cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
cpci.queueFamilyIndex = screen->gfx_queue; cpci.queueFamilyIndex = screen->gfx_queue;
if (VKSCR(CreateCommandPool)(screen->dev, &cpci, NULL, &bs->cmdpool) != VK_SUCCESS) VkResult result = VKSCR(CreateCommandPool)(screen->dev, &cpci, NULL, &bs->cmdpool);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateCommandPool failed (%s)", vk_Result_to_str(result));
goto fail; goto fail;
}
VkCommandBufferAllocateInfo cbai = {0}; VkCommandBufferAllocateInfo cbai = {0};
cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
@ -204,11 +208,17 @@ create_batch_state(struct zink_context *ctx)
cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
cbai.commandBufferCount = 1; cbai.commandBufferCount = 1;
if (VKSCR(AllocateCommandBuffers)(screen->dev, &cbai, &bs->cmdbuf) != VK_SUCCESS) result = VKSCR(AllocateCommandBuffers)(screen->dev, &cbai, &bs->cmdbuf);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkAllocateCommandBuffers failed (%s)", vk_Result_to_str(result));
goto fail; goto fail;
}
if (VKSCR(AllocateCommandBuffers)(screen->dev, &cbai, &bs->barrier_cmdbuf) != VK_SUCCESS) result = VKSCR(AllocateCommandBuffers)(screen->dev, &cbai, &bs->barrier_cmdbuf);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkAllocateCommandBuffers failed (%s)", vk_Result_to_str(result));
goto fail; goto fail;
}
#define SET_CREATE_OR_FAIL(ptr) \ #define SET_CREATE_OR_FAIL(ptr) \
ptr = _mesa_pointer_set_create(bs); \ ptr = _mesa_pointer_set_create(bs); \
@ -308,10 +318,14 @@ zink_start_batch(struct zink_context *ctx, struct zink_batch *batch)
VkCommandBufferBeginInfo cbbi = {0}; VkCommandBufferBeginInfo cbbi = {0};
cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cbbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; cbbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
if (VKCTX(BeginCommandBuffer)(batch->state->cmdbuf, &cbbi) != VK_SUCCESS)
mesa_loge("ZINK: vkBeginCommandBuffer failed"); VkResult result = VKCTX(BeginCommandBuffer)(batch->state->cmdbuf, &cbbi);
if (VKCTX(BeginCommandBuffer)(batch->state->barrier_cmdbuf, &cbbi) != VK_SUCCESS) if (result != VK_SUCCESS)
mesa_loge("ZINK: vkBeginCommandBuffer failed"); mesa_loge("ZINK: vkBeginCommandBuffer failed (%s)", vk_Result_to_str(result));
result = VKCTX(BeginCommandBuffer)(batch->state->barrier_cmdbuf, &cbbi);
if (result != VK_SUCCESS)
mesa_loge("ZINK: vkBeginCommandBuffer failed (%s)", vk_Result_to_str(result));
batch->state->fence.completed = false; batch->state->fence.completed = false;
if (ctx->last_fence) { if (ctx->last_fence) {
@ -397,14 +411,16 @@ submit_queue(void *data, void *gdata, int thread_index)
signals[si[1].signalSemaphoreCount++] = bs->present; signals[si[1].signalSemaphoreCount++] = bs->present;
tsi.signalSemaphoreValueCount = si[1].signalSemaphoreCount; tsi.signalSemaphoreValueCount = si[1].signalSemaphoreCount;
if (VKSCR(EndCommandBuffer)(bs->cmdbuf) != VK_SUCCESS) { VkResult result = VKSCR(EndCommandBuffer)(bs->cmdbuf);
mesa_loge("ZINK: vkEndCommandBuffer failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEndCommandBuffer failed (%s)", vk_Result_to_str(result));
bs->is_device_lost = true; bs->is_device_lost = true;
goto end; goto end;
} }
if (bs->has_barriers) { if (bs->has_barriers) {
if (VKSCR(EndCommandBuffer)(bs->barrier_cmdbuf) != VK_SUCCESS) { result = VKSCR(EndCommandBuffer)(bs->barrier_cmdbuf);
mesa_loge("ZINK: vkEndCommandBuffer failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEndCommandBuffer failed (%s)", vk_Result_to_str(result));
bs->is_device_lost = true; bs->is_device_lost = true;
goto end; goto end;
} }
@ -413,14 +429,17 @@ submit_queue(void *data, void *gdata, int thread_index)
while (util_dynarray_contains(&bs->persistent_resources, struct zink_resource_object*)) { while (util_dynarray_contains(&bs->persistent_resources, struct zink_resource_object*)) {
struct zink_resource_object *obj = util_dynarray_pop(&bs->persistent_resources, struct zink_resource_object*); struct zink_resource_object *obj = util_dynarray_pop(&bs->persistent_resources, struct zink_resource_object*);
VkMappedMemoryRange range = zink_resource_init_mem_range(screen, obj, 0, obj->size); VkMappedMemoryRange range = zink_resource_init_mem_range(screen, obj, 0, obj->size);
if (VKSCR(FlushMappedMemoryRanges)(screen->dev, 1, &range) != VK_SUCCESS) {
mesa_loge("ZINK: vkFlushMappedMemoryRanges failed"); result = VKSCR(FlushMappedMemoryRanges)(screen->dev, 1, &range);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkFlushMappedMemoryRanges failed (%s)", vk_Result_to_str(result));
} }
} }
simple_mtx_lock(&screen->queue_lock); simple_mtx_lock(&screen->queue_lock);
if (VKSCR(QueueSubmit)(screen->queue, num_si, num_si == 2 ? si : &si[1], VK_NULL_HANDLE) != VK_SUCCESS) { result = VKSCR(QueueSubmit)(screen->queue, num_si, num_si == 2 ? si : &si[1], VK_NULL_HANDLE);
mesa_loge("ZINK: vkQueueSubmit failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkQueueSubmit failed (%s)", vk_Result_to_str(result));
bs->is_device_lost = true; bs->is_device_lost = true;
} }
simple_mtx_unlock(&screen->queue_lock); simple_mtx_unlock(&screen->queue_lock);

3
src/gallium/drivers/zink/zink_bo.c
View File

@ -29,6 +29,7 @@
* Mike Blumenkrantz <michael.blumenkrantz@gmail.com> * Mike Blumenkrantz <michael.blumenkrantz@gmail.com>
*/ */
#include "zink_context.h"
#include "zink_bo.h" #include "zink_bo.h"
#include "zink_resource.h" #include "zink_resource.h"
#include "zink_screen.h" #include "zink_screen.h"
@ -682,7 +683,7 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo)
if (!cpu) { if (!cpu) {
VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.size, 0, &cpu); VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.size, 0, &cpu);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkMapMemory failed"); mesa_loge("ZINK: vkMapMemory failed (%s)", vk_Result_to_str(result));
simple_mtx_unlock(&real->lock); simple_mtx_unlock(&real->lock);
return NULL; return NULL;
} }

23
src/gallium/drivers/zink/zink_context.c
View File

@ -98,8 +98,12 @@ zink_context_destroy(struct pipe_context *pctx)
if (util_queue_is_initialized(&screen->flush_queue)) if (util_queue_is_initialized(&screen->flush_queue))
util_queue_finish(&screen->flush_queue); util_queue_finish(&screen->flush_queue);
if (ctx->batch.state && !screen->device_lost && VKSCR(QueueWaitIdle)(screen->queue) != VK_SUCCESS) if (ctx->batch.state && !screen->device_lost) {
mesa_loge("ZINK: vkQueueWaitIdle failed"); VkResult result = VKSCR(QueueWaitIdle)(screen->queue);
if (result != VK_SUCCESS)
mesa_loge("ZINK: vkQueueWaitIdle failed (%s)", vk_Result_to_str(result));
}
for (unsigned i = 0; i < ARRAY_SIZE(ctx->program_cache); i++) { for (unsigned i = 0; i < ARRAY_SIZE(ctx->program_cache); i++) {
hash_table_foreach(&ctx->program_cache[i], entry) { hash_table_foreach(&ctx->program_cache[i], entry) {
@ -445,15 +449,17 @@ zink_create_sampler_state(struct pipe_context *pctx,
if (!sampler) if (!sampler)
return NULL; return NULL;
if (VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler) != VK_SUCCESS) { VkResult result = VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler);
mesa_loge("ZINK: vkCreateSampler failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSampler failed (%s)", vk_Result_to_str(result));
FREE(sampler); FREE(sampler);
return NULL; return NULL;
} }
if (need_clamped_border_color) { if (need_clamped_border_color) {
sci.pNext = &cbci_clamped; sci.pNext = &cbci_clamped;
if (VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler_clamped) != VK_SUCCESS) { result = VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler_clamped);
mesa_loge("ZINK: vkCreateSampler failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSampler failed (%s)", vk_Result_to_str(result));
VKSCR(DestroySampler)(screen->dev, sampler->sampler, NULL); VKSCR(DestroySampler)(screen->dev, sampler->sampler, NULL);
FREE(sampler); FREE(sampler);
return NULL; return NULL;
@ -810,8 +816,9 @@ get_buffer_view(struct zink_context *ctx, struct zink_resource *res, VkBufferVie
p_atomic_inc(&buffer_view->reference.count); p_atomic_inc(&buffer_view->reference.count);
} else { } else {
VkBufferView view; VkBufferView view;
if (VKSCR(CreateBufferView)(screen->dev, bvci, NULL, &view) != VK_SUCCESS) { VkResult result = VKSCR(CreateBufferView)(screen->dev, bvci, NULL, &view);
mesa_loge("ZINK: vkCreateBufferView failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateBufferView failed (%s)", vk_Result_to_str(result));
goto out; goto out;
} }
buffer_view = CALLOC_STRUCT(zink_buffer_view); buffer_view = CALLOC_STRUCT(zink_buffer_view);

1
src/gallium/drivers/zink/zink_context.h
View File

@ -47,6 +47,7 @@
#include "util/slab.h" #include "util/slab.h"
#include "util/list.h" #include "util/list.h"
#include "util/u_dynarray.h" #include "util/u_dynarray.h"
#include "vk_enum_to_str.h"
#include <vulkan/vulkan.h> #include <vulkan/vulkan.h>

25
src/gallium/drivers/zink/zink_descriptors.c
View File

@ -332,8 +332,9 @@ descriptor_pool_create(struct zink_screen *screen, enum zink_descriptor_type typ
dpci.flags = 0; dpci.flags = 0;
dpci.maxSets = ZINK_DEFAULT_MAX_DESCS; dpci.maxSets = ZINK_DEFAULT_MAX_DESCS;
assert(pool_key->num_type_sizes); assert(pool_key->num_type_sizes);
if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool->descpool) != VK_SUCCESS) { VkResult result = VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool->descpool);
mesa_loge("ZINK: vkCreateDescriptorPool failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed (%s)", vk_Result_to_str(result));
goto fail; goto fail;
} }
@ -376,8 +377,9 @@ descriptor_layout_create(struct zink_screen *screen, enum zink_descriptor_type t
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }
} }
if (VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &dsl) != VK_SUCCESS) VkResult result = VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &dsl);
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed"); if (result != VK_SUCCESS)
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed (%s)", vk_Result_to_str(result));
return dsl; return dsl;
} }
@ -625,8 +627,9 @@ zink_descriptor_util_alloc_sets(struct zink_screen *screen, VkDescriptorSetLayou
layouts[i] = dsl; layouts[i] = dsl;
dsai.pSetLayouts = layouts; dsai.pSetLayouts = layouts;
if (VKSCR(AllocateDescriptorSets)(screen->dev, &dsai, sets) != VK_SUCCESS) { VkResult result = VKSCR(AllocateDescriptorSets)(screen->dev, &dsai, sets);
mesa_loge("ZINK: %" PRIu64 " failed to allocate descriptor set :/", (uint64_t)dsl); if (result != VK_SUCCESS) {
mesa_loge("ZINK: %" PRIu64 " failed to allocate descriptor set :/ (%s)", (uint64_t)dsl, vk_Result_to_str(result));
return false; return false;
} }
return true; return true;
@ -1956,8 +1959,9 @@ zink_descriptors_init_bindless(struct zink_context *ctx)
dcslci.bindingCount = num_bindings; dcslci.bindingCount = num_bindings;
dcslci.pBindings = bindings; dcslci.pBindings = bindings;
if (VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &ctx->dd->bindless_layout) != VK_SUCCESS) { VkResult result = VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &ctx->dd->bindless_layout);
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed (%s)", vk_Result_to_str(result));
return; return;
} }
@ -1972,8 +1976,9 @@ zink_descriptors_init_bindless(struct zink_context *ctx)
dpci.poolSizeCount = 4; dpci.poolSizeCount = 4;
dpci.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT; dpci.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
dpci.maxSets = 1; dpci.maxSets = 1;
if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &ctx->dd->bindless_pool) != VK_SUCCESS) { result = VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &ctx->dd->bindless_pool);
mesa_loge("ZINK: vkCreateDescriptorPool failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed (%s)", vk_Result_to_str(result));
return; return;
} }

5
src/gallium/drivers/zink/zink_descriptors_lazy.c
View File

@ -378,8 +378,9 @@ create_pool(struct zink_screen *screen, unsigned num_type_sizes, const VkDescrip
dpci.poolSizeCount = num_type_sizes; dpci.poolSizeCount = num_type_sizes;
dpci.flags = flags; dpci.flags = flags;
dpci.maxSets = MAX_LAZY_DESCRIPTORS; dpci.maxSets = MAX_LAZY_DESCRIPTORS;
if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool) != VK_SUCCESS) { VkResult result = VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool);
mesa_loge("ZINK: vkCreateDescriptorPool failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }
return pool; return pool;

11
src/gallium/drivers/zink/zink_device_info.py
View File

@ -359,6 +359,7 @@ void zink_stub_${cmd.lstrip("vk")}(void);
impl_code = """ impl_code = """
<%namespace name="helpers" file="helpers"/> <%namespace name="helpers" file="helpers"/>
#include "vk_enum_to_str.h"
#include "zink_device_info.h" #include "zink_device_info.h"
#include "zink_screen.h" #include "zink_screen.h"
@ -377,14 +378,16 @@ zink_get_physical_device_info(struct zink_screen *screen)
screen->vk.GetPhysicalDeviceMemoryProperties(screen->pdev, &info->mem_props); screen->vk.GetPhysicalDeviceMemoryProperties(screen->pdev, &info->mem_props);
// enumerate device supported extensions // enumerate device supported extensions
if (screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, NULL) != VK_SUCCESS) { VkResult result = screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, NULL);
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed (%s)", vk_Result_to_str(result));
} else { } else {
if (num_extensions > 0) { if (num_extensions > 0) {
VkExtensionProperties *extensions = MALLOC(sizeof(VkExtensionProperties) * num_extensions); VkExtensionProperties *extensions = MALLOC(sizeof(VkExtensionProperties) * num_extensions);
if (!extensions) goto fail; if (!extensions) goto fail;
if (screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, extensions) != VK_SUCCESS) { result = screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, extensions);
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed (%s)", vk_Result_to_str(result));
} }
for (uint32_t i = 0; i < num_extensions; ++i) { for (uint32_t i = 0; i < num_extensions; ++i) {

5
src/gallium/drivers/zink/zink_fence.c
View File

@ -242,8 +242,9 @@ zink_create_fence_fd(struct pipe_context *pctx, struct pipe_fence_handle **pfenc
*pfence = NULL; *pfence = NULL;
if (VKSCR(CreateSemaphore)(screen->dev, &sci, NULL, &mfence->sem) != VK_SUCCESS) { VkResult result = VKSCR(CreateSemaphore)(screen->dev, &sci, NULL, &mfence->sem);
mesa_loge("ZINK: vkCreateSemaphore failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSemaphore failed (%s)", vk_Result_to_str(result));
FREE(mfence); FREE(mfence);
return; return;
} }

2
src/gallium/drivers/zink/zink_instance.py
View File

@ -118,9 +118,9 @@ struct pipe_resource;
""" """
impl_code = """ impl_code = """
#include "vk_enum_to_str.h"
#include "zink_instance.h" #include "zink_instance.h"
#include "zink_screen.h" #include "zink_screen.h"
#include "vk_enum_to_str.h"
bool bool
zink_create_instance(struct zink_screen *screen) zink_create_instance(struct zink_screen *screen)

6
src/gallium/drivers/zink/zink_kopper.c
View File

@ -27,7 +27,6 @@
#include "zink_screen.h" #include "zink_screen.h"
#include "zink_resource.h" #include "zink_resource.h"
#include "zink_kopper.h" #include "zink_kopper.h"
#include "vk_enum_to_str.h"
static void static void
zink_kopper_set_present_mode_for_interval(struct kopper_displaytarget *cdt, int interval) zink_kopper_set_present_mode_for_interval(struct kopper_displaytarget *cdt, int interval)
@ -283,8 +282,9 @@ kopper_CreateSwapchain(struct zink_screen *screen, struct kopper_displaytarget *
if (error == VK_ERROR_NATIVE_WINDOW_IN_USE_KHR) { if (error == VK_ERROR_NATIVE_WINDOW_IN_USE_KHR) {
if (util_queue_is_initialized(&screen->flush_queue)) if (util_queue_is_initialized(&screen->flush_queue))
util_queue_finish(&screen->flush_queue); util_queue_finish(&screen->flush_queue);
if (VKSCR(QueueWaitIdle)(screen->queue) != VK_SUCCESS) VkResult result = VKSCR(QueueWaitIdle)(screen->queue);
debug_printf("vkQueueWaitIdle failed\n"); if (result != VK_SUCCESS)
mesa_loge("ZINK: vkQueueWaitIdle failed (%s)", vk_Result_to_str(result));
zink_kopper_deinit_displaytarget(screen, cdt); zink_kopper_deinit_displaytarget(screen, cdt);
error = VKSCR(CreateSwapchainKHR)(screen->dev, &cswap->scci, NULL, error = VKSCR(CreateSwapchainKHR)(screen->dev, &cswap->scci, NULL,
&cswap->swapchain); &cswap->swapchain);

14
src/gallium/drivers/zink/zink_pipeline.c
View File

@ -376,9 +376,10 @@ zink_create_gfx_pipeline(struct zink_screen *screen,
pci.stageCount = num_stages; pci.stageCount = num_stages;
VkPipeline pipeline; VkPipeline pipeline;
if (VKSCR(CreateGraphicsPipelines)(screen->dev, prog->base.pipeline_cache, VkResult result = VKSCR(CreateGraphicsPipelines)(screen->dev, prog->base.pipeline_cache,
1, &pci, NULL, &pipeline) != VK_SUCCESS) { 1, &pci, NULL, &pipeline);
mesa_loge("ZINK: vkCreateGraphicsPipelines failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateGraphicsPipelines failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }
@ -417,9 +418,10 @@ zink_create_compute_pipeline(struct zink_screen *screen, struct zink_compute_pro
pci.stage = stage; pci.stage = stage;
VkPipeline pipeline; VkPipeline pipeline;
if (VKSCR(CreateComputePipelines)(screen->dev, comp->base.pipeline_cache, VkResult result = VKSCR(CreateComputePipelines)(screen->dev, comp->base.pipeline_cache,
1, &pci, NULL, &pipeline) != VK_SUCCESS) { 1, &pci, NULL, &pipeline);
mesa_loge("ZINK: vkCreateComputePipelines failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateComputePipelines failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }
zink_screen_update_pipeline_cache(screen, &comp->base); zink_screen_update_pipeline_cache(screen, &comp->base);

5
src/gallium/drivers/zink/zink_program.c
View File

@ -389,8 +389,9 @@ zink_pipeline_layout_create(struct zink_screen *screen, struct zink_program *pg,
plci.pPushConstantRanges = &pcr[0]; plci.pPushConstantRanges = &pcr[0];
VkPipelineLayout layout; VkPipelineLayout layout;
if (VKSCR(CreatePipelineLayout)(screen->dev, &plci, NULL, &layout) != VK_SUCCESS) { VkResult result = VKSCR(CreatePipelineLayout)(screen->dev, &plci, NULL, &layout);
mesa_loge("vkCreatePipelineLayout failed"); if (result != VK_SUCCESS) {
mesa_loge("vkCreatePipelineLayout failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }

14
src/gallium/drivers/zink/zink_query.c
View File

@ -174,7 +174,7 @@ find_or_allocate_qp(struct zink_context *ctx,
VkResult status = VKSCR(CreateQueryPool)(screen->dev, &pool_create, NULL, &new_pool->query_pool); VkResult status = VKSCR(CreateQueryPool)(screen->dev, &pool_create, NULL, &new_pool->query_pool);
if (status != VK_SUCCESS) { if (status != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateQueryPool failed"); mesa_loge("ZINK: vkCreateQueryPool failed (%s)", vk_Result_to_str(status));
FREE(new_pool); FREE(new_pool);
return NULL; return NULL;
} }
@ -1254,12 +1254,13 @@ zink_get_query_result_resource(struct pipe_context *pctx,
unsigned src_offset = result_size * get_num_results(query); unsigned src_offset = result_size * get_num_results(query);
if (zink_batch_usage_check_completion(ctx, query->batch_uses)) { if (zink_batch_usage_check_completion(ctx, query->batch_uses)) {
uint64_t u64[4] = {0}; uint64_t u64[4] = {0};
if (VKCTX(GetQueryPoolResults)(screen->dev, start->vkq[0]->pool->query_pool, query_id, 1, sizeof(u64), u64, VkResult result = VKCTX(GetQueryPoolResults)(screen->dev, start->vkq[0]->pool->query_pool, query_id, 1,
0, size_flags | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | flag) == VK_SUCCESS) { sizeof(u64), u64, 0, size_flags | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | flag);
if (result == VK_SUCCESS) {
tc_buffer_write(pctx, pres, offset, result_size, (unsigned char*)u64 + src_offset); tc_buffer_write(pctx, pres, offset, result_size, (unsigned char*)u64 + src_offset);
return; return;
} else { } else {
mesa_loge("ZINK: vkGetQueryPoolResults failed"); mesa_loge("ZINK: vkGetQueryPoolResults failed (%s)", vk_Result_to_str(result));
} }
} }
struct pipe_resource *staging = pipe_buffer_create(pctx->screen, 0, PIPE_USAGE_STAGING, src_offset + result_size); struct pipe_resource *staging = pipe_buffer_create(pctx->screen, 0, PIPE_USAGE_STAGING, src_offset + result_size);
@ -1314,8 +1315,9 @@ zink_get_timestamp(struct pipe_screen *pscreen)
VkCalibratedTimestampInfoEXT cti = {0}; VkCalibratedTimestampInfoEXT cti = {0};
cti.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT; cti.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT;
cti.timeDomain = VK_TIME_DOMAIN_DEVICE_EXT; cti.timeDomain = VK_TIME_DOMAIN_DEVICE_EXT;
if (VKSCR(GetCalibratedTimestampsEXT)(screen->dev, 1, &cti, &timestamp, &deviation) != VK_SUCCESS) { VkResult result = VKSCR(GetCalibratedTimestampsEXT)(screen->dev, 1, &cti, &timestamp, &deviation);
mesa_loge("ZINK: vkGetCalibratedTimestampsEXT failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetCalibratedTimestampsEXT failed (%s)", vk_Result_to_str(result));
} }
} else { } else {
struct pipe_context *pctx = &screen->copy_context->base; struct pipe_context *pctx = &screen->copy_context->base;

5
src/gallium/drivers/zink/zink_render_pass.c
View File

@ -221,8 +221,9 @@ create_render_pass2(struct zink_screen *screen, struct zink_render_pass_state *s
rpci.pDependencies = input_count ? fbfetch_deps : deps; rpci.pDependencies = input_count ? fbfetch_deps : deps;
VkRenderPass render_pass; VkRenderPass render_pass;
if (VKSCR(CreateRenderPass2)(screen->dev, &rpci, NULL, &render_pass) != VK_SUCCESS) { VkResult result = VKSCR(CreateRenderPass2)(screen->dev, &rpci, NULL, &render_pass);
mesa_loge("ZINK: vkCreateRenderPass2 failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateRenderPass2 failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
} }

2
src/gallium/drivers/zink/zink_resource.c
View File

@ -785,7 +785,7 @@ resource_object_create(struct zink_screen *screen, const struct pipe_resource *t
} }
} }
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateImage failed"); mesa_loge("ZINK: vkCreateImage failed (%s)", vk_Result_to_str(result));
goto fail1; goto fail1;
} }

49
src/gallium/drivers/zink/zink_screen.c
View File

@ -217,8 +217,9 @@ cache_put_job(void *data, void *gdata, int thread_index)
struct zink_program *pg = data; struct zink_program *pg = data;
struct zink_screen *screen = gdata; struct zink_screen *screen = gdata;
size_t size = 0; size_t size = 0;
if (VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL) != VK_SUCCESS) { VkResult result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL);
mesa_loge("ZINK: vkGetPipelineCacheData failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPipelineCacheData failed (%s)", vk_Result_to_str(result));
return; return;
} }
if (pg->pipeline_cache_size == size) if (pg->pipeline_cache_size == size)
@ -226,14 +227,15 @@ cache_put_job(void *data, void *gdata, int thread_index)
void *pipeline_data = malloc(size); void *pipeline_data = malloc(size);
if (!pipeline_data) if (!pipeline_data)
return; return;
if (VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, pipeline_data) == VK_SUCCESS) { result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, pipeline_data);
if (result == VK_SUCCESS) {
pg->pipeline_cache_size = size; pg->pipeline_cache_size = size;
cache_key key; cache_key key;
disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key); disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key);
disk_cache_put_nocopy(screen->disk_cache, key, pipeline_data, size, NULL); disk_cache_put_nocopy(screen->disk_cache, key, pipeline_data, size, NULL);
} else { } else {
mesa_loge("ZINK: vkGetPipelineCacheData failed"); mesa_loge("ZINK: vkGetPipelineCacheData failed (%s)", vk_Result_to_str(result));
} }
} }
@ -264,8 +266,10 @@ cache_get_job(void *data, void *gdata, int thread_index)
disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key); disk_cache_compute_key(screen->disk_cache, pg->sha1, sizeof(pg->sha1), key);
pcci.pInitialData = disk_cache_get(screen->disk_cache, key, &pg->pipeline_cache_size); pcci.pInitialData = disk_cache_get(screen->disk_cache, key, &pg->pipeline_cache_size);
pcci.initialDataSize = pg->pipeline_cache_size; pcci.initialDataSize = pg->pipeline_cache_size;
if (VKSCR(CreatePipelineCache)(screen->dev, &pcci, NULL, &pg->pipeline_cache) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreatePipelineCache failed"); VkResult res = VKSCR(CreatePipelineCache)(screen->dev, &pcci, NULL, &pg->pipeline_cache);
if (res != VK_SUCCESS) {
mesa_loge("ZINK: vkCreatePipelineCache failed (%s)", vk_Result_to_str(res));
} }
free((void*)pcci.pInitialData); free((void*)pcci.pInitialData);
} }
@ -1306,7 +1310,7 @@ choose_pdev(struct zink_screen *screen)
bool is_cpu = false; bool is_cpu = false;
VkResult result = VKSCR(EnumeratePhysicalDevices)(screen->instance, &pdev_count, NULL); VkResult result = VKSCR(EnumeratePhysicalDevices)(screen->instance, &pdev_count, NULL);
if (result != VK_SUCCESS) { if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumeratePhysicalDevices failed"); mesa_loge("ZINK: vkEnumeratePhysicalDevices failed (%s)", vk_Result_to_str(result));
return is_cpu; return is_cpu;
} }
@ -1573,14 +1577,16 @@ check_have_device_time(struct zink_screen *screen)
{ {
uint32_t num_domains = 0; uint32_t num_domains = 0;
VkTimeDomainEXT domains[8]; //current max is 4 VkTimeDomainEXT domains[8]; //current max is 4
if (VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, NULL) != VK_SUCCESS) { VkResult result = VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, NULL);
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed (%s)", vk_Result_to_str(result));
} }
assert(num_domains > 0); assert(num_domains > 0);
assert(num_domains < ARRAY_SIZE(domains)); assert(num_domains < ARRAY_SIZE(domains));
if (VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, domains) != VK_SUCCESS) { result = VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, domains);
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed (%s)", vk_Result_to_str(result));
} }
/* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */ /* VK_TIME_DOMAIN_DEVICE_EXT is used for the ctx->get_timestamp hook and is the only one we really need */
@ -1654,12 +1660,13 @@ create_debug(struct zink_screen *screen)
VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE; VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE;
if (VKSCR(CreateDebugUtilsMessengerEXT)( VkResult result = VKSCR(CreateDebugUtilsMessengerEXT)(
screen->instance, screen->instance,
&vkDebugUtilsMessengerCreateInfoEXT, &vkDebugUtilsMessengerCreateInfoEXT,
NULL, NULL,
&vkDebugUtilsCallbackEXT) != VK_SUCCESS) { &vkDebugUtilsCallbackEXT);
mesa_loge("ZINK: vkCreateDebugUtilsMessengerEXT failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDebugUtilsMessengerEXT failed (%s)", vk_Result_to_str(result));
} }
screen->debugUtilsCallbackHandle = vkDebugUtilsCallbackEXT; screen->debugUtilsCallbackHandle = vkDebugUtilsCallbackEXT;
@ -1750,7 +1757,7 @@ populate_format_props(struct zink_screen *screen)
VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
0, &image_props); 0, &image_props);
if (ret != VK_SUCCESS && ret != VK_ERROR_FORMAT_NOT_SUPPORTED) { if (ret != VK_SUCCESS && ret != VK_ERROR_FORMAT_NOT_SUPPORTED) {
mesa_loge("ZINK: vkGetPhysicalDeviceImageFormatProperties failed"); mesa_loge("ZINK: vkGetPhysicalDeviceImageFormatProperties failed (%s)", vk_Result_to_str(ret));
} }
screen->need_2D_zs = ret != VK_SUCCESS; screen->need_2D_zs = ret != VK_SUCCESS;
@ -1805,10 +1812,11 @@ zink_get_loader_version(struct zink_screen *screen)
GET_PROC_ADDR_INSTANCE_LOCAL(screen, NULL, EnumerateInstanceVersion); GET_PROC_ADDR_INSTANCE_LOCAL(screen, NULL, EnumerateInstanceVersion);
if (vk_EnumerateInstanceVersion) { if (vk_EnumerateInstanceVersion) {
uint32_t loader_version_temp = VK_API_VERSION_1_0; uint32_t loader_version_temp = VK_API_VERSION_1_0;
if (VK_SUCCESS == (*vk_EnumerateInstanceVersion)(&loader_version_temp)) { VkResult result = (*vk_EnumerateInstanceVersion)(&loader_version_temp);
if (VK_SUCCESS == result) {
loader_version = loader_version_temp; loader_version = loader_version_temp;
} else { } else {
mesa_loge("ZINK: vkEnumerateInstanceVersion failed"); mesa_loge("ZINK: vkEnumerateInstanceVersion failed (%s)", vk_Result_to_str(result));
} }
} }
@ -2016,9 +2024,10 @@ zink_create_logical_device(struct zink_screen *screen)
dci.ppEnabledExtensionNames = screen->info.extensions; dci.ppEnabledExtensionNames = screen->info.extensions;
dci.enabledExtensionCount = screen->info.num_extensions; dci.enabledExtensionCount = screen->info.num_extensions;
if (VKSCR(CreateDevice)(screen->pdev, &dci, NULL, &dev) != VK_SUCCESS) { VkResult result = VKSCR(CreateDevice)(screen->pdev, &dci, NULL, &dev);
mesa_loge("ZINK: vkCreateDevice failed"); if (result != VK_SUCCESS)
} mesa_loge("ZINK: vkCreateDevice failed (%s)", vk_Result_to_str(result));
return dev; return dev;
} }

12
src/gallium/drivers/zink/zink_surface.c
View File

@ -172,9 +172,10 @@ create_surface(struct pipe_context *pctx,
if (!actually) if (!actually)
return surface; return surface;
assert(ivci->image); assert(ivci->image);
if (VKSCR(CreateImageView)(screen->dev, ivci, NULL, VkResult result = VKSCR(CreateImageView)(screen->dev, ivci, NULL,
&surface->image_view) != VK_SUCCESS) { &surface->image_view);
mesa_loge("ZINK: vkCreateImageView failed"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateImageView failed (%s)", vk_Result_to_str(result));
FREE(surface); FREE(surface);
return NULL; return NULL;
} }
@ -363,8 +364,9 @@ zink_rebind_surface(struct zink_context *ctx, struct pipe_surface **psurface)
assert(entry); assert(entry);
_mesa_hash_table_remove(&res->surface_cache, entry); _mesa_hash_table_remove(&res->surface_cache, entry);
VkImageView image_view; VkImageView image_view;
if (VKSCR(CreateImageView)(screen->dev, &ivci, NULL, &image_view) != VK_SUCCESS) { VkResult result = VKSCR(CreateImageView)(screen->dev, &ivci, NULL, &image_view);
mesa_loge("ZINK: failed to create new imageview"); if (result != VK_SUCCESS) {
mesa_loge("ZINK: failed to create new imageview (%s)", vk_Result_to_str(result));
simple_mtx_unlock(&res->surface_mtx); simple_mtx_unlock(&res->surface_mtx);
return false; return false;
} }