loader: Add support for debug report

3 files changed, 143 insertions, 69 deletions

diff --git a/layers/layers_msg.h b/layers/layers_msg.h
index 88208f9b..a5e90de3 100644
--- a/layers/layers_msg.h
+++ b/layers/layers_msg.h
@@ -62,6 +62,8 @@ static VkResult layer_create_msg_callback(
         pNewDbgFuncNode->msgFlags = msgFlags;
         pNewDbgFuncNode->pUserData = pUserData;
         pNewDbgFuncNode->pNext = g_pDbgFunctionHead;
+
+        /* TODO: This should be a per-instance resource */
         g_pDbgFunctionHead = pNewDbgFuncNode;
     } else {
         free(pNewDbgFuncNode);
@@ -94,10 +96,27 @@ static VkResult layer_destroy_msg_callback(
     return result;
 }
 
+static void* msg_callback_get_proc_addr(
+        const char      *funcName)
+{
+    if (!g_DEBUG_REPORT) {
+        return NULL;
+    }
+
+    if (!strcmp(funcName, "vkDbgCreateMsgCallback")) {
+        return (void *) vkDbgCreateMsgCallback;
+    }
+    if (!strcmp(funcName, "vkDbgDestroyMsgCallback")) {
+        return (void *) vkDbgDestroyMsgCallback;
+    }
+
+    return NULL;
+}
+
 // Utility function to handle reporting
 //  If callbacks are enabled, use them, otherwise use printf
 static void layerCbMsg(
-    VkFlags    msgFlags,
+    VkFlags             msgFlags,
     VkObjectType        objectType,
     VkObject            srcObject,
     size_t              location,
@@ -122,65 +141,4 @@ static void layerCbMsg(
         }
         pTrav = pTrav->pNext;
     }
-#if 0
-    if (g_debugAction & (VK_DBG_LAYER_ACTION_LOG_MSG | VK_DBG_LAYER_ACTION_CALLBACK)) {
-        if (msgFlags & VK_DBG_REPORT_ERROR_BIT) {
-            if (g_reportFlags <= VK_DBG_LAYER_LEVEL_ERROR) {
-                if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG) {
-                    fprintf(g_logFile, "{%s}ERROR : %s\n", pLayerPrefix, pMsg);
-                    fflush(g_logFile);
-                }
-                if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK) {
-                    while (pTrav) {
-                        pTrav->pfnMsgCallback(msgFlags,
-                                              objectType, srcObject,
-                                              location,
-                                              msgCode,
-                                              pLayerPrefix,
-                                              pMsg,
-                                              pTrav->pUserData);
-                        pTrav = pTrav->pNext;
-                    }
-                }
-            }
-        }
-        switch (msgType) {
-            case VK_DBG_REPORT_ERROR_BIT:
-                break;
-            case VK_DBG_MSG_WARNING:
-                if (g_reportFlags <= VK_DBG_LAYER_LEVEL_WARN) {
-                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
-                        fprintf(g_logFile, "{%s}WARN : %s\n", pLayerPrefix, pMsg);
-                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
-                        while (pTrav) {
-				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
-                            pTrav = pTrav->pNext;
-                        }
-                }
-                break;
-            case VK_DBG_MSG_PERF_WARNING:
-                if (g_reportFlags <= VK_DBG_LAYER_LEVEL_PERF_WARN) {
-                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
-                        fprintf(g_logFile, "{%s}PERF_WARN : %s\n", pLayerPrefix, pMsg);
-                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
-                        while (pTrav) {
-				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
-                            pTrav = pTrav->pNext;
-                        }
-                }
-                break;
-            default:
-                if (g_reportFlags <= VK_DBG_LAYER_LEVEL_INFO) {
-                    if (g_debugAction & VK_DBG_LAYER_ACTION_LOG_MSG)
-                        fprintf(g_logFile, "{%s}INFO : %s\n", pLayerPrefix, pMsg);
-                    if (g_debugAction & VK_DBG_LAYER_ACTION_CALLBACK)
-                        while (pTrav) {
-				            pTrav->pfnMsgCallback(msgType, validationLevel, srcObject, location, msgCode, pMsg, pTrav->pUserData);
-                            pTrav = pTrav->pNext;
-                        }
-                }
-                break;
-        }
-    }
-#endif
 }
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index 3898a543..85af9c2b 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -863,6 +863,25 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyInstance(VkInstance instance)
     return res;
 }
 
