Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 1 | /* |
| 2 | * Vulkan |
| 3 | * |
| 4 | * Copyright (C) 2015 LunarG, Inc. |
| 5 | * |
| 6 | * Permission is hereby granted, free of charge, to any person obtaining a |
| 7 | * copy of this software and associated documentation files (the "Software"), |
| 8 | * to deal in the Software without restriction, including without limitation |
| 9 | * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| 10 | * and/or sell copies of the Software, and to permit persons to whom the |
| 11 | * Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included |
| 14 | * in all copies or substantial portions of the Software. |
| 15 | * |
| 16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| 17 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 18 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| 19 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| 20 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| 21 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| 22 | * DEALINGS IN THE SOFTWARE. |
| 23 | * |
| 24 | * Authors: |
| 25 | * Jon Ashburn <jon@lunarg.com> |
| 26 | * Courtney Goeltzenleuchter <courtney@lunarg.com> |
| 27 | */ |
| 28 | |
Courtney Goeltzenleuchter | b620ace | 2015-07-05 11:28:29 -0600 | [diff] [blame^] | 29 | #define _GNU_SOURCE |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 30 | #include <stdio.h> |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 31 | #include <string.h> |
| 32 | #include <stdlib.h> |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 33 | #include <inttypes.h> |
Tony Barbour | 6969851 | 2015-06-18 16:29:32 -0600 | [diff] [blame] | 34 | #ifndef WIN32 |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 35 | #include <alloca.h> |
Tony Barbour | 6969851 | 2015-06-18 16:29:32 -0600 | [diff] [blame] | 36 | #endif |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 37 | #include "debug_report.h" |
Tobin Ehlis | 2d1d970 | 2015-07-03 09:42:57 -0600 | [diff] [blame] | 38 | #include "vk_layer.h" |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 39 | |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 40 | typedef void (VKAPI *PFN_stringCallback)(char *message); |
| 41 | |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 42 | static const struct loader_extension_property debug_report_extension_info = { |
| 43 | .info = { |
Courtney Goeltzenleuchter | 18061cd | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 44 | .extName = DEBUG_REPORT_EXTENSION_NAME, |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 45 | .version = VK_DEBUG_REPORT_EXTENSION_VERSION, |
Courtney Goeltzenleuchter | 18061cd | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 46 | .specVersion = VK_API_VERSION, |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 47 | }, |
| 48 | .origin = VK_EXTENSION_ORIGIN_LOADER, |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 49 | }; |
| 50 | |
| 51 | void debug_report_add_instance_extensions( |
| 52 | struct loader_extension_list *ext_list) |
| 53 | { |
| 54 | loader_add_to_ext_list(ext_list, 1, &debug_report_extension_info); |
| 55 | } |
| 56 | |
| 57 | void debug_report_create_instance( |
Courtney Goeltzenleuchter | 18061cd | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 58 | struct loader_instance *ptr_instance, |
| 59 | const VkInstanceCreateInfo *pCreateInfo) |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 60 | { |
Courtney Goeltzenleuchter | 18061cd | 2015-06-29 15:39:26 -0600 | [diff] [blame] | 61 | ptr_instance->debug_report_enabled = false; |
| 62 | |
| 63 | for (uint32_t i = 0; i < pCreateInfo->extensionCount; i++) { |
| 64 | if (strcmp(pCreateInfo->ppEnabledExtensionNames[i], DEBUG_REPORT_EXTENSION_NAME) == 0) { |
| 65 | ptr_instance->debug_report_enabled = true; |
| 66 | return; |
| 67 | } |
| 68 | } |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | static VkResult debug_report_DbgCreateMsgCallback( |
| 72 | VkInstance instance, |
| 73 | VkFlags msgFlags, |
| 74 | const PFN_vkDbgMsgCallback pfnMsgCallback, |
| 75 | void* pUserData, |
| 76 | VkDbgMsgCallback* pMsgCallback) |
| 77 | { |
| 78 | VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) malloc(sizeof(VkLayerDbgFunctionNode)); |
| 79 | if (!pNewDbgFuncNode) |
| 80 | return VK_ERROR_OUT_OF_HOST_MEMORY; |
| 81 | |
Courtney Goeltzenleuchter | 8afefb5 | 2015-06-08 15:04:02 -0600 | [diff] [blame] | 82 | struct loader_instance *inst = loader_instance(instance); |
Jon Ashburn | b40f256 | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 83 | loader_platform_thread_lock_mutex(&loader_lock); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 84 | VkResult result = inst->disp->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback); |
| 85 | if (result == VK_SUCCESS) { |
| 86 | pNewDbgFuncNode->msgCallback = *pMsgCallback; |
| 87 | pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback; |
| 88 | pNewDbgFuncNode->msgFlags = msgFlags; |
| 89 | pNewDbgFuncNode->pUserData = pUserData; |
| 90 | pNewDbgFuncNode->pNext = inst->DbgFunctionHead; |
| 91 | inst->DbgFunctionHead = pNewDbgFuncNode; |
| 92 | } else { |
| 93 | free(pNewDbgFuncNode); |
| 94 | } |
Jon Ashburn | b40f256 | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 95 | loader_platform_thread_unlock_mutex(&loader_lock); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 96 | return result; |
| 97 | } |
| 98 | |
| 99 | static VkResult debug_report_DbgDestroyMsgCallback( |
| 100 | VkInstance instance, |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 101 | VkDbgMsgCallback msg_callback) |
| 102 | { |
Courtney Goeltzenleuchter | 8afefb5 | 2015-06-08 15:04:02 -0600 | [diff] [blame] | 103 | struct loader_instance *inst = loader_instance(instance); |
Jon Ashburn | b40f256 | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 104 | loader_platform_thread_lock_mutex(&loader_lock); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 105 | VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead; |
| 106 | VkLayerDbgFunctionNode *pPrev = pTrav; |
| 107 | |
Courtney Goeltzenleuchter | 3d8dc1f | 2015-06-08 15:09:22 -0600 | [diff] [blame] | 108 | VkResult result = inst->disp->DbgDestroyMsgCallback(instance, msg_callback); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 109 | |
| 110 | while (pTrav) { |
| 111 | if (pTrav->msgCallback == msg_callback) { |
| 112 | pPrev->pNext = pTrav->pNext; |
| 113 | if (inst->DbgFunctionHead == pTrav) |
| 114 | inst->DbgFunctionHead = pTrav->pNext; |
| 115 | free(pTrav); |
| 116 | break; |
| 117 | } |
| 118 | pPrev = pTrav; |
| 119 | pTrav = pTrav->pNext; |
| 120 | } |
| 121 | |
Jon Ashburn | b40f256 | 2015-05-29 13:15:39 -0600 | [diff] [blame] | 122 | loader_platform_thread_unlock_mutex(&loader_lock); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 123 | return result; |
| 124 | } |
| 125 | |
| 126 | |
| 127 | /* |
| 128 | * This is the instance chain terminator function |
| 129 | * for DbgCreateMsgCallback |
| 130 | */ |
| 131 | VkResult loader_DbgCreateMsgCallback( |
| 132 | VkInstance instance, |
| 133 | VkFlags msgFlags, |
| 134 | const PFN_vkDbgMsgCallback pfnMsgCallback, |
| 135 | const void* pUserData, |
| 136 | VkDbgMsgCallback* pMsgCallback) |
| 137 | { |
| 138 | VkDbgMsgCallback *icd_info; |
| 139 | const struct loader_icd *icd; |
| 140 | struct loader_instance *inst; |
| 141 | VkResult res; |
| 142 | uint32_t storage_idx; |
| 143 | |
| 144 | if (instance == VK_NULL_HANDLE) |
| 145 | return VK_ERROR_INVALID_HANDLE; |
| 146 | |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 147 | for (inst = loader.instances; inst; inst = inst->next) { |
| 148 | if ((VkInstance) inst == instance) |
| 149 | break; |
| 150 | } |
| 151 | |
| 152 | if (inst == VK_NULL_HANDLE) |
| 153 | return VK_ERROR_INVALID_HANDLE; |
| 154 | |
| 155 | icd_info = calloc(sizeof(VkDbgMsgCallback), inst->total_icd_count); |
| 156 | if (!icd_info) { |
| 157 | return VK_ERROR_OUT_OF_HOST_MEMORY; |
| 158 | } |
| 159 | |
| 160 | storage_idx = 0; |
| 161 | for (icd = inst->icds; icd; icd = icd->next) { |
| 162 | if (!icd->DbgCreateMsgCallback) { |
| 163 | continue; |
| 164 | } |
| 165 | |
| 166 | res = icd->DbgCreateMsgCallback( |
| 167 | icd->instance, |
| 168 | msgFlags, |
| 169 | pfnMsgCallback, |
| 170 | pUserData, |
| 171 | &icd_info[storage_idx]); |
| 172 | |
| 173 | if (res != VK_SUCCESS) { |
| 174 | break; |
| 175 | } |
| 176 | storage_idx++; |
| 177 | } |
| 178 | |
| 179 | /* roll back on errors */ |
| 180 | if (icd) { |
| 181 | storage_idx = 0; |
| 182 | for (icd = inst->icds; icd; icd = icd->next) { |
| 183 | if (icd_info[storage_idx]) { |
| 184 | icd->DbgDestroyMsgCallback( |
| 185 | icd->instance, |
| 186 | icd_info[storage_idx]); |
| 187 | } |
| 188 | storage_idx++; |
| 189 | } |
| 190 | |
| 191 | return res; |
| 192 | } |
| 193 | |
| 194 | *pMsgCallback = (VkDbgMsgCallback) icd_info; |
| 195 | |
| 196 | return VK_SUCCESS; |
| 197 | } |
| 198 | |
| 199 | /* |
| 200 | * This is the instance chain terminator function |
| 201 | * for DbgDestroyMsgCallback |
| 202 | */ |
| 203 | VkResult loader_DbgDestroyMsgCallback( |
| 204 | VkInstance instance, |
| 205 | VkDbgMsgCallback msgCallback) |
| 206 | { |
| 207 | uint32_t storage_idx; |
| 208 | VkDbgMsgCallback *icd_info; |
| 209 | const struct loader_icd *icd; |
| 210 | VkResult res = VK_SUCCESS; |
| 211 | struct loader_instance *inst; |
| 212 | |
| 213 | if (instance == VK_NULL_HANDLE) |
| 214 | return VK_ERROR_INVALID_HANDLE; |
| 215 | |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 216 | for (inst = loader.instances; inst; inst = inst->next) { |
| 217 | if ((VkInstance) inst == instance) |
| 218 | break; |
| 219 | } |
| 220 | |
| 221 | if (inst == VK_NULL_HANDLE) |
| 222 | return VK_ERROR_INVALID_HANDLE; |
| 223 | |
| 224 | icd_info = (VkDbgMsgCallback *) msgCallback; |
| 225 | storage_idx = 0; |
| 226 | for (icd = inst->icds; icd; icd = icd->next) { |
| 227 | if (icd_info[storage_idx]) { |
| 228 | icd->DbgDestroyMsgCallback( |
Courtney Goeltzenleuchter | 3d8dc1f | 2015-06-08 15:09:22 -0600 | [diff] [blame] | 229 | icd->instance, |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 230 | icd_info[storage_idx]); |
| 231 | } |
| 232 | storage_idx++; |
| 233 | } |
| 234 | return res; |
| 235 | } |
| 236 | |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 237 | static void print_msg_flags(VkFlags msgFlags, char *msg_flags) |
| 238 | { |
| 239 | bool separator = false; |
| 240 | |
| 241 | msg_flags[0] = 0; |
| 242 | if (msgFlags & VK_DBG_REPORT_DEBUG_BIT) { |
| 243 | strcat(msg_flags, "DEBUG"); |
| 244 | separator = true; |
| 245 | } |
| 246 | if (msgFlags & VK_DBG_REPORT_INFO_BIT) { |
| 247 | if (separator) strcat(msg_flags, ","); |
| 248 | strcat(msg_flags, "INFO"); |
| 249 | separator = true; |
| 250 | } |
| 251 | if (msgFlags & VK_DBG_REPORT_WARN_BIT) { |
| 252 | if (separator) strcat(msg_flags, ","); |
| 253 | strcat(msg_flags, "WARN"); |
| 254 | separator = true; |
| 255 | } |
| 256 | if (msgFlags & VK_DBG_REPORT_PERF_WARN_BIT) { |
| 257 | if (separator) strcat(msg_flags, ","); |
| 258 | strcat(msg_flags, "PERF"); |
| 259 | separator = true; |
| 260 | } |
| 261 | if (msgFlags & VK_DBG_REPORT_ERROR_BIT) { |
| 262 | if (separator) strcat(msg_flags, ","); |
| 263 | strcat(msg_flags, "ERROR"); |
| 264 | } |
| 265 | } |
| 266 | |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 267 | // DebugReport utility callback functions |
| 268 | static void VKAPI StringCallback( |
| 269 | VkFlags msgFlags, |
| 270 | VkObjectType objType, |
| 271 | VkObject srcObject, |
| 272 | size_t location, |
| 273 | int32_t msgCode, |
| 274 | const char* pLayerPrefix, |
| 275 | const char* pMsg, |
| 276 | void* pUserData) |
| 277 | { |
Jon Ashburn | cab27b3 | 2015-06-30 14:44:13 -0700 | [diff] [blame] | 278 | size_t buf_size; |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 279 | char *buf; |
| 280 | char msg_flags[30]; |
| 281 | PFN_stringCallback callback = (PFN_stringCallback) pUserData; |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 282 | |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 283 | print_msg_flags(msgFlags, msg_flags); |
| 284 | |
| 285 | buf_size = strlen(msg_flags) + /* ReportFlags: i.e. (DEBUG,INFO,WARN,PERF,ERROR) */ |
| 286 | 20 + /* objType */ |
| 287 | 20 + /* srcObject */ |
| 288 | 20 + /* location */ |
| 289 | 20 + /* msgCode */ |
| 290 | strlen(pLayerPrefix) + |
| 291 | strlen(pMsg) + |
| 292 | 50 /* other / whitespace */; |
Tony Barbour | 6969851 | 2015-06-18 16:29:32 -0600 | [diff] [blame] | 293 | #ifdef WIN32 |
| 294 | buf = _alloca(buf_size); |
| 295 | #else |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 296 | buf = alloca(buf_size); |
Tony Barbour | 6969851 | 2015-06-18 16:29:32 -0600 | [diff] [blame] | 297 | #endif |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 298 | snprintf(buf, buf_size, "%s (%s): object: 0x%" PRIxLEAST64 " type: %d location: %zu msgCode: %d: %s", |
| 299 | pLayerPrefix, msg_flags, srcObject, objType, location, msgCode, pMsg); |
| 300 | callback(buf); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | static void VKAPI StdioCallback( |
| 304 | VkFlags msgFlags, |
| 305 | VkObjectType objType, |
| 306 | VkObject srcObject, |
| 307 | size_t location, |
| 308 | int32_t msgCode, |
| 309 | const char* pLayerPrefix, |
| 310 | const char* pMsg, |
| 311 | void* pUserData) |
| 312 | { |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 313 | char msg_flags[30]; |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 314 | |
Courtney Goeltzenleuchter | f1eb249 | 2015-06-11 16:01:11 -0600 | [diff] [blame] | 315 | print_msg_flags(msgFlags, msg_flags); |
| 316 | |
| 317 | fprintf((FILE *) pUserData, "%s(%s): object: 0x%" PRIxLEAST64 " type: %d location: %zu msgCode: %d: %s", |
| 318 | pLayerPrefix, msg_flags, srcObject, objType, location, msgCode, pMsg); |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 319 | } |
| 320 | |
| 321 | static void VKAPI BreakCallback( |
| 322 | VkFlags msgFlags, |
| 323 | VkObjectType objType, |
| 324 | VkObject srcObject, |
| 325 | size_t location, |
| 326 | int32_t msgCode, |
| 327 | const char* pLayerPrefix, |
| 328 | const char* pMsg, |
| 329 | void* pUserData) |
| 330 | { |
| 331 | |
| 332 | } |
| 333 | |
| 334 | void *debug_report_instance_gpa( |
| 335 | struct loader_instance *ptr_instance, |
| 336 | const char* name) |
| 337 | { |
| 338 | if (ptr_instance == VK_NULL_HANDLE || !ptr_instance->debug_report_enabled) |
| 339 | return NULL; |
| 340 | |
| 341 | if (!strcmp("vkDbgCreateMsgCallback", name)) |
| 342 | return (void *) debug_report_DbgCreateMsgCallback; |
| 343 | else if (!strcmp("vkDbgDestroyMsgCallback", name)) |
| 344 | return (void *) debug_report_DbgDestroyMsgCallback; |
Jon Ashburn | b843f0b | 2015-05-26 13:56:43 -0600 | [diff] [blame] | 345 | else if (!strcmp("vkDbgStringCallback", name)) |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 346 | return (void *) StringCallback; |
Jon Ashburn | b843f0b | 2015-05-26 13:56:43 -0600 | [diff] [blame] | 347 | else if (!strcmp("vkDbgStdioCallback", name)) |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 348 | return (void *) StdioCallback; |
Jon Ashburn | b843f0b | 2015-05-26 13:56:43 -0600 | [diff] [blame] | 349 | else if (!strcmp("vkDbgBreakCallback", name)) |
Courtney Goeltzenleuchter | 1c7c65d | 2015-06-10 17:39:03 -0600 | [diff] [blame] | 350 | return (void *) BreakCallback; |
| 351 | |
| 352 | return NULL; |
| 353 | } |