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);
if (VKSCR(ResetCommandPool)(screen->dev, bs->cmdpool, 0) != VK_SUCCESS)
mesa_loge("ZINK: vkResetCommandPool failed");
VkResult result = VKSCR(ResetCommandPool)(screen->dev, bs->cmdpool, 0);
if (result != VK_SUCCESS)
mesa_loge("ZINK: vkResetCommandPool failed (%s)", vk_Result_to_str(result));
/* unref all used resources */
set_foreach_remove(bs->resources, entry) {
@ -195,8 +196,11 @@ create_batch_state(struct zink_context *ctx)
VkCommandPoolCreateInfo cpci = {0};
cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
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;
}
VkCommandBufferAllocateInfo cbai = {0};
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.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;
}
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;
}
#define SET_CREATE_OR_FAIL(ptr) \
ptr = _mesa_pointer_set_create(bs); \
@ -308,10 +318,14 @@ zink_start_batch(struct zink_context *ctx, struct zink_batch *batch)
VkCommandBufferBeginInfo cbbi = {0};
cbbi.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
cbbi.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
if (VKCTX(BeginCommandBuffer)(batch->state->cmdbuf, &cbbi) != VK_SUCCESS)
mesa_loge("ZINK: vkBeginCommandBuffer failed");
if (VKCTX(BeginCommandBuffer)(batch->state->barrier_cmdbuf, &cbbi) != VK_SUCCESS)
mesa_loge("ZINK: vkBeginCommandBuffer failed");
VkResult result = VKCTX(BeginCommandBuffer)(batch->state->cmdbuf, &cbbi);
if (result != VK_SUCCESS)
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;
if (ctx->last_fence) {
@ -397,14 +411,16 @@ submit_queue(void *data, void *gdata, int thread_index)
signals[si[1].signalSemaphoreCount++] = bs->present;
tsi.signalSemaphoreValueCount = si[1].signalSemaphoreCount;
if (VKSCR(EndCommandBuffer)(bs->cmdbuf) != VK_SUCCESS) {
mesa_loge("ZINK: vkEndCommandBuffer failed");
VkResult result = VKSCR(EndCommandBuffer)(bs->cmdbuf);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEndCommandBuffer failed (%s)", vk_Result_to_str(result));
bs->is_device_lost = true;
goto end;
}
if (bs->has_barriers) {
if (VKSCR(EndCommandBuffer)(bs->barrier_cmdbuf) != VK_SUCCESS) {
mesa_loge("ZINK: vkEndCommandBuffer failed");
result = VKSCR(EndCommandBuffer)(bs->barrier_cmdbuf);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEndCommandBuffer failed (%s)", vk_Result_to_str(result));
bs->is_device_lost = true;
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*)) {
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);
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);
if (VKSCR(QueueSubmit)(screen->queue, num_si, num_si == 2 ? si : &si[1], VK_NULL_HANDLE) != VK_SUCCESS) {
mesa_loge("ZINK: vkQueueSubmit failed");
result = VKSCR(QueueSubmit)(screen->queue, num_si, num_si == 2 ? si : &si[1], VK_NULL_HANDLE);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkQueueSubmit failed (%s)", vk_Result_to_str(result));
bs->is_device_lost = true;
}
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>
*/
#include "zink_context.h"
#include "zink_bo.h"
#include "zink_resource.h"
#include "zink_screen.h"
@ -682,7 +683,7 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo)
if (!cpu) {
VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.size, 0, &cpu);
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);
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))
util_queue_finish(&screen->flush_queue);
if (ctx->batch.state && !screen->device_lost && VKSCR(QueueWaitIdle)(screen->queue) != VK_SUCCESS)
mesa_loge("ZINK: vkQueueWaitIdle failed");
if (ctx->batch.state && !screen->device_lost) {
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++) {
hash_table_foreach(&ctx->program_cache[i], entry) {
@ -445,15 +449,17 @@ zink_create_sampler_state(struct pipe_context *pctx,
if (!sampler)
return NULL;
if (VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSampler failed");
VkResult result = VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSampler failed (%s)", vk_Result_to_str(result));
FREE(sampler);
return NULL;
}
if (need_clamped_border_color) {
sci.pNext = &cbci_clamped;
if (VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler_clamped) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSampler failed");
result = VKSCR(CreateSampler)(screen->dev, &sci, NULL, &sampler->sampler_clamped);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSampler failed (%s)", vk_Result_to_str(result));
VKSCR(DestroySampler)(screen->dev, sampler->sampler, NULL);
FREE(sampler);
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);
} else {
VkBufferView view;
if (VKSCR(CreateBufferView)(screen->dev, bvci, NULL, &view) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateBufferView failed");
VkResult result = VKSCR(CreateBufferView)(screen->dev, bvci, NULL, &view);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateBufferView failed (%s)", vk_Result_to_str(result));
goto out;
}
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/list.h"
#include "util/u_dynarray.h"
#include "vk_enum_to_str.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.maxSets = ZINK_DEFAULT_MAX_DESCS;
assert(pool_key->num_type_sizes);
if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool->descpool) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed");
VkResult result = VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool->descpool);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed (%s)", vk_Result_to_str(result));
goto fail;
}
@ -376,8 +377,9 @@ descriptor_layout_create(struct zink_screen *screen, enum zink_descriptor_type t
return VK_NULL_HANDLE;
}
}
if (VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &dsl) != VK_SUCCESS)
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed");
VkResult result = VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &dsl);
if (result != VK_SUCCESS)
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed (%s)", vk_Result_to_str(result));
return dsl;
}
@ -625,8 +627,9 @@ zink_descriptor_util_alloc_sets(struct zink_screen *screen, VkDescriptorSetLayou
layouts[i] = dsl;
dsai.pSetLayouts = layouts;
if (VKSCR(AllocateDescriptorSets)(screen->dev, &dsai, sets) != VK_SUCCESS) {
mesa_loge("ZINK: %" PRIu64 " failed to allocate descriptor set :/", (uint64_t)dsl);
VkResult result = VKSCR(AllocateDescriptorSets)(screen->dev, &dsai, sets);
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 true;
@ -1956,8 +1959,9 @@ zink_descriptors_init_bindless(struct zink_context *ctx)
dcslci.bindingCount = num_bindings;
dcslci.pBindings = bindings;
if (VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &ctx->dd->bindless_layout) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed");
VkResult result = VKSCR(CreateDescriptorSetLayout)(screen->dev, &dcslci, 0, &ctx->dd->bindless_layout);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorSetLayout failed (%s)", vk_Result_to_str(result));
return;
}
@ -1972,8 +1976,9 @@ zink_descriptors_init_bindless(struct zink_context *ctx)
dpci.poolSizeCount = 4;
dpci.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
dpci.maxSets = 1;
if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &ctx->dd->bindless_pool) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed");
result = VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &ctx->dd->bindless_pool);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed (%s)", vk_Result_to_str(result));
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.flags = flags;
dpci.maxSets = MAX_LAZY_DESCRIPTORS;
if (VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed");
VkResult result = VKSCR(CreateDescriptorPool)(screen->dev, &dpci, 0, &pool);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDescriptorPool failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE;
}
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 = """
<%namespace name="helpers" file="helpers"/>
#include "vk_enum_to_str.h"
#include "zink_device_info.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);
// enumerate device supported extensions
if (screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, NULL) != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed");
VkResult result = screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, NULL);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed (%s)", vk_Result_to_str(result));
} else {
if (num_extensions > 0) {
VkExtensionProperties *extensions = MALLOC(sizeof(VkExtensionProperties) * num_extensions);
if (!extensions) goto fail;
if (screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, extensions) != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed");
result = screen->vk.EnumerateDeviceExtensionProperties(screen->pdev, NULL, &num_extensions, extensions);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumerateDeviceExtensionProperties failed (%s)", vk_Result_to_str(result));
}
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;
if (VKSCR(CreateSemaphore)(screen->dev, &sci, NULL, &mfence->sem) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSemaphore failed");
VkResult result = VKSCR(CreateSemaphore)(screen->dev, &sci, NULL, &mfence->sem);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateSemaphore failed (%s)", vk_Result_to_str(result));
FREE(mfence);
return;
}

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

@ -118,9 +118,9 @@ struct pipe_resource;
"""
impl_code = """
#include "vk_enum_to_str.h"
#include "zink_instance.h"
#include "zink_screen.h"
#include "vk_enum_to_str.h"
bool
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_resource.h"
#include "zink_kopper.h"
#include "vk_enum_to_str.h"
static void
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 (util_queue_is_initialized(&screen->flush_queue))
util_queue_finish(&screen->flush_queue);
if (VKSCR(QueueWaitIdle)(screen->queue) != VK_SUCCESS)
debug_printf("vkQueueWaitIdle failed\n");
VkResult result = VKSCR(QueueWaitIdle)(screen->queue);
if (result != VK_SUCCESS)
mesa_loge("ZINK: vkQueueWaitIdle failed (%s)", vk_Result_to_str(result));
zink_kopper_deinit_displaytarget(screen, cdt);
error = VKSCR(CreateSwapchainKHR)(screen->dev, &cswap->scci, NULL,
&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;
VkPipeline pipeline;
if (VKSCR(CreateGraphicsPipelines)(screen->dev, prog->base.pipeline_cache,
1, &pci, NULL, &pipeline) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateGraphicsPipelines failed");
VkResult result = VKSCR(CreateGraphicsPipelines)(screen->dev, prog->base.pipeline_cache,
1, &pci, NULL, &pipeline);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateGraphicsPipelines failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE;
}
@ -417,9 +418,10 @@ zink_create_compute_pipeline(struct zink_screen *screen, struct zink_compute_pro
pci.stage = stage;
VkPipeline pipeline;
if (VKSCR(CreateComputePipelines)(screen->dev, comp->base.pipeline_cache,
1, &pci, NULL, &pipeline) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateComputePipelines failed");
VkResult result = VKSCR(CreateComputePipelines)(screen->dev, comp->base.pipeline_cache,
1, &pci, NULL, &pipeline);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateComputePipelines failed (%s)", vk_Result_to_str(result));
return VK_NULL_HANDLE;
}
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];
VkPipelineLayout layout;
if (VKSCR(CreatePipelineLayout)(screen->dev, &plci, NULL, &layout) != VK_SUCCESS) {
mesa_loge("vkCreatePipelineLayout failed");
VkResult result = VKSCR(CreatePipelineLayout)(screen->dev, &plci, NULL, &layout);
if (result != VK_SUCCESS) {
mesa_loge("vkCreatePipelineLayout failed (%s)", vk_Result_to_str(result));
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);
if (status != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateQueryPool failed");
mesa_loge("ZINK: vkCreateQueryPool failed (%s)", vk_Result_to_str(status));
FREE(new_pool);
return NULL;
}
@ -1254,12 +1254,13 @@ zink_get_query_result_resource(struct pipe_context *pctx,
unsigned src_offset = result_size * get_num_results(query);
if (zink_batch_usage_check_completion(ctx, query->batch_uses)) {
uint64_t u64[4] = {0};
if (VKCTX(GetQueryPoolResults)(screen->dev, start->vkq[0]->pool->query_pool, query_id, 1, sizeof(u64), u64,
0, size_flags | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | flag) == VK_SUCCESS) {
VkResult result = VKCTX(GetQueryPoolResults)(screen->dev, start->vkq[0]->pool->query_pool, query_id, 1,
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);
return;
} 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);
@ -1314,8 +1315,9 @@ zink_get_timestamp(struct pipe_screen *pscreen)
VkCalibratedTimestampInfoEXT cti = {0};
cti.sType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT;
cti.timeDomain = VK_TIME_DOMAIN_DEVICE_EXT;
if (VKSCR(GetCalibratedTimestampsEXT)(screen->dev, 1, &cti, &timestamp, &deviation) != VK_SUCCESS) {
mesa_loge("ZINK: vkGetCalibratedTimestampsEXT failed");
VkResult result = VKSCR(GetCalibratedTimestampsEXT)(screen->dev, 1, &cti, &timestamp, &deviation);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetCalibratedTimestampsEXT failed (%s)", vk_Result_to_str(result));
}
} else {
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;
VkRenderPass render_pass;
if (VKSCR(CreateRenderPass2)(screen->dev, &rpci, NULL, &render_pass) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateRenderPass2 failed");
VkResult result = VKSCR(CreateRenderPass2)(screen->dev, &rpci, NULL, &render_pass);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateRenderPass2 failed (%s)", vk_Result_to_str(result));
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) {
mesa_loge("ZINK: vkCreateImage failed");
mesa_loge("ZINK: vkCreateImage failed (%s)", vk_Result_to_str(result));
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_screen *screen = gdata;
size_t size = 0;
if (VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL) != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPipelineCacheData failed");
VkResult result = VKSCR(GetPipelineCacheData)(screen->dev, pg->pipeline_cache, &size, NULL);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPipelineCacheData failed (%s)", vk_Result_to_str(result));
return;
}
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);
if (!pipeline_data)
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;
cache_key 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);
} 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);
pcci.pInitialData = disk_cache_get(screen->disk_cache, key, &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);
}
@ -1306,7 +1310,7 @@ choose_pdev(struct zink_screen *screen)
bool is_cpu = false;
VkResult result = VKSCR(EnumeratePhysicalDevices)(screen->instance, &pdev_count, NULL);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkEnumeratePhysicalDevices failed");
mesa_loge("ZINK: vkEnumeratePhysicalDevices failed (%s)", vk_Result_to_str(result));
return is_cpu;
}
@ -1573,14 +1577,16 @@ check_have_device_time(struct zink_screen *screen)
{
uint32_t num_domains = 0;
VkTimeDomainEXT domains[8]; //current max is 4
if (VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, NULL) != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed");
VkResult result = VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, NULL);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed (%s)", vk_Result_to_str(result));
}
assert(num_domains > 0);
assert(num_domains < ARRAY_SIZE(domains));
if (VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, domains) != VK_SUCCESS) {
mesa_loge("ZINK: vkGetPhysicalDeviceCalibrateableTimeDomainsEXT failed");
result = VKSCR(GetPhysicalDeviceCalibrateableTimeDomainsEXT)(screen->pdev, &num_domains, domains);
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 */
@ -1654,12 +1660,13 @@ create_debug(struct zink_screen *screen)
VkDebugUtilsMessengerEXT vkDebugUtilsCallbackEXT = VK_NULL_HANDLE;
if (VKSCR(CreateDebugUtilsMessengerEXT)(
VkResult result = VKSCR(CreateDebugUtilsMessengerEXT)(
screen->instance,
&vkDebugUtilsMessengerCreateInfoEXT,
NULL,
&vkDebugUtilsCallbackEXT) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDebugUtilsMessengerEXT failed");
&vkDebugUtilsCallbackEXT);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDebugUtilsMessengerEXT failed (%s)", vk_Result_to_str(result));
}
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,
0, &image_props);
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;
@ -1805,10 +1812,11 @@ zink_get_loader_version(struct zink_screen *screen)
GET_PROC_ADDR_INSTANCE_LOCAL(screen, NULL, EnumerateInstanceVersion);
if (vk_EnumerateInstanceVersion) {
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;
} 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.enabledExtensionCount = screen->info.num_extensions;
if (VKSCR(CreateDevice)(screen->pdev, &dci, NULL, &dev) != VK_SUCCESS) {
mesa_loge("ZINK: vkCreateDevice failed");
}
VkResult result = VKSCR(CreateDevice)(screen->pdev, &dci, NULL, &dev);
if (result != VK_SUCCESS)
mesa_loge("ZINK: vkCreateDevice failed (%s)", vk_Result_to_str(result));
return dev;
}

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

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