+VkResult VKAPI vkCreateInstance(
+    const VkInstanceCreateInfo*                 pCreateInfo,
+    VkInstance*                                 pInstance)
+{
+    loader_platform_thread_once(&g_initOnce, initMemTracker);
+    /*
+     * For layers, the pInstance has already been filled out
+     * by the loader so that dispatch table is available.
+     */
+    initInstanceTable((const VkBaseLayerObject *) (*pInstance));
+
+    VkResult result = instance_dispatch_table(*pInstance)->CreateInstance(pCreateInfo, pInstance);
+
+    if (result == VK_SUCCESS) {
+        enable_debug_report(pCreateInfo->extensionCount, pCreateInfo->pEnabledExtensions);
+    }
+    return result;
+}
+
 VK_LAYER_EXPORT VkResult VKAPI vkCreateDevice(
     VkPhysicalDevice          gpu,
     const VkDeviceCreateInfo *pCreateInfo,
@@ -922,13 +941,19 @@ struct extProps {
     uint32_t version;
     const char * const name;
 };
-#define MEM_TRACKER_LAYER_EXT_ARRAY_SIZE 1
+#define MEM_TRACKER_LAYER_EXT_ARRAY_SIZE 2
 static const VkExtensionProperties mtExts[MEM_TRACKER_LAYER_EXT_ARRAY_SIZE] = {
     {
         VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
         "MemTracker",
         0x10,
-        "Sample layer: MemTracker",
+        "Validation layer: MemTracker",
+    },
+    {
+        VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
+        "Validation",
+        0x10,
+        "Validation layer: MemTracker",
     }
 };
 
@@ -971,6 +996,45 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo(
     return VK_SUCCESS;
 }
 
+VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
+    VkPhysicalDevice     physical_device,
+    VkExtensionInfoType  infoType,
+    uint32_t             extensionIndex,
+    size_t              *pDataSize,
+    void                *pData)
+{
+    uint32_t *count;
+
+    if (pDataSize == NULL) {
+        return VK_ERROR_INVALID_POINTER;
+    }
+
+    switch (infoType) {
+        case VK_EXTENSION_INFO_TYPE_COUNT:
+            *pDataSize = sizeof(uint32_t);
+            if (pData == NULL) {
+                return VK_SUCCESS;
+            }
+            count = (uint32_t *) pData;
+            *count = MEM_TRACKER_LAYER_EXT_ARRAY_SIZE;
+            break;
+        case VK_EXTENSION_INFO_TYPE_PROPERTIES:
+            *pDataSize = sizeof(VkExtensionProperties);
+            if (pData == NULL) {
+                return VK_SUCCESS;
+            }
+            if (extensionIndex >= MEM_TRACKER_LAYER_EXT_ARRAY_SIZE) {
+                return VK_ERROR_INVALID_VALUE;
+            }
+            memcpy((VkExtensionProperties *) pData, &mtExts[extensionIndex], sizeof(VkExtensionProperties));
+            break;
+        default:
+            return VK_ERROR_INVALID_VALUE;
+    }
+
+    return VK_SUCCESS;
+}
+
 VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(
     VkDevice  device,
     uint32_t  queueNodeIndex,
@@ -1252,6 +1316,10 @@ VK_LAYER_EXPORT VkResult VKAPI vkResetFences(
     uint32_t  fenceCount,
     VkFence  *pFences)
 {
+    /*
+     * TODO: Shouldn't we check for error conditions before passing down the chain?
+     * What if reason result is not VK_SUCCESS is something we could report as a validation error?
+     */
     VkResult result = device_dispatch_table(device)->ResetFences(device, fenceCount, pFences);
     if (VK_SUCCESS == result) {
         loader_platform_thread_lock_mutex(&globalLock);
@@ -2151,6 +2219,8 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
     VkDevice         dev,
     const char       *funcName)
 {
+    void *fptr;
+
     if (dev == NULL) {
         return NULL;
     }
@@ -2296,7 +2366,11 @@ VK_LAYER_EXPORT void* VKAPI vkGetDeviceProcAddr(
         return (void*) vkDestroySwapChainWSI;
     if (!strcmp(funcName, "vkGetSwapChainInfoWSI"))
         return (void*) vkGetSwapChainInfoWSI;
-    else
+
+    fptr = msg_callback_get_proc_addr(funcName);
+    if (fptr)
+        return fptr;
+
     {
         VkLayerDispatchTable **ppDisp = (VkLayerDispatchTable **) dev;
         VkLayerDispatchTable* pTable = tableMap[*ppDisp];
@@ -2310,6 +2384,7 @@ VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(
     VkInstance       instance,
     const char       *funcName)
 {
+    void *fptr;
     if (instance == NULL) {
         return NULL;
     }
@@ -2324,9 +2399,15 @@ VK_LAYER_EXPORT void* VKAPI vkGetInstanceProcAddr(
 
     if (!strcmp(funcName, "vkDestroyInstance"))
         return (void *) vkDestroyInstance;
+    if (!strcmp(funcName, "vkCreateInstance"))
+        return (void*) vkCreateInstance;
     if (!strcmp(funcName, "vkCreateDevice"))
         return (void*) vkCreateDevice;
-    else
+
+    fptr = msg_callback_get_proc_addr(funcName);
+    if (fptr)
+        return fptr;
+
     {
         VkLayerInstanceDispatchTable **ppDisp = (VkLayerInstanceDispatchTable **) instance;
         VkLayerInstanceDispatchTable* pTable = tableInstanceMap[*ppDisp];
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index a27d54e0..fa8f316c 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -193,6 +193,10 @@ void PostCreateInstance(VkResult result, const VkInstanceCreateInfo *pCreateInfo
 
 VK_LAYER_EXPORT VkResult VKAPI vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, VkInstance* pInstance)
 {
+    /* TODO: shouldn't we have initInstanceDispatch here? */
+    loader_platform_thread_once(&initOnce, initParamChecker);
+    initInstanceTable((const VkBaseLayerObject *) (*pInstance));
+
     PreCreateInstance(pCreateInfo->pAppInfo, pCreateInfo->pAllocCb);
     VkResult result = instance_dispatch_table(*pInstance)->CreateInstance(pCreateInfo, pInstance);
     PostCreateInstance(result, pCreateInfo, pInstance);
@@ -327,13 +331,19 @@ VK_LAYER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device)
     return result;
 }
 
-#define PARAM_CHECKER_LAYER_EXT_ARRAY_SIZE 1
+#define PARAM_CHECKER_LAYER_EXT_ARRAY_SIZE 2
 static const VkExtensionProperties pcExts[PARAM_CHECKER_LAYER_EXT_ARRAY_SIZE] = {
     {
         VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
         "ParamChecker",
         0x10,
         "Sample layer: ParamChecker",
+    },
+    {
+        VK_STRUCTURE_TYPE_EXTENSION_PROPERTIES,
+        "Validation",
+        0x10,
+        "Sample layer: ParamChecker",
     }
 };
 
@@ -379,8 +389,33 @@ VK_LAYER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionInfo(
                                                size_t*  pDataSize,
                                                void*    pData)
 {
-    VkResult result = instance_dispatch_table(gpu)->GetPhysicalDeviceExtensionInfo(gpu, infoType, extensionIndex, pDataSize, pData);
-    return result;
+    /* This entrypoint is NOT going to init it's own dispatch table since loader calls here early */
+    uint32_t *count;
+
+    if (pDataSize == NULL)
+        return VK_ERROR_INVALID_POINTER;
+
+    switch (infoType) {
+        case VK_EXTENSION_INFO_TYPE_COUNT:
+            *pDataSize = sizeof(uint32_t);
+            if (pData == NULL)
+                return VK_SUCCESS;
+            count = (uint32_t *) pData;
+            *count = PARAM_CHECKER_LAYER_EXT_ARRAY_SIZE;
+            break;
+        case VK_EXTENSION_INFO_TYPE_PROPERTIES:
+            *pDataSize = sizeof(VkExtensionProperties);
+            if (pData == NULL)
+                return VK_SUCCESS;
+            if (extensionIndex >= PARAM_CHECKER_LAYER_EXT_ARRAY_SIZE)
+                return VK_ERROR_INVALID_VALUE;
+            memcpy((VkExtensionProperties *) pData, &pcExts[extensionIndex], sizeof(VkExtensionProperties));
+            break;
+        default:
+            return VK_ERROR_INVALID_VALUE;
+    };
+
+    return VK_SUCCESS;
 }
 
 VK_LAYER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)