From e27c32e6490ec5cdde16ab2181bff9b5ab0abc56 Mon Sep 17 00:00:00 2001 From: Courtney Goeltzenleuchter Date: Mon, 13 Apr 2015 14:10:06 -0600 Subject: [PATCH] xgl: update xglDbg.h for XGL_INSTANCE Add XGL_INSTANCE as the first parameter of xglDbgRegisterMsgCallback(), xglDbgUnregisterMsgCallback(), and xglDbgSetGlobalOption(). The loader is simplified. loader_log() is modified to always output to stderr. glave is modified to register its message callback after xglEnumerateGpus(), and xglDbgUnregisterMsgCallback() is called only before xglDestroyInstance(). XGL_INSTANCE is ignored by the layers and the driver for now. Bump up API version to XGL_MAKE_VERSION(0, 56, 1). --- icd/nulldrv/nulldrv.c | 3 + include/xgl.h | 2 +- include/xglDbg.h | 9 ++- layers/draw_state.c | 8 +- layers/draw_state.cpp | 8 +- layers/mem_tracker.cpp | 8 +- loader/loader.c | 210 +++++-------------------------------------------- xgl-generate.py | 4 +- xgl-layer-generate.py | 8 +- xgl.py | 9 ++- 10 files changed, 56 insertions(+), 213 deletions(-) diff --git a/icd/nulldrv/nulldrv.c b/icd/nulldrv/nulldrv.c index 4887d3b..f6fa9e0 100644 --- a/icd/nulldrv/nulldrv.c +++ b/icd/nulldrv/nulldrv.c @@ -1532,6 +1532,7 @@ ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers( } ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback( + XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) { @@ -1540,6 +1541,7 @@ ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback( } ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback( + XGL_INSTANCE instance, XGL_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) { NULLDRV_LOG_FUNC; @@ -1547,6 +1549,7 @@ ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback( } ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption( + XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) diff --git a/include/xgl.h b/include/xgl.h index 43008ac..bffc7df 100644 --- a/include/xgl.h +++ b/include/xgl.h @@ -33,7 +33,7 @@ #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" diff --git a/include/xglDbg.h b/include/xglDbg.h index dfed1a8..d589dbe 100644 --- a/include/xglDbg.h +++ b/include/xglDbg.h @@ -109,11 +109,11 @@ typedef void (XGLAPI *XGL_DBG_MSG_CALLBACK_FUNCTION)( // 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); @@ -123,10 +123,12 @@ XGL_RESULT XGLAPI xglDbgSetValidationLevel( 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( @@ -140,6 +142,7 @@ XGL_RESULT XGLAPI xglDbgSetObjectTag( const void* pTag); XGL_RESULT XGLAPI xglDbgSetGlobalOption( + XGL_INSTANCE instance, XGL_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData); diff --git a/layers/draw_state.c b/layers/draw_state.c index 96f15a7..979b136 100644 --- a/layers/draw_state.c +++ b/layers/draw_state.c @@ -2655,7 +2655,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_R 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)); @@ -2672,11 +2672,11 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBAC 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; @@ -2701,7 +2701,7 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLB else g_debugAction &= ~XGL_DBG_LAYER_ACTION_CALLBACK; } - XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(pfnMsgCallback); + XGL_RESULT result = nextTable.DbgUnregisterMsgCallback(instance, pfnMsgCallback); return result; } diff --git a/layers/draw_state.cpp b/layers/draw_state.cpp index 415634b..3687c06 100644 --- a/layers/draw_state.cpp +++ b/layers/draw_state.cpp @@ -2559,7 +2559,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdEndRenderPass(XGL_CMD_BUFFER cmdBuffer, XGL_R 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)); @@ -2576,11 +2576,11 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBAC 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; @@ -2605,7 +2605,7 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLB 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; } diff --git a/layers/mem_tracker.cpp b/layers/mem_tracker.cpp index 3c2dec0..c68dc97 100644 --- a/layers/mem_tracker.cpp +++ b/layers/mem_tracker.cpp @@ -1650,7 +1650,7 @@ XGL_LAYER_EXPORT void XGLAPI xglCmdResetQueryPool(XGL_CMD_BUFFER cmdBuffer, XGL_ 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)); @@ -1664,11 +1664,11 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBAC 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; @@ -1691,7 +1691,7 @@ XGL_LAYER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLB 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; } diff --git a/loader/loader.c b/loader/loader.c index bff896f..bfc5ef0 100644 --- a/loader/loader.c +++ b/loader/loader.c @@ -77,13 +77,6 @@ struct loader_icd { }; -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; @@ -104,11 +97,6 @@ static struct { 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; @@ -214,66 +202,9 @@ static char *loader_get_registry_and_env(const char *env_var, #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; @@ -285,31 +216,8 @@ static void loader_log(XGL_DBG_MSG_TYPE msg_type, int32_t msg_code, } 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 @@ -335,58 +243,6 @@ loader_icd_create(const struct loader_scanned_icds *scanned) 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) { @@ -1120,12 +976,6 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus( *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) { @@ -1136,9 +986,6 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus( icd = icd->next; } - /* we have nothing to log anymore */ - loader_msg_callback_clear(); - *pGpuCount = count; return (count > 0) ? XGL_SUCCESS : res; @@ -1240,21 +1087,22 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(XGL_PHYSICAL_GPU gpu, size_t 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; @@ -1275,12 +1123,12 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_F 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; } @@ -1288,13 +1136,14 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(XGL_DBG_MSG_CALLBACK_F 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) { @@ -1302,7 +1151,7 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK 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; } @@ -1312,31 +1161,14 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(XGL_DBG_MSG_CALLBACK 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) { @@ -1344,7 +1176,7 @@ LOADER_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(XGL_DBG_GLOBAL_OPTION dbgO 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) { diff --git a/xgl-generate.py b/xgl-generate.py index cb79913..55371ab 100755 --- a/xgl-generate.py +++ b/xgl-generate.py @@ -101,7 +101,9 @@ class LoaderEntrypointsSubcommand(Subcommand): 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() diff --git a/xgl-layer-generate.py b/xgl-layer-generate.py index a21b004..98a62ce 100755 --- a/xgl-layer-generate.py +++ b/xgl-layer-generate.py @@ -140,7 +140,7 @@ class Subcommand(object): 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));') @@ -154,14 +154,14 @@ class Subcommand(object): 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;') @@ -183,7 +183,7 @@ class Subcommand(object): 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) diff --git a/xgl.py b/xgl.py index 8623b87..e917f82 100644 --- a/xgl.py +++ b/xgl.py @@ -819,11 +819,13 @@ core = Extension( 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"), @@ -836,7 +838,8 @@ core = Extension( 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")]), -- 2.7.4