diff --git a/include/vulkan/vk_layer.h b/include/vulkan/vk_layer.h
index 471f8ff..5ac2f7e 100644
--- a/include/vulkan/vk_layer.h
+++ b/include/vulkan/vk_layer.h
@@ -174,8 +174,8 @@
     PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
     PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
     PFN_vkGetPhysicalDeviceSurfacePresentModesKHR GetPhysicalDeviceSurfacePresentModesKHR;
-    PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
-    PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
+    PFN_vkCreateDebugReportCallbackLUNARG CreateDebugReportCallbackLUNARG;
+    PFN_vkDestroyDebugReportCallbackLUNARG DestroyDebugReportCallbackLUNARG;
 #ifdef VK_USE_PLATFORM_MIR_KHR
     PFN_vkCreateMirSurfaceKHR CreateMirSurfaceKHR;
     PFN_vkGetPhysicalDeviceMirPresentationSupportKHR GetPhysicalDeviceMirPresentationSupportKHR;
@@ -205,7 +205,7 @@
 typedef struct VkLayerDbgFunctionNode_
 {
     VkDebugReportCallbackLUNARG msgCallback;
-    PFN_vkDbgMsgCallback pfnMsgCallback;
+    PFN_vkDebugReportCallbackLUNARG pfnMsgCallback;
     VkFlags msgFlags;
     const void *pUserData;
     struct VkLayerDbgFunctionNode_ *pNext;
diff --git a/include/vulkan/vk_lunarg_debug_report.h b/include/vulkan/vk_lunarg_debug_report.h
index 5fc3de0..936625f 100644
--- a/include/vulkan/vk_lunarg_debug_report.h
+++ b/include/vulkan/vk_lunarg_debug_report.h
@@ -110,11 +110,12 @@
 
 #define VK_OBJECT_TYPE_MSG_CALLBACK VK_DEBUG_REPORT_ENUM_EXTEND(VkDebugReportObjectTypeLUNARG, 0)
 #define VK_ERROR_VALIDATION_FAILED VK_DEBUG_REPORT_ENUM_EXTEND(VkResult, 0)
+#define VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG VK_DEBUG_REPORT_ENUM_EXTEND(VkStructureType, 0)
 
 // ------------------------------------------------------------------------------------------------
 // Vulkan function pointers
 
-typedef VkBool32 (*PFN_vkDbgMsgCallback)(
+typedef VkBool32 (*PFN_vkDebugReportCallbackLUNARG)(
     VkFlags                             msgFlags,
     VkDebugReportObjectTypeLUNARG       objType,
     uint64_t                            srcObject,
@@ -124,26 +125,33 @@
     const char*                         pMsg,
     const void*                         pUserData);
 
+typedef struct VkDebugReportCallbackCreateInfoLUNARG {
+    VkStructureType                     sType;
+    const void*                         pNext;
+    VkDebugReportFlagsLUNARG            flags;
+    PFN_vkDebugReportCallbackLUNARG     pfnCallback;
+    const void*                         pUserData;
+} VkDebugReportCallbackCreateInfoLUNARG;
+
 // ------------------------------------------------------------------------------------------------
 // API functions
 
-typedef VkResult (VKAPI_PTR *PFN_vkDbgCreateMsgCallback)(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDebugReportCallbackLUNARG* pMsgCallback);
-typedef VkResult (VKAPI_PTR *PFN_vkDbgDestroyMsgCallback)(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback);
+typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackLUNARG)(VkInstance instance, VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackLUNARG* pCallback);
+typedef VkResult (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackLUNARG)(VkInstance instance, VkDebugReportCallbackLUNARG callback, const VkAllocationCallbacks *pAllocator);
 
 #ifdef VK_PROTOTYPES
 
 // DebugReport extension entrypoints
-VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
-    VkInstance                          instance,
-    VkFlags                             msgFlags,
-    const PFN_vkDbgMsgCallback          pfnMsgCallback,
-    void*                               pUserData,
-    VkDebugReportCallbackLUNARG*        pMsgCallback);
+VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+    VkInstance                                  instance,
+    VkDebugReportCallbackCreateInfoLUNARG*      pCreateInfo,
+    const VkAllocationCallbacks*                pAllocator,
+    VkDebugReportCallbackLUNARG*                pCallback);
 
-VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
-    VkInstance                          instance,
-    VkDebugReportCallbackLUNARG         msgCallback);
-
+VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+    VkInstance                                  instance,
+    VkDebugReportCallbackLUNARG                 callback,
+    const VkAllocationCallbacks*                pAllocator);
 #endif // VK_PROTOTYPES
 
 #ifdef __cplusplus
diff --git a/layers/device_limits.cpp b/layers/device_limits.cpp
index c4e67c2..d57ce6d 100644
--- a/layers/device_limits.cpp
+++ b/layers/device_limits.cpp
@@ -114,12 +114,24 @@
     {
         option_str = getLayerOption("DeviceLimitsLogFilename");
         log_output = getLayerLogOutput(option_str, "DeviceLimits");
-        layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+        memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgCreateInfo.flags = report_flags;
+        dbgCreateInfo.pfnCallback = log_callback;
+        dbgCreateInfo.pUserData = (void *) log_output;
+        layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 
     if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
-        layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+        memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgCreateInfo.flags = report_flags;
+        dbgCreateInfo.pfnCallback = win32_debug_output_msg;
+        dbgCreateInfo.pUserData = NULL;
+        layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 
@@ -191,7 +203,7 @@
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
         VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
-        layer_destroy_msg_callback(my_data->report_data, callback);
+        layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
         my_data->logging_callback.pop_back();
     }
 
@@ -550,29 +562,28 @@
     dev_data->device_dispatch_table->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
-    VkInstance                          instance,
-    VkFlags                             msgFlags,
-    const PFN_vkDbgMsgCallback          pfnMsgCallback,
-    void*                               pUserData,
-    VkDebugReportCallbackLUNARG*                   pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackCreateInfoLUNARG*      pCreateInfo,
+        const VkAllocationCallbacks*                pAllocator,
+        VkDebugReportCallbackLUNARG*                pMsgCallback)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (VK_SUCCESS == res) {
-        res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+        res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
     }
     return res;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
-    VkInstance                          instance,
-    VkDebugReportCallbackLUNARG                    msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackLUNARG                 msgCallback,
+        const VkAllocationCallbacks*                pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
-    layer_destroy_msg_callback(my_data->report_data, msgCallback);
-    return res;
+    my_data->instance_dispatch_table->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice dev, const char* funcName)
diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp
index 5ad5ee4..c2afbdc 100644
--- a/layers/draw_state.cpp
+++ b/layers/draw_state.cpp
@@ -2569,12 +2569,24 @@
     {
         option_str = getLayerOption("DrawStateLogFilename");
         log_output = getLayerLogOutput(option_str, "DrawState");
-        layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = log_callback;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 
     if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
-        layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = win32_debug_output_msg;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 
@@ -2617,7 +2629,7 @@
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
         VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
-        layer_destroy_msg_callback(my_data->report_data, callback);
+        layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
         my_data->logging_callback.pop_back();
     }
 
@@ -5409,29 +5421,30 @@
     return VK_ERROR_VALIDATION_FAILED;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
