VirtualBox

Changeset 39160 in vbox for trunk/src/VBox/Additions/WINNT


Ignore:
Timestamp:
Nov 1, 2011 2:35:23 PM (13 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
74625
Message:

wddm: better logging

Location:
trunk/src/VBox/Additions/WINNT
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoLog.h

    r39150 r39160  
    2424#endif
    2525
     26#ifndef VBOX_VIDEO_LOG_LOGGER
     27# define VBOX_VIDEO_LOG_LOGGER Log
     28#endif
     29
     30#ifndef VBOX_VIDEO_LOGREL_LOGGER
     31# define VBOX_VIDEO_LOGREL_LOGGER LogRel
     32#endif
     33
     34#ifndef VBOX_VIDEO_LOGFLOW_LOGGER
     35# define VBOX_VIDEO_LOGFLOW_LOGGER LogFlow
     36#endif
     37
     38#ifndef VBOX_VIDEO_LOG_FN_FMT
     39# define VBOX_VIDEO_LOG_FN_FMT LOG_FN_FMT
     40#endif
     41
    2642/* Uncomment to show file/line info in the log */
    2743/*#define VBOX_VIDEO_LOG_SHOWLINEINFO*/
    2844
    29 #define VBOX_VIDEO_LOG_PREFIX_FMT VBOX_VIDEO_LOG_NAME"::"LOG_FN_FMT": "
     45#define VBOX_VIDEO_LOG_PREFIX_FMT VBOX_VIDEO_LOG_NAME"::"VBOX_VIDEO_LOG_FN_FMT": "
    3046#define VBOX_VIDEO_LOG_PREFIX_PARMS __PRETTY_FUNCTION__
    3147
    … …  
    6884
    6985#ifdef VBOX_WDDM_MINIPORT
    70 # define _WARN_LOGGER LogRel
     86# define _WARN_LOGGER VBOX_VIDEO_LOGREL_LOGGER
    7187#else
    72 # define _WARN_LOGGER Log
     88# define _WARN_LOGGER VBOX_VIDEO_LOG_LOGGER
    7389#endif
    7490
    … …  
    94110    } while (0)
    95111
    96 #define LOG(_a) _LOGMSG(Log, _a)
    97 #define LOGREL(_a) _LOGMSG(LogRel, _a)
    98 #define LOGF(_a) _LOGMSG(LogFlow, _a)
     112#define LOG(_a) _LOGMSG(VBOX_VIDEO_LOG_LOGGER, _a)
     113#define LOGREL(_a) _LOGMSG(VBOX_VIDEO_LOGREL_LOGGER, _a)
     114#define LOGF(_a) _LOGMSG(VBOX_VIDEO_LOGFLOW_LOGGER, _a)
    99115#define LOGF_ENTER() LOGF(("ENTER"))
    100116#define LOGF_LEAVE() LOGF(("LEAVE"))
    101 #define LOG_EXACT(_a) _LOGMSG_EXACT(Log, _a)
    102 #define LOGREL_EXACT(_a) _LOGMSG_EXACT(LogRel, _a)
     117#define LOG_EXACT(_a) _LOGMSG_EXACT(VBOX_VIDEO_LOG_LOGGER, _a)
     118#define LOGREL_EXACT(_a) _LOGMSG_EXACT(VBOX_VIDEO_LOGREL_LOGGER, _a)
     119#define LOGF_EXACT(_a) _LOGMSG_EXACT(VBOX_VIDEO_LOGFLOW_LOGGER, _a)
    103120/* we can not print paged strings to RT logger, do it this way */
    104121#define LOG_STRA(_a) do {\
    105         _LOGMSG_STR(Log, _a, "c"); \
     122        _LOGMSG_STR(VBOX_VIDEO_LOG_LOGGER, _a, "c"); \
    106123    } while (0)
    107124#define LOG_STRW(_a) do {\
    108         _LOGMSG_STR(Log, _a, "c"); \
     125        _LOGMSG_STR(VBOX_VIDEO_LOG_LOGGER, _a, "c"); \
    109126    } while (0)
    110127#define LOGREL_STRA(_a) do {\
    111         _LOGMSG_STR(LogRel, _a, "c"); \
     128        _LOGMSG_STR(VBOX_VIDEO_LOGREL_LOGGER, _a, "c"); \
    112129    } while (0)
    113130#define LOGREL_STRW(_a) do {\
    114         _LOGMSG_STR(LogRel, _a, "c"); \
     131        _LOGMSG_STR(VBOX_VIDEO_LOGREL_LOGGER, _a, "c"); \
    115132    } while (0)
    116133

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h

    r38982 r39160  
    370370} VBOXDISPIFESCAPE_DBGPRINT, *PVBOXDISPIFESCAPE_DBGPRINT;
    371371AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, EscapeHdr) == 0);
     372
     373typedef enum
     374{
     375    VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_UNDEFINED = 0,
     376    VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_D3DCAPS9 = 1,
     377    VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_DUMMY32BIT = 0x7fffffff
     378} VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE;
     379
     380typedef struct VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS
     381{
     382    union
     383    {
     384        struct
     385        {
     386            UINT WoW64      : 1;
     387            UINT Reserved   : 31; /* reserved */
     388        };
     389        UINT  Value;
     390    };
     391} VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS, *PVBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS;
     392
     393typedef struct VBOXDISPIFESCAPE_DBGDUMPBUF
     394{
     395    VBOXDISPIFESCAPE EscapeHdr;
     396    VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE enmType;
     397    VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS Flags;
     398    char aBuf[1];
     399} VBOXDISPIFESCAPE_DBGDUMPBUF, *PVBOXDISPIFESCAPE_DBGDUMPBUF;
     400AssertCompile(RT_OFFSETOF(VBOXDISPIFESCAPE_DBGDUMPBUF, EscapeHdr) == 0);
    372401
    373402typedef struct VBOXSCREENLAYOUT_ELEMENT

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/Makefile.kmk

    r37273 r39160  
    8282DLLS += VBoxDispD3D
    8383VBoxDispD3D_TEMPLATE = VBOXGUESTR3DLL
    84 VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOX_WITH_WDDM VBOXWDDMDISP LOG_TO_BACKDOOR
     84VBoxDispD3D_DEFS     = UNICODE _UNICODE VBOX_WITH_WDDM VBOXWDDMDISP LOG_TO_BACKDOOR LOG_TO_BACKDOOR_DRV
    8585ifdef DEBUG_misha
    8686VBoxDispD3D_DEFS    += LOG_ENABLED

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp

    r39150 r39160  
    33423342{
    33433343    HRESULT hr = pAdapter->pD3D9If->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, pCaps);
    3344     Assert(hr == S_OK);
    3345     if (hr == S_OK)
    3346     {
    3347         pCaps->Caps2 |= D3DCAPS2_CANSHARERESOURCE | 0x00080000 /*D3DCAPS2_CANRENDERWINDOWED*/;
    3348         pCaps->DevCaps |= D3DDEVCAPS_FLOATTLVERTEX /* <- must be set according to the docs */
    3349                 /*| D3DDEVCAPS_HWVERTEXBUFFER | D3DDEVCAPS_HWINDEXBUFFER |  D3DDEVCAPS_SUBVOLUMELOCK */;
    3350         pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_INDEPENDENTWRITEMASKS
    3351                 | D3DPMISCCAPS_FOGINFVF
    3352                 | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
    3353         pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
    3354         pCaps->TextureCaps |= D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE;
    3355         pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
    3356         pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
    3357         pCaps->GuardBandLeft = -8192.;
    3358         pCaps->GuardBandTop = -8192.;
    3359         pCaps->GuardBandRight = 8192.;
    3360         pCaps->GuardBandBottom = 8192.;
    3361         pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
    3362         pCaps->DeclTypes |= D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
    3363         pCaps->VS20Caps.DynamicFlowControlDepth = 24;
    3364         pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
    3365         pCaps->PS20Caps.DynamicFlowControlDepth = 24;
    3366         pCaps->PS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
    3367         pCaps->VertexTextureFilterCaps |= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MAGFPOINT;
     3344    if (FAILED(hr))
     3345    {
     3346        WARN(("GetDeviceCaps failed hr(0x%x)",hr));
     3347        return hr;
     3348    }
     3349
     3350    pCaps->Caps2 |= D3DCAPS2_CANSHARERESOURCE | 0x00080000 /*D3DCAPS2_CANRENDERWINDOWED*/;
     3351    pCaps->DevCaps |= D3DDEVCAPS_FLOATTLVERTEX /* <- must be set according to the docs */
     3352            /*| D3DDEVCAPS_HWVERTEXBUFFER | D3DDEVCAPS_HWINDEXBUFFER |  D3DDEVCAPS_SUBVOLUMELOCK */;
     3353    pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_INDEPENDENTWRITEMASKS
     3354            | D3DPMISCCAPS_FOGINFVF
     3355            | D3DPMISCCAPS_SEPARATEALPHABLEND | D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
     3356    pCaps->RasterCaps |= D3DPRASTERCAPS_SUBPIXEL | D3DPRASTERCAPS_STIPPLE | D3DPRASTERCAPS_ZBIAS | D3DPRASTERCAPS_COLORPERSPECTIVE /* keep */;
     3357    pCaps->TextureCaps |= D3DPTEXTURECAPS_TRANSPARENCY | D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE;
     3358    pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
     3359    pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
     3360    pCaps->GuardBandLeft = -8192.;
     3361    pCaps->GuardBandTop = -8192.;
     3362    pCaps->GuardBandRight = 8192.;
     3363    pCaps->GuardBandBottom = 8192.;
     3364    pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
     3365    pCaps->DeclTypes |= D3DDTCAPS_FLOAT16_2 | D3DDTCAPS_FLOAT16_4;
     3366    pCaps->VS20Caps.DynamicFlowControlDepth = 24;
     3367    pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
     3368    pCaps->PS20Caps.DynamicFlowControlDepth = 24;
     3369    pCaps->PS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
     3370    pCaps->VertexTextureFilterCaps |= D3DPTFILTERCAPS_MINFPOINT | D3DPTFILTERCAPS_MAGFPOINT;
    33683371#if 1 /* workaround for wine not returning InstructionSlots correctly for  shaders v3.0 */
    3369         if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
    3370         {
    3371             pCaps->MaxVertexShader30InstructionSlots = RT_MIN(32768, pCaps->MaxVertexShader30InstructionSlots);
    3372             pCaps->MaxPixelShader30InstructionSlots = RT_MIN(32768, pCaps->MaxPixelShader30InstructionSlots);
    3373         }
     3372    if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
     3373    {
     3374        pCaps->MaxVertexShader30InstructionSlots = RT_MIN(32768, pCaps->MaxVertexShader30InstructionSlots);
     3375        pCaps->MaxPixelShader30InstructionSlots = RT_MIN(32768, pCaps->MaxPixelShader30InstructionSlots);
     3376    }
    33743377#endif
    33753378#ifdef DEBUG
    3376         if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
    3377         {
    3378             Assert(pCaps->MaxVertexShader30InstructionSlots >= 512);
    3379             Assert(pCaps->MaxVertexShader30InstructionSlots <= 32768);
    3380             Assert(pCaps->MaxPixelShader30InstructionSlots >= 512);
    3381             Assert(pCaps->MaxPixelShader30InstructionSlots <= 32768);
    3382         }
    3383         else if ((pCaps->VertexShaderVersion & 0xff00) == 0x0200)
    3384         {
    3385             Assert(pCaps->MaxVertexShader30InstructionSlots == 0);
    3386             Assert(pCaps->MaxPixelShader30InstructionSlots == 0);
    3387         }
    3388         else
    3389         {
    3390             Assert(0);
    3391         }
    3392 #endif
    3393     }
    3394 
    3395     return hr;
     3379    if ((pCaps->VertexShaderVersion & 0xff00) == 0x0300)
     3380    {
     3381        Assert(pCaps->MaxVertexShader30InstructionSlots >= 512);
     3382        Assert(pCaps->MaxVertexShader30InstructionSlots <= 32768);
     3383        Assert(pCaps->MaxPixelShader30InstructionSlots >= 512);
     3384        Assert(pCaps->MaxPixelShader30InstructionSlots <= 32768);
     3385    }
     3386    else if ((pCaps->VertexShaderVersion & 0xff00) == 0x0200)
     3387    {
     3388        Assert(pCaps->MaxVertexShader30InstructionSlots == 0);
     3389        Assert(pCaps->MaxPixelShader30InstructionSlots == 0);
     3390    }
     3391    else
     3392    {
     3393        Assert(0);
     3394    }
     3395#endif
     3396
     3397    vboxDispDumpD3DCAPS9(pCaps);
     3398
     3399    return S_OK;
    33963400}
    33973401
    … …  
    76307634    {
    76317635
     7636    LOGREL(("Built %s %s", __DATE__, __TIME__));
     7637
    76327638    VBOXWDDM_QI Query;
    76337639    D3DDDICB_QUERYADAPTERINFO DdiQuery;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.cpp

    r39132 r39160  
    8080
    8181DWORD g_VBoxVDbgPid = 0;
    82 typedef enum
    83 {
    84     VBOXDISPDBG_STATE_UNINITIALIZED = 0,
    85     VBOXDISPDBG_STATE_INITIALIZING,
    86     VBOXDISPDBG_STATE_INITIALIZED,
    87 } VBOXDISPDBG_STATE;
    88 
    89 typedef struct VBOXDISPDBG
    90 {
    91     VBOXDISPKMT_CALLBACKS KmtCallbacks;
    92     VBOXDISPDBG_STATE enmState;
    93 } VBOXDISPDBG, *PVBOXDISPDBG;
    94 
    95 static VBOXDISPDBG g_VBoxDispDbg = {0};
    96 
    97 PVBOXDISPDBG vboxDispDbgGet()
    98 {
    99     if (ASMAtomicCmpXchgU32((volatile uint32_t *)&g_VBoxDispDbg.enmState, VBOXDISPDBG_STATE_INITIALIZING, VBOXDISPDBG_STATE_UNINITIALIZED))
    100     {
    101         HRESULT hr = vboxDispKmtCallbacksInit(&g_VBoxDispDbg.KmtCallbacks);
    102         Assert(hr == S_OK);
    103         if (hr == S_OK)
    104         {
    105             ASMAtomicWriteU32((volatile uint32_t *)&g_VBoxDispDbg.enmState, VBOXDISPDBG_STATE_INITIALIZED);
    106             return &g_VBoxDispDbg;
    107         }
    108         else
    109         {
    110             ASMAtomicWriteU32((volatile uint32_t *)&g_VBoxDispDbg.enmState, VBOXDISPDBG_STATE_UNINITIALIZED);
    111         }
    112     }
    113     else if (ASMAtomicReadU32((volatile uint32_t *)&g_VBoxDispDbg.enmState) == VBOXDISPDBG_STATE_INITIALIZED)
    114     {
    115         return &g_VBoxDispDbg;
    116     }
    117     Assert(0);
    118     return NULL;
    119 }
    120 
    121 void vboxDispLogDrv(char * szString)
    122 {
    123     PVBOXDISPDBG pDbg = vboxDispDbgGet();
    124     if (!pDbg)
    125     {
    126         /* do not use WARN her esince this would lead to a recursion */
    127         WARN_BREAK();
    128         return;
    129     }
    130 
    131     VBOXDISPKMT_ADAPTER Adapter;
    132     HRESULT hr = vboxDispKmtOpenAdapter(&pDbg->KmtCallbacks, &Adapter);
    133     if (hr == S_OK)
    134     {
    135         uint32_t cbString = (uint32_t)strlen(szString) + 1;
    136         uint32_t cbCmd = RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[cbString]);
    137         PVBOXDISPIFESCAPE_DBGPRINT pCmd = (PVBOXDISPIFESCAPE_DBGPRINT)RTMemAllocZ(cbCmd);
    138         if (pCmd)
    139         {
    140             pCmd->EscapeHdr.escapeCode = VBOXESC_DBGPRINT;
    141             memcpy(pCmd->aStringBuf, szString, cbString);
    142 
    143             D3DKMT_ESCAPE EscapeData = {0};
    144             EscapeData.hAdapter = Adapter.hAdapter;
    145             //EscapeData.hDevice = NULL;
    146             EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
    147     //        EscapeData.Flags.HardwareAccess = 1;
    148             EscapeData.pPrivateDriverData = pCmd;
    149             EscapeData.PrivateDriverDataSize = cbCmd;
    150             //EscapeData.hContext = NULL;
    151 
    152             int Status = pDbg->KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
    153             if (Status)
    154             {
    155                 WARN_BREAK();
    156             }
    157 
    158             RTMemFree(pCmd);
    159         }
    160         else
    161         {
    162             WARN_BREAK();
    163         }
    164         hr = vboxDispKmtCloseAdapter(&Adapter);
    165         if(hr != S_OK)
    166         {
    167             WARN_BREAK();
    168         }
    169     }
    170 }
    171 
    172 void vboxDispLogDrvF(char * szString, ...)
     82
     83void vboxDispLogDbgPrintF(char * szString, ...)
    17384{
    17485    char szBuffer[4096] = {0};
    … …  
    17889    va_end(pArgList);
    17990
    180     vboxDispLogDrv(szBuffer);
    181 }
    182 
    183 void vboxDispLogDbgPrintF(char * szString, ...)
    184 {
    185     char szBuffer[4096] = {0};
    186     va_list pArgList;
    187     va_start(pArgList, szString);
    188     _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
    189     va_end(pArgList);
    190 
    19191    OutputDebugStringA(szBuffer);
    19292}
    193 
    19493
    19594VOID vboxVDbgDoDumpSurfRectByAlloc(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc, const RECT *pRect, const char* pSuffix)
    … …  
    771670
    772671#endif
     672
     673#if defined(VBOXWDDMDISP_DEBUG) || defined(LOG_TO_BACKDOOR_DRV)
     674typedef enum
     675{
     676    VBOXDISPDBG_STATE_UNINITIALIZED = 0,
     677    VBOXDISPDBG_STATE_INITIALIZING,
     678    VBOXDISPDBG_STATE_INITIALIZED,
     679} VBOXDISPDBG_STATE;
     680
     681typedef struct VBOXDISPDBG
     682{
     683    VBOXDISPKMT_CALLBACKS KmtCallbacks;
     684    VBOXDISPDBG_STATE enmState;
     685} VBOXDISPDBG, *PVBOXDISPDBG;
     686
     687static VBOXDISPDBG g_VBoxDispDbg = {0};
     688
     689PVBOXDISPDBG vboxDispDbgGet()
     690{
     691    if (ASMAtomicCmpXchgU32((volatile uint32_t *)&g_VBoxDispDbg.enmState, VBOXDISPDBG_STATE_INITIALIZING, VBOXDISPDBG_STATE_UNINITIALIZED))
     692    {
     693        HRESULT hr = vboxDispKmtCallbacksInit(&g_VBoxDispDbg.KmtCallbacks);
     694        Assert(hr == S_OK);
     695        if (hr == S_OK)
     696        {
     697            ASMAtomicWriteU32((volatile uint32_t *)&g_VBoxDispDbg.enmState, VBOXDISPDBG_STATE_INITIALIZED);
     698            return &g_VBoxDispDbg;
     699        }
     700        else
     701        {
     702            ASMAtomicWriteU32((volatile uint32_t *)&g_VBoxDispDbg.enmState, VBOXDISPDBG_STATE_UNINITIALIZED);
     703        }
     704    }
     705    else if (ASMAtomicReadU32((volatile uint32_t *)&g_VBoxDispDbg.enmState) == VBOXDISPDBG_STATE_INITIALIZED)
     706    {
     707        return &g_VBoxDispDbg;
     708    }
     709    Assert(0);
     710    return NULL;
     711}
     712
     713void vboxDispLogDrv(char * szString)
     714{
     715    PVBOXDISPDBG pDbg = vboxDispDbgGet();
     716    if (!pDbg)
     717    {
     718        /* do not use WARN her esince this would lead to a recursion */
     719        BP_WARN();
     720        return;
     721    }
     722
     723    VBOXDISPKMT_ADAPTER Adapter;
     724    HRESULT hr = vboxDispKmtOpenAdapter(&pDbg->KmtCallbacks, &Adapter);
     725    if (hr == S_OK)
     726    {
     727        uint32_t cbString = (uint32_t)strlen(szString) + 1;
     728        uint32_t cbCmd = RT_OFFSETOF(VBOXDISPIFESCAPE_DBGPRINT, aStringBuf[cbString]);
     729        PVBOXDISPIFESCAPE_DBGPRINT pCmd = (PVBOXDISPIFESCAPE_DBGPRINT)RTMemAllocZ(cbCmd);
     730        if (pCmd)
     731        {
     732            pCmd->EscapeHdr.escapeCode = VBOXESC_DBGPRINT;
     733            memcpy(pCmd->aStringBuf, szString, cbString);
     734
     735            D3DKMT_ESCAPE EscapeData = {0};
     736            EscapeData.hAdapter = Adapter.hAdapter;
     737            //EscapeData.hDevice = NULL;
     738            EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
     739    //        EscapeData.Flags.HardwareAccess = 1;
     740            EscapeData.pPrivateDriverData = pCmd;
     741            EscapeData.PrivateDriverDataSize = cbCmd;
     742            //EscapeData.hContext = NULL;
     743
     744            int Status = pDbg->KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
     745            if (Status)
     746            {
     747                BP_WARN();
     748            }
     749
     750            RTMemFree(pCmd);
     751        }
     752        else
     753        {
     754            BP_WARN();
     755        }
     756        hr = vboxDispKmtCloseAdapter(&Adapter);
     757        if(hr != S_OK)
     758        {
     759            BP_WARN();
     760        }
     761    }
     762}
     763
     764void vboxDispLogDrvF(char * szString, ...)
     765{
     766    char szBuffer[4096] = {0};
     767    va_list pArgList;
     768    va_start(pArgList, szString);
     769    _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
     770    va_end(pArgList);
     771
     772    vboxDispLogDrv(szBuffer);
     773}
     774
     775static void vboxDispDumpBufDrv(void *pvBuf, uint32_t cbBuf, VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE enmBuf)
     776{
     777    PVBOXDISPDBG pDbg = vboxDispDbgGet();
     778    if (!pDbg)
     779    {
     780        /* do not use WARN her esince this would lead to a recursion */
     781        BP_WARN();
     782        return;
     783    }
     784
     785    VBOXDISPKMT_ADAPTER Adapter;
     786    HRESULT hr = vboxDispKmtOpenAdapter(&pDbg->KmtCallbacks, &Adapter);
     787    if (hr == S_OK)
     788    {
     789        uint32_t cbCmd = RT_OFFSETOF(VBOXDISPIFESCAPE_DBGDUMPBUF, aBuf[cbBuf]);
     790        PVBOXDISPIFESCAPE_DBGDUMPBUF pCmd = (PVBOXDISPIFESCAPE_DBGDUMPBUF)RTMemAllocZ(cbCmd);
     791        if (pCmd)
     792        {
     793            pCmd->EscapeHdr.escapeCode = VBOXESC_DBGDUMPBUF;
     794            pCmd->enmType = enmBuf;
     795#ifdef VBOX_WDDM_WOW64
     796            pCmd->Flags.WoW64 = 1;
     797#endif
     798            memcpy(pCmd->aBuf, pvBuf, cbBuf);
     799
     800            D3DKMT_ESCAPE EscapeData = {0};
     801            EscapeData.hAdapter = Adapter.hAdapter;
     802            //EscapeData.hDevice = NULL;
     803            EscapeData.Type = D3DKMT_ESCAPE_DRIVERPRIVATE;
     804    //        EscapeData.Flags.HardwareAccess = 1;
     805            EscapeData.pPrivateDriverData = pCmd;
     806            EscapeData.PrivateDriverDataSize = cbCmd;
     807            //EscapeData.hContext = NULL;
     808
     809            int Status = pDbg->KmtCallbacks.pfnD3DKMTEscape(&EscapeData);
     810            if (Status)
     811            {
     812                BP_WARN();
     813            }
     814
     815            RTMemFree(pCmd);
     816        }
     817        else
     818        {
     819            BP_WARN();
     820        }
     821        hr = vboxDispKmtCloseAdapter(&Adapter);
     822        if(hr != S_OK)
     823        {
     824            BP_WARN();
     825        }
     826    }
     827}
     828
     829void vboxDispDumpD3DCAPS9Drv(D3DCAPS9 *pCaps)
     830{
     831    vboxDispDumpBufDrv(pCaps, sizeof (*pCaps), VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_D3DCAPS9);
     832}
     833#endif

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.h

    r39155 r39160  
    1919#ifndef ___VBoxDispDbg_h__
    2020#define ___VBoxDispDbg_h__
     21
     22#define VBOX_VIDEO_LOG_NAME "VBoxD3D"
     23#define VBOX_VIDEO_LOG_LOGGER vboxVDbgInternalLogLogger
     24#define VBOX_VIDEO_LOGREL_LOGGER vboxVDbgInternalLogRelLogger
     25#define VBOX_VIDEO_LOGFLOW_LOGGER vboxVDbgInternalLogFlowLogger
     26#define VBOX_VIDEO_LOG_FN_FMT "%s"
     27
     28#include "../../common/VBoxVideoLog.h"
    2129
    2230#ifdef DEBUG
    … …  
    9098#endif
    9199
    92 #ifdef VBOXWDDMDISP_DEBUG_PRINTDRV
     100#if defined(LOG_TO_BACKDOOR_DRV) || defined(VBOXWDDMDISP_DEBUG_PRINTDRV)
    93101# define DbgPrintDrv(_m) do { vboxDispLogDrvF _m; } while (0)
    94102# define DbgPrintDrvRel(_m) do { vboxDispLogDrvF _m; } while (0)
    95 # define DbgPrintDrvFlow(_m) do { } while (0)
     103# define DbgPrintDrvFlow(_m) do { vboxDispLogDrvF _m; } while (0)
    96104#else
    97105# define DbgPrintDrv(_m) do { } while (0)
    … …  
    109117# define DbgPrintUsrFlow(_m) do { } while (0)
    110118#endif
    111 #ifdef DEBUG_misha
    112 # define WARN_BREAK() do { AssertFailed(); } while (0)
    113 #else
    114 # define WARN_BREAK() do { } while (0)
    115 #endif
    116119
    117120#ifdef VBOXWDDMDISP_DEBUG
    … …  
    125128#endif
    126129
    127 #define WARN(_m) do { \
     130/* @todo: remove these from the code and from here */
     131#define vboxVDbgPrint(_m) LOG_EXACT(_m)
     132#define vboxVDbgPrintF(_m) LOGF_EXACT(_m)
     133#define vboxVDbgPrintR(_m)  LOGREL_EXACT(_m)
     134
     135#define vboxVDbgInternalLogLogger(_m) do { \
    128136        vboxVDbgInternalLog( \
    129137            Log(_m); \
    … …  
    131139            DbgPrintDrv(_m); \
    132140        ); \
    133         WARN_BREAK(); \
    134     } while (0)
    135 #define vboxVDbgPrint(_m) do { \
    136         vboxVDbgInternalLog( \
    137             Log(_m); \
    138             DbgPrintUsr(_m); \
    139             DbgPrintDrv(_m); \
    140         ); \
    141     } while (0)
    142 #define vboxVDbgPrintF(_m)  do { \
     141    } while (0)
     142
     143#define vboxVDbgInternalLogFlowLogger(_m)  do { \
    143144        vboxVDbgInternalLogFlow( \
    144145            LogFlow(_m); \
    … …  
    147148        ); \
    148149    } while (0)
    149 #define vboxVDbgPrintR(_m)  do { \
     150
     151#define vboxVDbgInternalLogRelLogger(_m)  do { \
    150152        vboxVDbgInternalLogRel( \
    151153            LogRel(_m); \
    … …  
    155157    } while (0)
    156158
    157 #define LOG vboxVDbgPrint
    158 #define LOGREL vboxVDbgPrintR
    159 #define LOGFLOW vboxVDbgPrintF
    160 
    161 #ifdef VBOXWDDMDISP_DEBUG
     159#if defined(VBOXWDDMDISP_DEBUG) || defined(LOG_TO_BACKDOOR_DRV)
    162160
    163161void vboxDispLogDrvF(char * szString, ...);
    164162void vboxDispLogDrv(char * szString);
     163void vboxDispDumpD3DCAPS9Drv(D3DCAPS9 *pCaps);
     164
     165# define vboxDispDumpD3DCAPS9(_pCaps) do { vboxDispDumpD3DCAPS9Drv(_pCaps); } while (0)
     166#else
     167# define vboxDispDumpD3DCAPS9(_pCaps) do { } while (0)
     168#endif
     169
     170#ifdef VBOXWDDMDISP_DEBUG
     171
    165172void vboxDispLogDbgPrintF(char * szString, ...);
    166173

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.cpp

    r38982 r39160  
    14741474}
    14751475
     1476/* dump user-mode driver debug info */
     1477static char    g_aVBoxUmdD3DCAPS9[304];
     1478static VBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS g_VBoxUmdD3DCAPS9Flags;
     1479static BOOLEAN g_bVBoxUmdD3DCAPS9IsInited = FALSE;
     1480
     1481static void vboxUmdDumpDword(DWORD *pvData, DWORD cData)
     1482{
     1483    char aBuf[16*4];
     1484    DWORD dw1, dw2, dw3, dw4;
     1485    for (UINT i = 0; i < (cData & (~3)); i+=4)
     1486    {
     1487        dw1 = *pvData++;
     1488        dw2 = *pvData++;
     1489        dw3 = *pvData++;
     1490        dw4 = *pvData++;
     1491        sprintf(aBuf, "0x%08x, 0x%08x, 0x%08x, 0x%08x,\n", dw1, dw2, dw3, dw4);
     1492        LOGREL(("%s", aBuf));
     1493    }
     1494
     1495    cData = cData % 4;
     1496    switch (cData)
     1497    {
     1498        case 3:
     1499            dw1 = *pvData++;
     1500            dw2 = *pvData++;
     1501            dw3 = *pvData++;
     1502            sprintf(aBuf, "0x%08x, 0x%08x, 0x%08x\n", dw1, dw2, dw3);
     1503            LOGREL(("%s", aBuf));
     1504            break;
     1505        case 2:
     1506            dw1 = *pvData++;
     1507            dw2 = *pvData++;
     1508            sprintf(aBuf, "0x%08x, 0x%08x\n", dw1, dw2);
     1509            LOGREL(("%s", aBuf));
     1510            break;
     1511        case 1:
     1512            dw1 = *pvData++;
     1513            sprintf(aBuf, "0x%8x\n", dw1);
     1514            LOGREL(("%s", aBuf));
     1515            break;
     1516        default:
     1517            break;
     1518    }
     1519}
     1520
     1521static void vboxUmdDumpD3DCAPS9(void *pvData, PVBOXDISPIFESCAPE_DBGDUMPBUF_FLAGS pFlags)
     1522{
     1523    AssertCompile(!(sizeof (g_aVBoxUmdD3DCAPS9) % sizeof (DWORD)));
     1524    LOGREL(("*****Start Dumping D3DCAPS9:*******"));
     1525    LOGREL(("WoW64 flag(%d)", (UINT)pFlags->WoW64));
     1526    vboxUmdDumpDword((DWORD*)pvData, sizeof (g_aVBoxUmdD3DCAPS9) / sizeof (DWORD));
     1527    LOGREL(("*****End Dumping D3DCAPS9**********"));
     1528}
     1529
     1530NTSTATUS vboxUmdDumpBuf(PVBOXDISPIFESCAPE_DBGDUMPBUF pBuf, uint32_t cbBuffer)
     1531{
     1532    if (cbBuffer < RT_OFFSETOF(VBOXDISPIFESCAPE_DBGDUMPBUF, aBuf[0]))
     1533    {
     1534        WARN(("Buffer too small"));
     1535        return STATUS_BUFFER_TOO_SMALL;
     1536    }
     1537
     1538    NTSTATUS Status = STATUS_SUCCESS;
     1539    uint32_t cbString = cbBuffer - RT_OFFSETOF(VBOXDISPIFESCAPE_DBGDUMPBUF, aBuf[0]);
     1540    switch (pBuf->enmType)
     1541    {
     1542        case VBOXDISPIFESCAPE_DBGDUMPBUF_TYPE_D3DCAPS9:
     1543        {
     1544            if (cbString != sizeof (g_aVBoxUmdD3DCAPS9))
     1545            {
     1546                WARN(("wrong caps size, expected %d, but was %d", sizeof (g_aVBoxUmdD3DCAPS9), cbString));
     1547                Status = STATUS_INVALID_PARAMETER;
     1548                break;
     1549            }
     1550
     1551            if (g_bVBoxUmdD3DCAPS9IsInited)
     1552            {
     1553                if (!memcmp(g_aVBoxUmdD3DCAPS9, pBuf->aBuf, sizeof (g_aVBoxUmdD3DCAPS9)))
     1554                    break;
     1555
     1556                WARN(("caps do not match!"));
     1557                vboxUmdDumpD3DCAPS9(pBuf->aBuf, &pBuf->Flags);
     1558                break;
     1559            }
     1560
     1561            memcpy(g_aVBoxUmdD3DCAPS9, pBuf->aBuf, sizeof (g_aVBoxUmdD3DCAPS9));
     1562            g_VBoxUmdD3DCAPS9Flags = pBuf->Flags;
     1563            g_bVBoxUmdD3DCAPS9IsInited = TRUE;
     1564            vboxUmdDumpD3DCAPS9(pBuf->aBuf, &pBuf->Flags);
     1565        }
     1566    }
     1567
     1568    return Status;
     1569}
     1570
    14761571#if 0
    14771572VOID vboxShRcTreeInit(PVBOXMP_DEVEXT pDevExt)

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPMisc.h

    r38982 r39160  
    151151VOID vboxWddmCounterU32Wait(uint32_t volatile * pu32, uint32_t u32Val);
    152152
     153NTSTATUS vboxUmdDumpBuf(PVBOXDISPIFESCAPE_DBGDUMPBUF pBuf, uint32_t cbBuffer);
     154
    153155#if 0
    154156/* wine shrc handle -> allocation map */

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm/VBoxMPWddm.cpp

    r39150 r39160  
    38433843                    DbgPrint("%s", pDbgPrint->aStringBuf);
    38443844#else
    3845                     LOGREL(("%s", pDbgPrint->aStringBuf));
     3845                    LOGREL_EXACT(("%s", pDbgPrint->aStringBuf));
    38463846#endif
    38473847                }
    38483848                Status = STATUS_SUCCESS;
     3849                break;
     3850            }
     3851            case VBOXESC_DBGDUMPBUF:
     3852            {
     3853                Status = vboxUmdDumpBuf((PVBOXDISPIFESCAPE_DBGDUMPBUF)pEscapeHdr, pEscape->PrivateDriverDataSize);
    38493854                break;
    38503855            }

  • trunk/src/VBox/Additions/WINNT/include/VBoxDisplay.h

    r38982 r39160  
    3232# define VBOXESC_SHRC_ADDREF                0xABCD900B
    3333# define VBOXESC_SHRC_RELEASE               0xABCD900C
     34# define VBOXESC_DBGDUMPBUF                 0xABCD900D
    3435
    3536typedef struct
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette