}
ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
+ XGL_INSTANCE instance,
XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
void* pUserData)
{
}
ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
+ XGL_INSTANCE instance,
XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
NULLDRV_LOG_FUNC;
}
ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(
+ XGL_INSTANCE instance,
XGL_DBG_GLOBAL_OPTION dbgOption,
size_t dataSize,
const void* pData)
#include "xglPlatform.h"
// XGL API version supported by this file
-#define XGL_API_VERSION XGL_MAKE_VERSION(0, 56, 0)
+#define XGL_API_VERSION XGL_MAKE_VERSION(0, 56, 1)
#ifdef __cplusplus
extern "C"
// Debug functions
typedef XGL_RESULT (XGLAPI *xglDbgSetValidationLevelType)(XGL_DEVICE device, XGL_VALIDATION_LEVEL validationLevel);
-typedef XGL_RESULT (XGLAPI *xglDbgRegisterMsgCallbackType)(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData);
-typedef XGL_RESULT (XGLAPI *xglDbgUnregisterMsgCallbackType)(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
+typedef XGL_RESULT (XGLAPI *xglDbgRegisterMsgCallbackType)(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData);
+typedef XGL_RESULT (XGLAPI *xglDbgUnregisterMsgCallbackType)(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
typedef XGL_RESULT (XGLAPI *xglDbgSetMessageFilterType)(XGL_DEVICE device, int32_t msgCode, XGL_DBG_MSG_FILTER filter);
typedef XGL_RESULT (XGLAPI *xglDbgSetObjectTagType)(XGL_BASE_OBJECT object, size_t tagSize, const void* pTag);
-typedef XGL_RESULT (XGLAPI *xglDbgSetGlobalOptionType)(XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData);
+typedef XGL_RESULT (XGLAPI *xglDbgSetGlobalOptionType)(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData);
typedef XGL_RESULT (XGLAPI *xglDbgSetDeviceOptionType)(XGL_DEVICE device, XGL_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData);
typedef void (XGLAPI *xglCmdDbgMarkerBeginType)(XGL_CMD_BUFFER cmdBuffer, const char* pMarker);
typedef void (XGLAPI *xglCmdDbgMarkerEndType)(XGL_CMD_BUFFER cmdBuffer);
XGL_VALIDATION_LEVEL validationLevel);
XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
+ XGL_INSTANCE instance,
XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback,
void* pUserData);
XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
+ XGL_INSTANCE instance,
XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback);
XGL_RESULT XGLAPI xglDbgSetMessageFilter(
const void* pTag);
XGL_RESULT XGLAPI xglDbgSetGlobalOption(
+ XGL_INSTANCE instance,
XGL_DBG_GLOBAL_OPTION dbgOption,
size_t dataSize,
const void* pData);
nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
XGL_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
if (g_actionIsDefault) {
g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgRegisterMsgCallback(pfnMsgCallback, pUserData);
+ XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
else
g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback);
+ XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
nextTable.CmdEndRenderPass(cmdBuffer, renderPass);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
XGL_LAYER_DBG_FUNCTION_NODE* pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
if (g_actionIsDefault) {
g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgRegisterMsgCallback(pfnMsgCallback, pUserData);
+ XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;
XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;
else
g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback);
+ XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
nextTable.CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
// This layer intercepts callbacks
XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));
if (g_actionIsDefault) {
g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;
}
- XGL_RESULT result = nextTable.DbgRegisterMsgCallback(pfnMsgCallback, pUserData);
+ XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);
return result;
}
-XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
XGL_LAYER_DBG_FUNCTION_NODE *pInfo = g_pDbgFunctionHead;
XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pInfo;
g_debugAction = (XGL_LAYER_DBG_ACTION)(g_debugAction & ~((uint32_t)XGL_DBG_LAYER_ACTION_CALLBACK));
}
}
- XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback);
+ XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);
return result;
}
};
-struct loader_msg_callback {
- XGL_DBG_MSG_CALLBACK_FUNCTION func;
- void *data;
-
- struct loader_msg_callback *next;
-};
-
struct loader_scanned_icds {
loader_platform_dl_handle handle;
xglGetProcAddrType GetProcAddr;
char *layer_dirs;
unsigned int scanned_layer_count;
char *scanned_layer_names[MAX_LAYER_LIBRARIES];
- struct loader_msg_callback *msg_callbacks;
-
- bool debug_echo_enable;
- bool break_on_error;
- bool break_on_warning;
} loader;
#endif // WIN32
-static XGL_RESULT loader_msg_callback_add(XGL_DBG_MSG_CALLBACK_FUNCTION func,
- void *data)
-{
- struct loader_msg_callback *cb;
-
- cb = malloc(sizeof(*cb));
- if (!cb)
- return XGL_ERROR_OUT_OF_MEMORY;
-
- cb->func = func;
- cb->data = data;
-
- cb->next = loader.msg_callbacks;
- loader.msg_callbacks = cb;
-
- return XGL_SUCCESS;
-}
-
-static XGL_RESULT loader_msg_callback_remove(XGL_DBG_MSG_CALLBACK_FUNCTION func)
-{
- struct loader_msg_callback *cb = loader.msg_callbacks;
-
- /*
- * Find the first match (last registered).
- *
- * XXX What if the same callback function is registered more than once?
- */
- while (cb) {
- if (cb->func == func) {
- break;
- }
-
- cb = cb->next;
- }
-
- if (!cb)
- return XGL_ERROR_INVALID_POINTER;
-
- free(cb);
-
- return XGL_SUCCESS;
-}
-
-static void loader_msg_callback_clear(void)
-{
- struct loader_msg_callback *cb = loader.msg_callbacks;
-
- while (cb) {
- struct loader_msg_callback *next = cb->next;
- free(cb);
- cb = next;
- }
-
- loader.msg_callbacks = NULL;
-}
-
static void loader_log(XGL_DBG_MSG_TYPE msg_type, int32_t msg_code,
const char *format, ...)
{
- const struct loader_msg_callback *cb = loader.msg_callbacks;
char msg[256];
va_list ap;
int ret;
}
va_end(ap);
- if (loader.debug_echo_enable || !cb) {
- fputs(msg, stderr);
- fputc('\n', stderr);
- }
-
- while (cb) {
- cb->func(msg_type, XGL_VALIDATION_LEVEL_0, XGL_NULL_HANDLE, 0,
- msg_code, msg, cb->data);
- cb = cb->next;
- }
-
- switch (msg_type) {
- case XGL_DBG_MSG_ERROR:
- if (loader.break_on_error) {
- exit(1);
- }
- /* fall through */
- case XGL_DBG_MSG_WARNING:
- if (loader.break_on_warning) {
- exit(1);
- }
- break;
- default:
- break;
- }
+ fputs(msg, stderr);
+ fputc('\n', stderr);
}
static void
return icd;
}
-static XGL_RESULT loader_icd_register_msg_callbacks(const struct loader_icd *icd)
-{
- const struct loader_msg_callback *cb = loader.msg_callbacks;
- XGL_RESULT res;
-
- while (cb) {
- for (uint32_t i = 0; i < icd->gpu_count; i++) {
- res = (icd->loader_dispatch + i)->DbgRegisterMsgCallback(cb->func, cb->data);
- if (res != XGL_SUCCESS) {
- break;
- }
- }
- cb = cb->next;
- }
-
- /* roll back on errors */
- if (cb) {
- const struct loader_msg_callback *tmp = loader.msg_callbacks;
-
- while (tmp != cb) {
- for (uint32_t i = 0; i < icd->gpu_count; i++) {
- (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(cb->func);
- }
- tmp = tmp->next;
- }
-
- return res;
- }
-
- return XGL_SUCCESS;
-}
-
-static XGL_RESULT loader_icd_set_global_options(const struct loader_icd *icd)
-{
-#define SETB(icd, opt, val) do { \
- if (val) { \
- for (uint32_t i = 0; i < icd->gpu_count; i++) { \
- const XGL_RESULT res = \
- (icd->loader_dispatch + i)->DbgSetGlobalOption(opt, sizeof(val), &val); \
- if (res != XGL_SUCCESS) \
- return res; \
- } \
- } \
-} while (0)
- SETB(icd, XGL_DBG_OPTION_DEBUG_ECHO_ENABLE, loader.debug_echo_enable);
- SETB(icd, XGL_DBG_OPTION_BREAK_ON_ERROR, loader.break_on_error);
- SETB(icd, XGL_DBG_OPTION_BREAK_ON_WARNING, loader.break_on_warning);
-#undef SETB
-
-return XGL_SUCCESS;
-}
-
static struct loader_icd *loader_icd_add(struct loader_instance *ptr_inst,
const struct loader_scanned_icds *scanned)
{
*disp = icd->loader_dispatch + i;
}
- if (loader_icd_set_global_options(icd) != XGL_SUCCESS ||
- loader_icd_register_msg_callbacks(icd) != XGL_SUCCESS) {
- loader_log(XGL_DBG_MSG_WARNING, 0,
- "ICD ignored: failed to migrate settings");
- loader_icd_destroy(icd);
- }
count += n;
if (count >= maxGpus) {
icd = icd->next;
}
- /* we have nothing to log anymore */
- loader_msg_callback_clear();
-
*pGpuCount = count;
return (count > 0) ? XGL_SUCCESS : res;
return XGL_SUCCESS;
}
-LOADER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
+LOADER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)
{
const struct loader_icd *icd;
struct loader_instance *inst;
XGL_RESULT res;
uint32_t gpu_idx;
- if (!loader.icds_scanned) {
- return loader_msg_callback_add(pfnMsgCallback, pUserData);
- }
+ if (instance == XGL_NULL_HANDLE)
+ return XGL_ERROR_INVALID_HANDLE;
+
+ assert(loader.icds_scanned);
for (inst = loader.instances; inst; inst = inst->next) {
for (icd = inst->icds; icd; icd = icd->next) {
for (uint32_t i = 0; i < icd->gpu_count; i++) {
- res = (icd->loader_dispatch + i)->DbgRegisterMsgCallback(
+ res = (icd->loader_dispatch + i)->DbgRegisterMsgCallback(icd->scanned_icds->instance,
pfnMsgCallback, pUserData);
if (res != XGL_SUCCESS) {
gpu_idx = i;
for (const struct loader_icd * tmp = tmp_inst->icds; tmp != icd;
tmp = tmp->next) {
for (uint32_t i = 0; i < icd->gpu_count; i++)
- (tmp->loader_dispatch + i)->DbgUnregisterMsgCallback(pfnMsgCallback);
+ (tmp->loader_dispatch + i)->DbgUnregisterMsgCallback(tmp->scanned_icds->instance, pfnMsgCallback);
}
}
/* and gpus on current icd */
for (uint32_t i = 0; i < gpu_idx; i++)
- (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(pfnMsgCallback);
+ (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(icd->scanned_icds->instance, pfnMsgCallback);
return res;
}
return XGL_SUCCESS;
}
-LOADER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
+LOADER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)
{
XGL_RESULT res = XGL_SUCCESS;
- if (!loader.icds_scanned) {
- return loader_msg_callback_remove(pfnMsgCallback);
- }
+ if (instance == XGL_NULL_HANDLE)
+ return XGL_ERROR_INVALID_HANDLE;
+
+ assert(loader.icds_scanned);
for (struct loader_instance *inst = loader.instances; inst;
inst = inst->next) {
icd = icd->next) {
for (uint32_t i = 0; i < icd->gpu_count; i++) {
XGL_RESULT r;
- r = (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(pfnMsgCallback);
+ r = (icd->loader_dispatch + i)->DbgUnregisterMsgCallback(icd->scanned_icds->instance, pfnMsgCallback);
if (r != XGL_SUCCESS) {
res = r;
}
return res;
}
-LOADER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
+LOADER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData)
{
XGL_RESULT res = XGL_SUCCESS;
- if (!loader.icds_scanned) {
- if (dataSize == 0)
- return XGL_ERROR_INVALID_VALUE;
-
- switch (dbgOption) {
- case XGL_DBG_OPTION_DEBUG_ECHO_ENABLE:
- loader.debug_echo_enable = *((const bool *) pData);
- break;
- case XGL_DBG_OPTION_BREAK_ON_ERROR:
- loader.break_on_error = *((const bool *) pData);
- break;
- case XGL_DBG_OPTION_BREAK_ON_WARNING:
- loader.break_on_warning = *((const bool *) pData);
- break;
- default:
- res = XGL_ERROR_INVALID_VALUE;
- break;
- }
+ if (instance == XGL_NULL_HANDLE)
+ return XGL_ERROR_INVALID_HANDLE;
- return res;
- }
+ assert(loader.icds_scanned);
for (struct loader_instance *inst = loader.instances; inst;
inst = inst->next) {
icd = icd->next) {
for (uint32_t i = 0; i < icd->gpu_count; i++) {
XGL_RESULT r;
- r = (icd->loader_dispatch + i)->DbgSetGlobalOption(dbgOption,
+ r = (icd->loader_dispatch + i)->DbgSetGlobalOption(icd->scanned_icds->instance, dbgOption,
dataSize, pData);
/* unfortunately we cannot roll back */
if (r != XGL_SUCCESS) {
return "#include \"loader.h\""
def _is_dispatchable(self, proto):
- if proto.name in ["GetProcAddr", "DestroyInstance", "EnumerateGpus", "EnumerateLayers"]:
+ if proto.name in ["GetProcAddr", "DestroyInstance", "EnumerateGpus",
+ "EnumerateLayers", "DbgRegisterMsgCallback",
+ "DbgUnregisterMsgCallback", "DbgSetGlobalOption"]:
return False
in_objs = proto.object_in_params()
def _gen_layer_dbg_callback_register(self):
r_body = []
- r_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)')
+ r_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData)')
r_body.append('{')
r_body.append(' // This layer intercepts callbacks')
r_body.append(' XGL_LAYER_DBG_FUNCTION_NODE *pNewDbgFuncNode = (XGL_LAYER_DBG_FUNCTION_NODE*)malloc(sizeof(XGL_LAYER_DBG_FUNCTION_NODE));')
r_body.append(' if (g_actionIsDefault) {')
r_body.append(' g_debugAction = XGL_DBG_LAYER_ACTION_CALLBACK;')
r_body.append(' }')
- r_body.append(' XGL_RESULT result = nextTable.DbgRegisterMsgCallback(pfnMsgCallback, pUserData);')
+ r_body.append(' XGL_RESULT result = nextTable.DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData);')
r_body.append(' return result;')
r_body.append('}')
return "\n".join(r_body)
def _gen_layer_dbg_callback_unregister(self):
ur_body = []
- ur_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)')
+ ur_body.append('XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback)')
ur_body.append('{')
ur_body.append(' XGL_LAYER_DBG_FUNCTION_NODE *pTrav = g_pDbgFunctionHead;')
ur_body.append(' XGL_LAYER_DBG_FUNCTION_NODE *pPrev = pTrav;')
ur_body.append(' else')
ur_body.append(' g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK;')
ur_body.append(' }')
- ur_body.append(' XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback);')
+ ur_body.append(' XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback);')
ur_body.append(' return result;')
ur_body.append('}')
return "\n".join(ur_body)
Param("XGL_VALIDATION_LEVEL", "validationLevel")]),
Proto("XGL_RESULT", "DbgRegisterMsgCallback",
- [Param("XGL_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"),
+ [Param("XGL_INSTANCE", "instance"),
+ Param("XGL_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback"),
Param("void*", "pUserData")]),
Proto("XGL_RESULT", "DbgUnregisterMsgCallback",
- [Param("XGL_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]),
+ [Param("XGL_INSTANCE", "instance"),
+ Param("XGL_DBG_MSG_CALLBACK_FUNCTION", "pfnMsgCallback")]),
Proto("XGL_RESULT", "DbgSetMessageFilter",
[Param("XGL_DEVICE", "device"),
Param("const void*", "pTag")]),
Proto("XGL_RESULT", "DbgSetGlobalOption",
- [Param("XGL_DBG_GLOBAL_OPTION", "dbgOption"),
+ [Param("XGL_INSTANCE", "instance"),
+ Param("XGL_DBG_GLOBAL_OPTION", "dbgOption"),
Param("size_t", "dataSize"),
Param("const void*", "pData")]),