-    VkInstance                          instance,
-    VkFlags                             msgFlags,
-    const PFN_vkDbgMsgCallback          pfnMsgCallback,
-    void*                               pUserData,
-    VkDebugReportCallbackLUNARG*                   pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackCreateInfoLUNARG*      pCreateInfo,
+        const VkAllocationCallbacks*                pAllocator,
+        VkDebugReportCallbackLUNARG*                pMsgCallback)
 {
     layer_data* my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+    VkResult res = pTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (VK_SUCCESS == res) {
-        res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+        res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
     }
     return res;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
-    VkInstance                          instance,
-    VkDebugReportCallbackLUNARG                    msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackLUNARG                 msgCallback,
+        const VkAllocationCallbacks*                pAllocator)
 {
     layer_data* my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
-    layer_destroy_msg_callback(my_data->report_data, msgCallback);
-    return res;
+    VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
+    pTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDbgMarkerBegin(VkCommandBuffer commandBuffer, const char* pMarker)
diff --git a/layers/image.cpp b/layers/image.cpp
index e489286..cde964a 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -84,39 +84,49 @@
         FILE *log_output = NULL;
         const char* option_str = getLayerOption("ImageLogFilename");
         log_output = getLayerLogOutput(option_str, "Image");
-        layer_create_msg_callback(data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = log_callback;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback);
         data->logging_callback.push_back(callback);
     }
 
     if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
-        layer_create_msg_callback(data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = win32_debug_output_msg;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(data->report_data, &dbgInfo, pAllocator, &callback);
         data->logging_callback.push_back(callback);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
-        VkInstance instance,
-        VkFlags msgFlags,
-        const PFN_vkDbgMsgCallback pfnMsgCallback,
-        void* pUserData,
-        VkDebugReportCallbackLUNARG* pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackCreateInfoLUNARG*      pCreateInfo,
+        const VkAllocationCallbacks*                pAllocator,
+        VkDebugReportCallbackLUNARG*                pMsgCallback)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkResult res = my_data->instance_dispatch_table->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (res == VK_SUCCESS) {
-        res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+        res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
     }
     return res;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
-        VkInstance instance,
-        VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackLUNARG                 msgCallback,
+        const VkAllocationCallbacks*                pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult res = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
-    layer_destroy_msg_callback(my_data->report_data, msgCallback);
-    return res;
+    my_data->instance_dispatch_table->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance)
@@ -145,7 +155,7 @@
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
         VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
-        layer_destroy_msg_callback(my_data->report_data, callback);
+        layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
         my_data->logging_callback.pop_back();
     }
 
diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp
index bd65bcb..62a78ba 100644
--- a/layers/mem_tracker.cpp
+++ b/layers/mem_tracker.cpp
@@ -1010,12 +1010,24 @@
     {
         option_str = getLayerOption("MemTrackerLogFilename");
         log_output = getLayerLogOutput(option_str, "MemTracker");
-        layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = log_callback;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 
     if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
-        layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = win32_debug_output_msg;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 
@@ -1043,7 +1055,7 @@
     // Clean up logging callback, if any
     while (my_data->logging_callback.size() > 0) {
         VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
-        layer_destroy_msg_callback(my_data->report_data, callback);
+        layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
         my_data->logging_callback.pop_back();
     }
 
@@ -2561,32 +2573,30 @@
     my_data->device_dispatch_table->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
-    VkInstance                    instance,
-    VkFlags                       msgFlags,
-    const PFN_vkDbgMsgCallback    pfnMsgCallback,
-    void                         *pUserData,
-    VkDebugReportCallbackLUNARG  *pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackCreateInfoLUNARG*      pCreateInfo,
+        const VkAllocationCallbacks*                pAllocator,
+        VkDebugReportCallbackLUNARG*                pMsgCallback)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    VkResult res =  pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkResult res = pTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (res == VK_SUCCESS) {
-        res = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+        res = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
     }
     return res;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
-        VkInstance       instance,
-        VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
+        VkInstance                                  instance,
+        VkDebugReportCallbackLUNARG                 msgCallback,
+        const VkAllocationCallbacks*                pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
     VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;
-    VkResult res =  pTable->DbgDestroyMsgCallback(instance, msgCallback);
-    layer_destroy_msg_callback(my_data->report_data, msgCallback);
-
-    return res;
+    pTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
diff --git a/layers/object_track.h b/layers/object_track.h
index 1410151..08f36c7 100644
--- a/layers/object_track.h
+++ b/layers/object_track.h
@@ -425,7 +425,13 @@
     {
         option_str = getLayerOption("ObjectTrackerLogFilename");
         log_output = getLayerLogOutput(option_str, "ObjectTracker");
-        layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &(my_data->logging_callback));
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = log_callback;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &my_data->logging_callback);
     }
 
     if (!objLockInitialized)
diff --git a/layers/param_checker.cpp b/layers/param_checker.cpp
index 42068a9..0514bf1 100644
--- a/layers/param_checker.cpp
+++ b/layers/param_checker.cpp
@@ -96,46 +96,58 @@
         FILE *log_output = NULL;
         const char* option_str = getLayerOption("ParamCheckerLogFilename");
         log_output = getLayerLogOutput(option_str, "ParamChecker");
-        layer_create_msg_callback(data->report_data, report_flags, log_callback, (void *) log_output, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+        memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgCreateInfo.flags = report_flags;
+        dbgCreateInfo.pfnCallback = log_callback;
+        dbgCreateInfo.pUserData = log_output;
+
+        layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator, &callback);
         data->logging_callback.push_back(callback);
     }
 
     if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
-        layer_create_msg_callback(data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+        memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgCreateInfo.flags = report_flags;
+        dbgCreateInfo.pfnCallback = win32_debug_output_msg;
+        dbgCreateInfo.pUserData = NULL;
+
+        layer_create_msg_callback(data->report_data, &dbgCreateInfo, pAllocator, &callback);
         data->logging_callback.push_back(callback);
     }
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(
     VkInstance instance,
-    VkFlags msgFlags,
-    const PFN_vkDbgMsgCallback pfnMsgCallback,
-    void* pUserData,
+    VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+    const VkAllocationCallbacks *pAllocator,
     VkDebugReportCallbackLUNARG* pMsgCallback)
 {
     VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
-    VkResult result =  pTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkResult result =  pTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
 
     if (result == VK_SUCCESS)
     {
         layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-        result = layer_create_msg_callback(data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+        result = layer_create_msg_callback(data->report_data, pCreateInfo, pAllocator, pMsgCallback);
     }
 
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(
     VkInstance instance,
-    VkDebugReportCallbackLUNARG msgCallback)
+    VkDebugReportCallbackLUNARG msgCallback,
+    const VkAllocationCallbacks *pAllocator)
 {
     VkLayerInstanceDispatchTable *pTable = get_dispatch_table(pc_instance_table_map, instance);
-    VkResult result =  pTable->DbgDestroyMsgCallback(instance, msgCallback);
+    pTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
 
     layer_data *data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    layer_destroy_msg_callback(data->report_data, msgCallback);
-
-    return result;
+    layer_destroy_msg_callback(data->report_data, msgCallback, pAllocator);
 }
 
 static const VkLayerProperties pc_global_layers[] = {
@@ -1760,7 +1772,7 @@
     layer_data *my_data = get_my_data_ptr(key, layer_data_map);
     while (my_data->logging_callback.size() > 0) {
         VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
-        layer_destroy_msg_callback(my_data->report_data, callback);
+        layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
         my_data->logging_callback.pop_back();
     }
 
diff --git a/layers/swapchain.cpp b/layers/swapchain.cpp
index 4c41928..2b8ed24 100644
--- a/layers/swapchain.cpp
+++ b/layers/swapchain.cpp
@@ -126,13 +126,26 @@
         // Turn on logging, since it was requested:
         option_str = getLayerOption("SwapchainLogFilename");
         log_output = getLayerLogOutput(option_str, "Swapchain");
-        layer_create_msg_callback(my_data->report_data, report_flags,
-                                  log_callback, (void *) log_output,
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = log_callback;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data,
+                                  &dbgInfo,
+                                  pAllocator,
                                   &callback);
         my_data->logging_callback.push_back(callback);
     }
     if (debug_action & VK_DBG_LAYER_ACTION_DEBUG_OUTPUT) {
-        layer_create_msg_callback(my_data->report_data, report_flags, win32_debug_output_msg, NULL, &callback);
+        VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+        memset(&dbgInfo, 0, sizeof(dbgInfo));
+        dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+        dbgInfo.pfnCallback = win32_debug_output_msg;
+        dbgInfo.pUserData = log_output;
+        dbgInfo.flags = report_flags;
+        layer_create_msg_callback(my_data->report_data, &dbgInfo, pAllocator, &callback);
         my_data->logging_callback.push_back(callback);
     }
 }
@@ -210,7 +223,7 @@
         // Clean up logging callback, if any
         while (my_data->logging_callback.size() > 0) {
             VkDebugReportCallbackLUNARG callback = my_data->logging_callback.back();
-            layer_destroy_msg_callback(my_data->report_data, callback);
+            layer_destroy_msg_callback(my_data->report_data, callback, pAllocator);
             my_data->logging_callback.pop_back();
         }
         layer_debug_report_destroy_instance(my_data->report_data);
@@ -1113,22 +1126,21 @@
     return NULL;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDebugReportCallbackLUNARG* pMsgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(VkInstance instance, VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackLUNARG* pMsgCallback)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult result = my_data->instance_dispatch_table->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkResult result = my_data->instance_dispatch_table->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pMsgCallback);
     if (VK_SUCCESS == result) {
-        result = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+        result = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pMsgCallback);
     }
     return result;
 }
 
-VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback)
+VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback, const VkAllocationCallbacks *pAllocator)
 {
     layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);
-    VkResult result = my_data->instance_dispatch_table->DbgDestroyMsgCallback(instance, msgCallback);
-    layer_destroy_msg_callback(my_data->report_data, msgCallback);
-    return result;
+    my_data->instance_dispatch_table->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);
+    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);
 }
 
 VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(VkDevice device, const char* funcName)
diff --git a/layers/vk_layer_config.cpp b/layers/vk_layer_config.cpp
index 6d09a18..4ca7b2c 100755
--- a/layers/vk_layer_config.cpp
+++ b/layers/vk_layer_config.cpp
@@ -121,9 +121,9 @@
     return log_output;
 }
 
-uint32_t getLayerOptionFlags(const char *_option, uint32_t optionDefault)
+VkDebugReportFlagsLUNARG getLayerOptionFlags(const char *_option, uint32_t optionDefault)
 {
-    uint32_t flags = optionDefault;
+    VkDebugReportFlagsLUNARG flags = optionDefault;
     const char *option = (g_configFileObj.getOption(_option));
 
     /* parse comma-separated options */
diff --git a/layers/vk_layer_config.h b/layers/vk_layer_config.h
index c1fa1e1..167aaf6 100644
--- a/layers/vk_layer_config.h
+++ b/layers/vk_layer_config.h
@@ -32,7 +32,7 @@
 
 const char *getLayerOption(const char *_option);
 FILE* getLayerLogOutput(const char *_option, const char *layerName);
-uint32_t getLayerOptionFlags(const char *_option, uint32_t optionDefault);
+VkDebugReportFlagsLUNARG getLayerOptionFlags(const char *_option, uint32_t optionDefault);
 bool getLayerOptionEnum(const char *_option, uint32_t *optionDefault);
 
 void setLayerOption(const char *_option, const char *_val);
diff --git a/layers/vk_layer_logging.h b/layers/vk_layer_logging.h
index b603da8..325b3f0 100644
--- a/layers/vk_layer_logging.h
+++ b/layers/vk_layer_logging.h
@@ -88,8 +88,8 @@
     debug_report_data              *debug_data;
     PFN_vkGetInstanceProcAddr gpa = table->GetInstanceProcAddr;
 
-    table->DbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) gpa(inst, "vkDbgCreateMsgCallback");
-    table->DbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) gpa(inst, "vkDbgDestroyMsgCallback");
+    table->CreateDebugReportCallbackLUNARG = (PFN_vkCreateDebugReportCallbackLUNARG) gpa(inst, "vkCreateDebugReportCallbackLUNARG");
+    table->DestroyDebugReportCallbackLUNARG = (PFN_vkDestroyDebugReportCallbackLUNARG) gpa(inst, "vkDestroyDebugReportCallbackLUNARG");
 
     debug_data = (debug_report_data *) malloc(sizeof(debug_report_data));
     if (!debug_data) return NULL;
@@ -148,31 +148,31 @@
 }
 
 static inline VkResult layer_create_msg_callback(
-        debug_report_data              *debug_data,
-        VkFlags                         msgFlags,
-        const PFN_vkDbgMsgCallback      pfnMsgCallback,
-        void                           *pUserData,
-        VkDebugReportCallbackLUNARG               *pMsgCallback)
+        debug_report_data                     *debug_data,
+        VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+        const VkAllocationCallbacks           *pAllocator,
+        VkDebugReportCallbackLUNARG           *pCallback)
 {
+    /* TODO: Use app allocator */
     VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode*)malloc(sizeof(VkLayerDbgFunctionNode));
     if (!pNewDbgFuncNode)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
 
     // Handle of 0 is logging_callback so use allocated Node address as unique handle
-    if (!(*pMsgCallback))
-        *pMsgCallback = (VkDebugReportCallbackLUNARG) pNewDbgFuncNode;
-    pNewDbgFuncNode->msgCallback = *pMsgCallback;
-    pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
-    pNewDbgFuncNode->msgFlags = msgFlags;
-    pNewDbgFuncNode->pUserData = pUserData;
+    if (!(*pCallback))
+        *pCallback = (VkDebugReportCallbackLUNARG) pNewDbgFuncNode;
+    pNewDbgFuncNode->msgCallback = *pCallback;
+    pNewDbgFuncNode->pfnMsgCallback = pCreateInfo->pfnCallback;
+    pNewDbgFuncNode->msgFlags = pCreateInfo->flags;
+    pNewDbgFuncNode->pUserData = pCreateInfo->pUserData;
     pNewDbgFuncNode->pNext = debug_data->g_pDbgFunctionHead;
 
     debug_data->g_pDbgFunctionHead = pNewDbgFuncNode;
-    debug_data->active_flags |= msgFlags;
+    debug_data->active_flags |= pCreateInfo->flags;
 
     debug_report_log_msg(
                 debug_data, VK_DEBUG_REPORT_DEBUG_BIT,
-                VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pMsgCallback,
+                VK_OBJECT_TYPE_MSG_CALLBACK, (uint64_t) *pCallback,
                 0, DEBUG_REPORT_CALLBACK_REF,
                 "DebugReport",
                 "Added callback");
@@ -181,7 +181,8 @@
 
 static inline void layer_destroy_msg_callback(
         debug_report_data              *debug_data,
-        VkDebugReportCallbackLUNARG                msg_callback)
+        VkDebugReportCallbackLUNARG     callback,
+        const VkAllocationCallbacks    *pAllocator)
 {
     VkLayerDbgFunctionNode *pTrav = debug_data->g_pDbgFunctionHead;
     VkLayerDbgFunctionNode *pPrev = pTrav;
@@ -189,7 +190,7 @@
 
     debug_data->active_flags = 0;
     while (pTrav) {
-        if (pTrav->msgCallback == msg_callback) {
+        if (pTrav->msgCallback == callback) {
             matched = true;
             pPrev->pNext = pTrav->pNext;
             if (debug_data->g_pDbgFunctionHead == pTrav) {
@@ -208,6 +209,7 @@
         pPrev = pTrav;
         pTrav = pTrav->pNext;
         if (matched) {
+            /* TODO: Use pAllocator */
             free(pPrev);
         }
     }
@@ -221,11 +223,11 @@
         return NULL;
     }
 
-    if (!strcmp(funcName, "vkDbgCreateMsgCallback")) {
-        return (PFN_vkVoidFunction) vkDbgCreateMsgCallback;
+    if (!strcmp(funcName, "vkCreateDebugReportCallbackLUNARG")) {
+        return (PFN_vkVoidFunction) vkCreateDebugReportCallbackLUNARG;
     }
-    if (!strcmp(funcName, "vkDbgDestroyMsgCallback")) {
-        return (PFN_vkVoidFunction) vkDbgDestroyMsgCallback;
+    if (!strcmp(funcName, "vkDestroyDebugReportCallbackLUNARG")) {
+        return (PFN_vkVoidFunction) vkDestroyDebugReportCallbackLUNARG;
     }
 
     return NULL;
@@ -294,7 +296,7 @@
 
 static inline VKAPI_ATTR VkBool32 VKAPI_CALL log_callback(
     VkFlags                             msgFlags,
-    VkDebugReportObjectTypeLUNARG                     objType,
+    VkDebugReportObjectTypeLUNARG       objType,
     uint64_t                            srcObject,
     size_t                              location,
     int32_t                             msgCode,
@@ -315,7 +317,7 @@
 
 static inline VKAPI_ATTR VkBool32 VKAPI_CALL win32_debug_output_msg(
     VkFlags                             msgFlags,
-    VkDebugReportObjectTypeLUNARG                     objType,
+    VkDebugReportObjectTypeLUNARG       objType,
     uint64_t                            srcObject,
     size_t                              location,
     int32_t                             msgCode,
diff --git a/layers/vk_layer_settings.txt b/layers/vk_layer_settings.txt
index 1aee14f..5634c9b 100644
--- a/layers/vk_layer_settings.txt
+++ b/layers/vk_layer_settings.txt
@@ -14,7 +14,7 @@
 #  VK_DBG_LAYER_ACTION_LOG_MSG - Log a txt message to stdout or to a log file
 #     specified via the <LayerName>LogFilename setting (see below)
 #  VK_DBG_LAYER_ACTION_CALLBACK - Call user defined callback function(s) that
-#     have been registered via the vkDbgCreateMsgCallback() extension. Since
+#     have been registered via the VK_EXT_LUNARG_debug_report extension. Since
 #     app must register callback, this is a NOOP for the settings file.
 #  VK_DBG_LAYER_ACTION_BREAK - Trigger a breakpoint.
 #
diff --git a/loader/debug_report.c b/loader/debug_report.c
index b7057e6..f6b3a31 100644
--- a/loader/debug_report.c
+++ b/loader/debug_report.c
@@ -65,12 +65,11 @@
     }
 }
 
-static VKAPI_ATTR VkResult VKAPI_CALL debug_report_DbgCreateMsgCallback(
+static VKAPI_ATTR VkResult VKAPI_CALL debug_report_CreateDebugReportCallback(
         VkInstance instance,
-        VkFlags msgFlags,
-        const PFN_vkDbgMsgCallback pfnMsgCallback,
-        void* pUserData,
-        VkDebugReportCallbackLUNARG* pMsgCallback)
+        VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+        VkAllocationCallbacks *pAllocator,
+        VkDebugReportCallbackLUNARG* pCallback)
 {
     VkLayerDbgFunctionNode *pNewDbgFuncNode = (VkLayerDbgFunctionNode *) loader_heap_alloc((struct loader_instance *)instance, sizeof(VkLayerDbgFunctionNode), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (!pNewDbgFuncNode)
@@ -78,12 +77,12 @@
 
     struct loader_instance *inst = loader_get_instance(instance);
     loader_platform_thread_lock_mutex(&loader_lock);
-    VkResult result = inst->disp->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);
+    VkResult result = inst->disp->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pCallback);
     if (result == VK_SUCCESS) {
-        pNewDbgFuncNode->msgCallback = *pMsgCallback;
-        pNewDbgFuncNode->pfnMsgCallback = pfnMsgCallback;
-        pNewDbgFuncNode->msgFlags = msgFlags;
-        pNewDbgFuncNode->pUserData = pUserData;
+        pNewDbgFuncNode->msgCallback = *pCallback;
+        pNewDbgFuncNode->pfnMsgCallback = pCreateInfo->pfnCallback;
+        pNewDbgFuncNode->msgFlags = pCreateInfo->flags;
+        pNewDbgFuncNode->pUserData = pCreateInfo->pUserData;
         pNewDbgFuncNode->pNext = inst->DbgFunctionHead;
         inst->DbgFunctionHead = pNewDbgFuncNode;
     } else {
@@ -93,19 +92,20 @@
     return result;
 }
 
-static VKAPI_ATTR VkResult VKAPI_CALL debug_report_DbgDestroyMsgCallback(
+static VKAPI_ATTR VkResult VKAPI_CALL debug_report_DestroyDebugReportCallback(
         VkInstance instance,
-        VkDebugReportCallbackLUNARG msg_callback)
+        VkDebugReportCallbackLUNARG callback,
+        VkAllocationCallbacks *pAllocator)
 {
     struct loader_instance *inst = loader_get_instance(instance);
     loader_platform_thread_lock_mutex(&loader_lock);
     VkLayerDbgFunctionNode *pTrav = inst->DbgFunctionHead;
     VkLayerDbgFunctionNode *pPrev = pTrav;
 
-    VkResult result = inst->disp->DbgDestroyMsgCallback(instance, msg_callback);
+    VkResult result = inst->disp->DestroyDebugReportCallbackLUNARG(instance, callback, pAllocator);
 
     while (pTrav) {
-        if (pTrav->msgCallback == msg_callback) {
+        if (pTrav->msgCallback == callback) {
             pPrev->pNext = pTrav->pNext;
             if (inst->DbgFunctionHead == pTrav)
                 inst->DbgFunctionHead = pTrav->pNext;
@@ -123,15 +123,14 @@
 
 /*
  * This is the instance chain terminator function
- * for DbgCreateMsgCallback
+ * for CreateDebugReportCallback
  */
 
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgCreateMsgCallback(
-        VkInstance                          instance,
-        VkFlags                             msgFlags,
-        const PFN_vkDbgMsgCallback          pfnMsgCallback,
-        void*                               pUserData,
-        VkDebugReportCallbackLUNARG*                   pMsgCallback)
+VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDebugReportCallback(
+        VkInstance                             instance,
+        VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+        const VkAllocationCallbacks           *pAllocator,
+        VkDebugReportCallbackLUNARG           *pCallback)
 {
     VkDebugReportCallbackLUNARG *icd_info;
     const struct loader_icd *icd;
@@ -151,16 +150,15 @@
 
     storage_idx = 0;
     for (icd = inst->icds; icd; icd = icd->next) {
-        if (!icd->DbgCreateMsgCallback) {
+        if (!icd->CreateDebugReportCallbackLUNARG) {
             continue;
         }
 
-        res = icd->DbgCreateMsgCallback(
-                  icd->instance,
-                  msgFlags,
-                  pfnMsgCallback,
-                  pUserData,
-                  &icd_info[storage_idx]);
+        res = icd->CreateDebugReportCallbackLUNARG(
+                    icd->instance,
+                    pCreateInfo,
+                    pAllocator,
+                    &icd_info[storage_idx]);
 
         if (res != VK_SUCCESS) {
             break;
@@ -173,9 +171,10 @@
         storage_idx = 0;
         for (icd = inst->icds; icd; icd = icd->next) {
             if (icd_info[storage_idx]) {
-                icd->DbgDestroyMsgCallback(
+                icd->DestroyDebugReportCallbackLUNARG(
                       icd->instance,
-                      icd_info[storage_idx]);
+                      icd_info[storage_idx],
+                      pAllocator);
             }
             storage_idx++;
         }
@@ -183,18 +182,17 @@
         return res;
     }
 
-    *(VkDebugReportCallbackLUNARG **)pMsgCallback = icd_info;
+    *(VkDebugReportCallbackLUNARG **)pCallback = icd_info;
 
     return VK_SUCCESS;
 }
 
 /*
  * This is the instance chain terminator function
- * for DbgDestroyMsgCallback
+ * for DestroyDebugReportCallback
  */
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgDestroyMsgCallback(
-        VkInstance instance,
-        VkDebugReportCallbackLUNARG msgCallback)
+VKAPI_ATTR VkResult VKAPI_CALL loader_DestroyDebugReportCallback(VkInstance instance,
+        VkDebugReportCallbackLUNARG callback, const VkAllocationCallbacks *pAllocator)
 {
     uint32_t storage_idx;
     VkDebugReportCallbackLUNARG *icd_info;
@@ -207,13 +205,14 @@
             break;
     }
 
-    icd_info = *(VkDebugReportCallbackLUNARG **) &msgCallback;
+    icd_info = *(VkDebugReportCallbackLUNARG **) &callback;
     storage_idx = 0;
     for (icd = inst->icds; icd; icd = icd->next) {
         if (icd_info[storage_idx]) {
-            icd->DbgDestroyMsgCallback(
+            icd->DestroyDebugReportCallbackLUNARG(
                   icd->instance,
-                  icd_info[storage_idx]);
+                  icd_info[storage_idx],
+                  pAllocator);
         }
         storage_idx++;
     }
@@ -229,12 +228,12 @@
     // so always return the entry points if name matches and it's enabled
     *addr = NULL;
 
-    if (!strcmp("vkDbgCreateMsgCallback", name)) {
-        *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DbgCreateMsgCallback : NULL;
+    if (!strcmp("vkCreateDebugReportCallbackLUNARG", name)) {
+        *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_CreateDebugReportCallback : NULL;
         return true;
     }
-    if (!strcmp("vkDbgDestroyMsgCallback", name)) {
-        *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DbgDestroyMsgCallback : NULL;
+    if (!strcmp("vkDestroyDebugReportCallbackLUNARG", name)) {
+        *addr = ptr_instance->debug_report_enabled ? (void *) debug_report_DestroyDebugReportCallback : NULL;
         return true;
     }
     return false;
diff --git a/loader/debug_report.h b/loader/debug_report.h
index a6107a7..8210021 100644
--- a/loader/debug_report.h
+++ b/loader/debug_report.h
@@ -102,13 +102,13 @@
         const char* name,
         void **addr);
 
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgCreateMsgCallback(
-    VkInstance                          instance,
-    VkFlags                             msgFlags,
-    const PFN_vkDbgMsgCallback          pfnMsgCallback,
-    void*                               pUserData,
-    VkDebugReportCallbackLUNARG*                   pMsgCallback);
+VKAPI_ATTR VkResult VKAPI_CALL loader_CreateDebugReportCallback(
+        VkInstance                             instance,
+        VkDebugReportCallbackCreateInfoLUNARG *pCreateInfo,
+        const VkAllocationCallbacks           *pAllocator,
+        VkDebugReportCallbackLUNARG           *pCallback);
 
-VKAPI_ATTR VkResult VKAPI_CALL loader_DbgDestroyMsgCallback(
-    VkInstance                          instance,
-    VkDebugReportCallbackLUNARG                    msgCallback);
+VKAPI_ATTR VkResult VKAPI_CALL loader_DestroyDebugReportCallback(
+    VkInstance                                 instance,
+    VkDebugReportCallbackLUNARG                callback,
+    const VkAllocationCallbacks               *pAllocator);
diff --git a/loader/loader.c b/loader/loader.c
index 5673be4..6e37f06 100644
--- a/loader/loader.c
+++ b/loader/loader.c
@@ -114,8 +114,8 @@
     .GetPhysicalDeviceSurfaceCapabilitiesKHR = loader_GetPhysicalDeviceSurfaceCapabilitiesKHR,
     .GetPhysicalDeviceSurfaceFormatsKHR = loader_GetPhysicalDeviceSurfaceFormatsKHR,
     .GetPhysicalDeviceSurfacePresentModesKHR = loader_GetPhysicalDeviceSurfacePresentModesKHR,
-    .DbgCreateMsgCallback = loader_DbgCreateMsgCallback,
-    .DbgDestroyMsgCallback = loader_DbgDestroyMsgCallback,
+    .CreateDebugReportCallbackLUNARG = loader_CreateDebugReportCallback,
+    .DestroyDebugReportCallbackLUNARG = loader_DestroyDebugReportCallback,
 #ifdef VK_USE_PLATFORM_MIR_KHR
     .CreateMirSurfaceKHR = loader_CreateMirSurfaceKHR,
     .GetPhysicalDeviceMirPresentationSupportKHR = loader_GetPhysicalDeviceMirPresentationSupportKHR,
@@ -1341,8 +1341,8 @@
     LOOKUP_GIPA(GetPhysicalDeviceQueueFamilyProperties, true);
     LOOKUP_GIPA(EnumerateDeviceExtensionProperties, true);
     LOOKUP_GIPA(GetPhysicalDeviceSparseImageFormatProperties, true);
-    LOOKUP_GIPA(DbgCreateMsgCallback, false);
-    LOOKUP_GIPA(DbgDestroyMsgCallback, false);
+    LOOKUP_GIPA(CreateDebugReportCallbackLUNARG, false);
+    LOOKUP_GIPA(DestroyDebugReportCallbackLUNARG, false);
     LOOKUP_GIPA(GetPhysicalDeviceSurfaceSupportKHR, false);
     LOOKUP_GIPA(GetPhysicalDeviceSurfaceCapabilitiesKHR, false);
     LOOKUP_GIPA(GetPhysicalDeviceSurfaceFormatsKHR, false);
diff --git a/loader/loader.h b/loader/loader.h
index 2b44de3..0c0c94a 100644
--- a/loader/loader.h
+++ b/loader/loader.h
@@ -188,8 +188,8 @@
     PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties;
     PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
     PFN_vkGetPhysicalDeviceSparseImageFormatProperties GetPhysicalDeviceSparseImageFormatProperties;
-    PFN_vkDbgCreateMsgCallback DbgCreateMsgCallback;
-    PFN_vkDbgDestroyMsgCallback DbgDestroyMsgCallback;
+    PFN_vkCreateDebugReportCallbackLUNARG CreateDebugReportCallbackLUNARG;
+    PFN_vkDestroyDebugReportCallbackLUNARG DestroyDebugReportCallbackLUNARG;
     PFN_vkGetPhysicalDeviceSurfaceSupportKHR GetPhysicalDeviceSurfaceSupportKHR;
     PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR GetPhysicalDeviceSurfaceCapabilitiesKHR;
     PFN_vkGetPhysicalDeviceSurfaceFormatsKHR GetPhysicalDeviceSurfaceFormatsKHR;
diff --git a/loader/table_ops.h b/loader/table_ops.h
index ed9f8d6..7cbb51c 100644
--- a/loader/table_ops.h
+++ b/loader/table_ops.h
@@ -468,9 +468,9 @@
         PFN_vkGetInstanceProcAddr gpa,
         VkInstance inst)
 {
-    table->DbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) gpa(inst, "vkDbgCreateMsgCallback");
-    table->DbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) gpa(inst, "vkDbgDestroyMsgCallback");
     table->DestroySurfaceKHR = (PFN_vkDestroySurfaceKHR) gpa(inst, "vkDestroySurfaceKHR");
+    table->CreateDebugReportCallbackLUNARG = (PFN_vkCreateDebugReportCallbackLUNARG) gpa(inst, "vkCreateDebugReportCallbackLUNARG");
+    table->DestroyDebugReportCallbackLUNARG = (PFN_vkDestroyDebugReportCallbackLUNARG) gpa(inst, "vkDestroyDebugReportCallbackLUNARG");
     table->GetPhysicalDeviceSurfaceSupportKHR = (PFN_vkGetPhysicalDeviceSurfaceSupportKHR) gpa(inst, "vkGetPhysicalDeviceSurfaceSupportKHR");
     table->GetPhysicalDeviceSurfaceCapabilitiesKHR = (PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR) gpa(inst, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
     table->GetPhysicalDeviceSurfaceFormatsKHR = (PFN_vkGetPhysicalDeviceSurfaceFormatsKHR) gpa(inst, "vkGetPhysicalDeviceSurfaceFormatsKHR");
@@ -571,10 +571,10 @@
     if (!strcmp(name, "GetPhysicalDeviceXlibPresentationSupportKHR"))
         return (void *) table->GetPhysicalDeviceXlibPresentationSupportKHR;
 #endif
-    if (!strcmp(name, "DbgCreateMsgCallback"))
-        return (void *) table->DbgCreateMsgCallback;
-    if (!strcmp(name, "DbgDestroyMsgCallback"))
-        return (void *) table->DbgDestroyMsgCallback;
+    if (!strcmp(name, "CreateDebugReportCallbackLUNARG"))
+        return (void *) table->CreateDebugReportCallbackLUNARG;
+    if (!strcmp(name, "DestroyDebugReportCallbackLUNARG"))
+        return (void *) table->DestroyDebugReportCallbackLUNARG;
 
     return NULL;
 }
diff --git a/tests/vkrenderframework.cpp b/tests/vkrenderframework.cpp
index c0a824e..9333819 100644
--- a/tests/vkrenderframework.cpp
+++ b/tests/vkrenderframework.cpp
@@ -47,8 +47,8 @@
     m_depth_clear_color( 1.0 ),
     m_stencil_clear_color( 0 ),
     m_depthStencil( NULL ),
-    m_dbgCreateMsgCallback( VK_NULL_HANDLE ),
-    m_dbgDestroyMsgCallback( VK_NULL_HANDLE ),
+    m_CreateDebugReportCallback( VK_NULL_HANDLE ),
+    m_DestroyDebugReportCallback( VK_NULL_HANDLE ),
     m_globalMsgCallback( VK_NULL_HANDLE ),
     m_devMsgCallback( VK_NULL_HANDLE )
 {
@@ -86,7 +86,7 @@
         std::vector<const char *> device_layer_names,
         std::vector<const char *> instance_extension_names,
         std::vector<const char *> device_extension_names,
-        PFN_vkDbgMsgCallback dbgFunction,
+        PFN_vkDebugReportCallbackLUNARG dbgFunction,
         void *userData)
 {
     VkInstanceCreateInfo instInfo = {};
@@ -113,18 +113,24 @@
     ASSERT_VK_SUCCESS(err);
     ASSERT_GE(this->gpu_count, (uint32_t) 1) << "No GPU available";
     if (dbgFunction) {
-        m_dbgCreateMsgCallback = (PFN_vkDbgCreateMsgCallback) vkGetInstanceProcAddr(this->inst, "vkDbgCreateMsgCallback");
-        ASSERT_NE(m_dbgCreateMsgCallback, (PFN_vkDbgCreateMsgCallback) NULL) << "Did not get function pointer for DbgCreateMsgCallback";
-        if (m_dbgCreateMsgCallback) {
-            err = m_dbgCreateMsgCallback(this->inst,
-                                         VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT | VK_DEBUG_REPORT_PERF_WARN_BIT,
-                                         dbgFunction,
-                                         userData,
+        m_CreateDebugReportCallback = (PFN_vkCreateDebugReportCallbackLUNARG) vkGetInstanceProcAddr(this->inst, "vkCreateDebugReportCallbackLUNARG");
+        ASSERT_NE(m_CreateDebugReportCallback, (PFN_vkCreateDebugReportCallbackLUNARG) NULL) << "Did not get function pointer for CreateDebugReportCallback";
+        if (m_CreateDebugReportCallback) {
+            VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;
+            memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));
+            dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+            dbgCreateInfo.flags = VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT | VK_DEBUG_REPORT_PERF_WARN_BIT;
+            dbgCreateInfo.pfnCallback = dbgFunction;
+            dbgCreateInfo.pUserData = userData;
+
+            err = m_CreateDebugReportCallback(this->inst,
+                                         &dbgCreateInfo,
+                                         NULL,
                                          &m_globalMsgCallback);
             ASSERT_VK_SUCCESS(err);
 
-            m_dbgDestroyMsgCallback = (PFN_vkDbgDestroyMsgCallback) vkGetInstanceProcAddr(this->inst, "vkDbgDestroyMsgCallback");
-            ASSERT_NE(m_dbgDestroyMsgCallback, (PFN_vkDbgDestroyMsgCallback) NULL) << "Did not get function pointer for DbgDestroyMsgCallback";
+            m_DestroyDebugReportCallback = (PFN_vkDestroyDebugReportCallbackLUNARG) vkGetInstanceProcAddr(this->inst, "vkDestroyDebugReportCallbackLUNARG");
+            ASSERT_NE(m_DestroyDebugReportCallback, (PFN_vkDestroyDebugReportCallbackLUNARG) NULL) << "Did not get function pointer for DestroyDebugReportCallback";
         }
     }
 
@@ -133,11 +139,16 @@
 
     /* Now register callback on device */
     if (0) {
-        if (m_dbgCreateMsgCallback) {
-            err = m_dbgCreateMsgCallback(this->inst,
-                                         VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT,
-                                         dbgFunction,
-                                         userData,
+        if (m_CreateDebugReportCallback) {
+            VkDebugReportCallbackCreateInfoLUNARG dbgInfo;
+            memset(&dbgInfo, 0, sizeof(dbgInfo));
+            dbgInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;
+            dbgInfo.pfnCallback = dbgFunction;
+            dbgInfo.pUserData = userData;
+            dbgInfo.flags = VK_DEBUG_REPORT_ERROR_BIT | VK_DEBUG_REPORT_WARN_BIT;
+            err = m_CreateDebugReportCallback(this->inst,
+                                         &dbgInfo,
+                                         NULL,
                                          &m_devMsgCallback);
             ASSERT_VK_SUCCESS(err);
         }
@@ -155,8 +166,8 @@
     if (m_framebuffer) vkDestroyFramebuffer(device(), m_framebuffer, NULL);
     if (m_renderPass) vkDestroyRenderPass(device(), m_renderPass, NULL);
 
-    if (m_globalMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_globalMsgCallback);
-    if (m_devMsgCallback) m_dbgDestroyMsgCallback(this->inst, m_devMsgCallback);
+    if (m_globalMsgCallback) m_DestroyDebugReportCallback(this->inst, m_globalMsgCallback, NULL);
+    if (m_devMsgCallback) m_DestroyDebugReportCallback(this->inst, m_devMsgCallback, NULL);
 
     while (!m_renderTargets.empty()) {
         vkDestroyImageView(device(), m_renderTargets.back()->targetView(m_render_target_fmt), NULL);
diff --git a/tests/vkrenderframework.h b/tests/vkrenderframework.h
index 85682ca..f5b3bf7 100644
--- a/tests/vkrenderframework.h
+++ b/tests/vkrenderframework.h
@@ -99,7 +99,7 @@
             std::vector<const char *> device_layer_names,
             std::vector<const char *> instance_extension_names,
             std::vector<const char *> device_extension_names,
-            PFN_vkDbgMsgCallback=NULL,
+            PFN_vkDebugReportCallbackLUNARG=NULL,
             void *userData=NULL);
 
     void ShutdownFramework();
@@ -140,8 +140,8 @@
     float                               m_depth_clear_color;
     uint32_t                            m_stencil_clear_color;
     VkDepthStencilObj                  *m_depthStencil;
-    PFN_vkDbgCreateMsgCallback          m_dbgCreateMsgCallback;
-    PFN_vkDbgDestroyMsgCallback         m_dbgDestroyMsgCallback;
+    PFN_vkCreateDebugReportCallbackLUNARG          m_CreateDebugReportCallback;
+    PFN_vkDestroyDebugReportCallbackLUNARG         m_DestroyDebugReportCallback;
     VkDebugReportCallbackLUNARG                    m_globalMsgCallback;
     VkDebugReportCallbackLUNARG                    m_devMsgCallback;
 
diff --git a/vk-layer-generate.py b/vk-layer-generate.py
index 43bd11c..7eaf327 100755
--- a/vk-layer-generate.py
+++ b/vk-layer-generate.py
@@ -227,22 +227,28 @@
     def _gen_create_msg_callback(self):
         r_body = []
         r_body.append('%s' % self.lineinfo.get())
-        r_body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgCreateMsgCallback(VkInstance instance, VkFlags msgFlags, const PFN_vkDbgMsgCallback pfnMsgCallback, void* pUserData, VkDebugReportCallbackLUNARG* pMsgCallback)')
+        r_body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackLUNARG(VkInstance instance,')
+        r_body.append('                                       VkDebugReportCallbackCreateInfoLUNARG*    pCreateInfo,')
+        r_body.append('                                       const VkAllocationCallbacks*              pAllocator,')
+        r_body.append('                                       VkDebugReportCallbackLUNARG*              pCallback)')
         r_body.append('{')
         # Switch to this code section for the new per-instance storage and debug callbacks
         if self.layer_name == 'ObjectTracker' or self.layer_name == 'Threading':
             r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
-            r_body.append('    VkResult result = pInstanceTable->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+            r_body.append('    VkResult result = pInstanceTable->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pCallback);')
             r_body.append('    if (VK_SUCCESS == result) {')
             r_body.append('        layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
-            r_body.append('        result = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+            r_body.append('        result = layer_create_msg_callback(my_data->report_data,')
+            r_body.append('                                           pCreateInfo,')
+            r_body.append('                                           pAllocator,')
+            r_body.append('                                           pCallback);')
             r_body.append('    }')
             r_body.append('    return result;')
         else:
-            r_body.append('    VkResult result = instance_dispatch_table(instance)->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+            r_body.append('    VkResult result = instance_dispatch_table(instance)->CreateDebugReportCallbackLUNARG(instance, pCreateInfo, pAllocator, pCallback);')
             r_body.append('    if (VK_SUCCESS == result) {')
             r_body.append('        layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
-            r_body.append('        result = layer_create_msg_callback(my_data->report_data, msgFlags, pfnMsgCallback, pUserData, pMsgCallback);')
+            r_body.append('        result = layer_create_msg_callback(my_data->report_data, pCreateInfo, pAllocator, pCallback);')
             r_body.append('    }')
             r_body.append('    return result;')
         r_body.append('}')
@@ -251,20 +257,16 @@
     def _gen_destroy_msg_callback(self):
         r_body = []
         r_body.append('%s' % self.lineinfo.get())
-        r_body.append('VK_LAYER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDbgDestroyMsgCallback(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback)')
+        r_body.append('VK_LAYER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackLUNARG(VkInstance instance, VkDebugReportCallbackLUNARG msgCallback, const VkAllocationCallbacks *pAllocator)')
         r_body.append('{')
         # Switch to this code section for the new per-instance storage and debug callbacks
         if self.layer_name == 'ObjectTracker' or self.layer_name == 'Threading':
             r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = get_dispatch_table(%s_instance_table_map, instance);' % self.layer_name )
-            r_body.append('    VkResult result = pInstanceTable->DbgDestroyMsgCallback(instance, msgCallback);')
-            r_body.append('    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
-            r_body.append('    layer_destroy_msg_callback(my_data->report_data, msgCallback);')
-            r_body.append('    return result;')
         else:
-            r_body.append('    VkResult result = instance_dispatch_table(instance)->DbgDestroyMsgCallback(instance, msgCallback);')
-            r_body.append('    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
-            r_body.append('    layer_destroy_msg_callback(my_data->report_data, msgCallback);')
-            r_body.append('    return result;')
+            r_body.append('    VkLayerInstanceDispatchTable *pInstanceTable = instance_dispatch_table(instance);')
+        r_body.append('    pInstanceTable->DestroyDebugReportCallbackLUNARG(instance, msgCallback, pAllocator);')
+        r_body.append('    layer_data *my_data = get_my_data_ptr(get_dispatch_key(instance), layer_data_map);')
+        r_body.append('    layer_destroy_msg_callback(my_data->report_data, msgCallback, pAllocator);')
         r_body.append('}')
         return "\n".join(r_body)
 
@@ -339,9 +341,9 @@
                 intercept = self.generate_intercept(proto, qual)
                 if intercept is None:
                     # fill in default intercept for certain entrypoints
-                    if 'DbgCreateMsgCallback' == proto.name:
+                    if 'CreateDebugReportCallbackLUNARG' == proto.name:
                         intercept = self._gen_layer_dbg_create_msg_callback()
-                    elif 'DbgDestroyMsgCallback' == proto.name:
+                    elif 'DestroyDebugReportCallbackLUNARG' == proto.name:
                         intercept = self._gen_layer_dbg_destroy_msg_callback()
                     elif 'CreateDevice' == proto.name:
                         funcs.append('/* CreateDevice HERE */')
@@ -626,8 +628,13 @@
             func_body.append('    {')
             func_body.append('        option_str = getLayerOption("%sLogFilename");' % self.layer_name)
             func_body.append('        log_output = getLayerLogOutput(option_str,"%s");' % self.layer_name)
-            func_body.append('        layer_create_msg_callback(my_data->report_data, report_flags,')
-            func_body.append('                                  log_callback, (void *) log_output,')
+            func_body.append('        VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;')
+            func_body.append('        memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));')
+            func_body.append('        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;')
+            func_body.append('        dbgCreateInfo.flags = report_flags;')
+            func_body.append('        dbgCreateInfo.pfnCallback = log_callback;')
+            func_body.append('        dbgCreateInfo.pUserData = NULL;')
+            func_body.append('        layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator,')
             func_body.append('                                  &my_data->logging_callback);')
             func_body.append('    }')
             func_body.append('')
@@ -664,7 +671,14 @@
             func_body.append('    {')
             func_body.append('        strOpt = getLayerOption("%sLogFilename");' % self.layer_name)
             func_body.append('        log_output = getLayerLogOutput(strOpt, "%s");' % self.layer_name)
-            func_body.append('        layer_create_msg_callback(my_data->report_data, report_flags, log_callback, (void *) log_output, &my_data->logging_callback);')
+            func_body.append('        VkDebugReportCallbackCreateInfoLUNARG dbgCreateInfo;')
+            func_body.append('        memset(&dbgCreateInfo, 0, sizeof(dbgCreateInfo));')
+            func_body.append('        dbgCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_LUNARG;')
+            func_body.append('        dbgCreateInfo.flags = report_flags;')
+            func_body.append('        dbgCreateInfo.pfnCallback = log_callback;')
+            func_body.append('        dbgCreateInfo.pUserData = log_output;')
+            func_body.append('        layer_create_msg_callback(my_data->report_data, &dbgCreateInfo, pAllocator,')
+            func_body.append('                                  &my_data->logging_callback);')
             func_body.append('    }')
             func_body.append('')
         if lockname is not None:
@@ -769,7 +783,7 @@
                          '    // Clean up logging callback, if any\n'
                          '    layer_data *my_data = get_my_data_ptr(key, layer_data_map);\n'
                          '    if (my_data->logging_callback) {\n'
-                         '        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);\n'
+                         '        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback, pAllocator);\n'
                          '    }\n\n'
                          '    layer_debug_report_destroy_instance(my_data->report_data);\n'
                          '    layer_data_map.erase(key);\n'
@@ -1493,7 +1507,7 @@
         gedi_txt.append('    // Clean up logging callback, if any')
         gedi_txt.append('    layer_data *my_data = get_my_data_ptr(key, layer_data_map);')
         gedi_txt.append('    if (my_data->logging_callback) {')
-        gedi_txt.append('        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);')
+        gedi_txt.append('        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback, pAllocator);')
         gedi_txt.append('    }')
         gedi_txt.append('')
         gedi_txt.append('    layer_debug_report_destroy_instance(mid(instance));')
@@ -1571,7 +1585,7 @@
         return "\n".join(cbv_txt)
 
     def generate_intercept(self, proto, qual):
-        if proto.name in [ 'DbgCreateMsgCallback', 'EnumerateInstanceLayerProperties', 'EnumerateInstanceExtensionProperties','EnumerateDeviceLayerProperties', 'EnumerateDeviceExtensionProperties' ]:
+        if proto.name in [ 'CreateDebugReportCallbackLUNARG', 'EnumerateInstanceLayerProperties', 'EnumerateInstanceExtensionProperties','EnumerateDeviceLayerProperties', 'EnumerateDeviceExtensionProperties' ]:
             # use default version
             return None
 
@@ -1961,7 +1975,7 @@
         return "\n".join(header_txt)
 
     def generate_intercept(self, proto, qual):
-        if proto.name in [ 'DbgCreateMsgCallback' ]:
+        if proto.name in [ 'CreateDebugReportCallbackLUNARG' ]:
             # use default version
             return None
         decl = proto.c_func(prefix="vk", attr="VKAPI")
@@ -2055,7 +2069,7 @@
                          '    // Clean up logging callback, if any\n'
                          '    layer_data *my_data = get_my_data_ptr(key, layer_data_map);\n'
                          '    if (my_data->logging_callback) {\n'
-                         '        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback);\n'
+                         '        layer_destroy_msg_callback(my_data->report_data, my_data->logging_callback, pAllocator);\n'
                          '    }\n'
                          '\n'
                          '    layer_debug_report_destroy_instance(my_data->report_data);\n'
diff --git a/vk_helper.py b/vk_helper.py
index c875c2c..0d05083 100755
--- a/vk_helper.py
+++ b/vk_helper.py
@@ -1349,6 +1349,7 @@
     def _generateSizeHelperHeaderC(self):
         header = []
         header.append('#include "vk_struct_size_helper.h"')
+        header.append('#include "vulkan/vk_lunarg_debug_report.h"')
         header.append('#include <string.h>')
         header.append('#include <assert.h>')
         header.append('\n// Function definitions\n')
diff --git a/vulkan.py b/vulkan.py
index 1e32b2d..897688f 100755
--- a/vulkan.py
+++ b/vulkan.py
@@ -192,7 +192,7 @@
 # VK core API
 core = Extension(
     name="VK_CORE",
-    headers=["vulkan/vulkan.h", "vk_lunarg_debug_report.h"],
+    headers=["vulkan/vulkan.h", "vulkan/vk_lunarg_debug_report.h"],
     objects=[
         "VkInstance",
         "VkPhysicalDevice",
@@ -1124,16 +1124,16 @@
         "VkDebugReportCallbackLUNARG",
     ],
     protos=[
-        Proto("VkResult", "DbgCreateMsgCallback",
+        Proto("VkResult", "CreateDebugReportCallbackLUNARG",
             [Param("VkInstance", "instance"),
-             Param("VkFlags", "msgFlags"),
-             Param("const PFN_vkDbgMsgCallback", "pfnMsgCallback"),
-             Param("void*", "pUserData"),
-             Param("VkDebugReportCallbackLUNARG*", "pMsgCallback")]),
+             Param("VkDebugReportCallbackCreateInfoLUNARG*", "pCreateInfo"),
+             Param("const VkAllocationCallbacks*", "pAllocator"),
+             Param("VkDebugReportCallbackLUNARG*", "pCallback")]),
 
-        Proto("VkResult", "DbgDestroyMsgCallback",
+        Proto("VkResult", "DestroyDebugReportCallbackLUNARG",
             [Param("VkInstance", "instance"),
-             Param("VkDebugReportCallbackLUNARG", "msgCallback")]),
+             Param("VkDebugReportCallbackLUNARG", "callback"),
+             Param("const VkAllocationCallbacks*", "pAllocator")]),
     ],
 )
 lunarg_debug_marker = Extension(
@@ -1269,7 +1269,7 @@
 
     # make them an extension and print
     ext = Extension("VK_CORE",
-            headers=["vulkan/vulkan.h", "vk_lunarg_debug_report.h"],
+            headers=["vulkan/vulkan.h", "vulkan/vk_lunarg_debug_report.h"],
             objects=object_lines,
             protos=protos)
     print("core =", str(ext))