VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispDbg.cpp@ 44529

Last change on this file since 44529 was 44529, checked in by vboxsync, 12 years ago

header (C) fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 24.4 KB
Line 
1/* $Id: VBoxDispDbg.cpp 44529 2013-02-04 15:54:15Z vboxsync $ */
2
3/** @file
4 * VBoxVideo Display D3D User mode dll
5 */
6
7/*
8 * Copyright (C) 2011-2012 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19/* @todo: move this to VBoxDispD3DCmn.h ? */
20# if (_MSC_VER >= 1400) && !defined(VBOX_WITH_PATCHED_DDK)
21# define _InterlockedExchange _InterlockedExchange_StupidDDKVsCompilerCrap
22# define _InterlockedExchangeAdd _InterlockedExchangeAdd_StupidDDKVsCompilerCrap
23# define _InterlockedCompareExchange _InterlockedCompareExchange_StupidDDKVsCompilerCrap
24# define _InterlockedAddLargeStatistic _InterlockedAddLargeStatistic_StupidDDKVsCompilerCrap
25# define _interlockedbittestandset _interlockedbittestandset_StupidDDKVsCompilerCrap
26# define _interlockedbittestandreset _interlockedbittestandreset_StupidDDKVsCompilerCrap
27# define _interlockedbittestandset64 _interlockedbittestandset64_StupidDDKVsCompilerCrap
28# define _interlockedbittestandreset64 _interlockedbittestandreset64_StupidDDKVsCompilerCrap
29# pragma warning(disable : 4163)
30# include <windows.h>
31# pragma warning(default : 4163)
32# undef _InterlockedExchange
33# undef _InterlockedExchangeAdd
34# undef _InterlockedCompareExchange
35# undef _InterlockedAddLargeStatistic
36# undef _interlockedbittestandset
37# undef _interlockedbittestandreset
38# undef _interlockedbittestandset64
39# undef _interlockedbittestandreset64
40# else
41# include <windows.h>
42# endif
43
44#include "VBoxDispD3DCmn.h"
45
46#include <stdio.h>
47#include <stdarg.h>
48
49#include <iprt/asm.h>
50#include <iprt/assert.h>
51
52static DWORD g_VBoxVDbgFIsModuleNameInited = 0;
53static char g_VBoxVDbgModuleName[MAX_PATH];
54
55char *vboxVDbgDoGetModuleName()
56{
57 if (!g_VBoxVDbgFIsModuleNameInited)
58 {
59 DWORD cName = GetModuleFileNameA(NULL, g_VBoxVDbgModuleName, RT_ELEMENTS(g_VBoxVDbgModuleName));
60 if (!cName)
61 {
62 DWORD winEr = GetLastError();
63 WARN(("GetModuleFileNameA failed, winEr %d", winEr));
64 return NULL;
65 }
66 g_VBoxVDbgFIsModuleNameInited = TRUE;
67 }
68 return g_VBoxVDbgModuleName;
69}
70
71static void vboxDispLogDbgFormatStringV(char * szBuffer, uint32_t cbBuffer, const char * szString, va_list pArgList)
72{
73 uint32_t cbWritten = sprintf(szBuffer, "['%s' 0x%x.0x%x] Disp: ", vboxVDbgDoGetModuleName(), GetCurrentProcessId(), GetCurrentThreadId());
74 if (cbWritten > cbBuffer)
75 {
76 AssertReleaseFailed();
77 return;
78 }
79
80 _vsnprintf(szBuffer + cbWritten, cbBuffer - cbWritten, szString, pArgList);
81}
82
83#if defined(VBOXWDDMDISP_DEBUG) || defined(VBOX_WDDMDISP_WITH_PROFILE)
84LONG g_VBoxVDbgFIsDwm = -1;
85
86DWORD g_VBoxVDbgPid = 0;
87#endif
88
89#ifdef VBOXWDDMDISP_DEBUG
90
91DWORD g_VBoxVDbgFLogRel = 1;
92DWORD g_VBoxVDbgFLog = 1;
93DWORD g_VBoxVDbgFLogFlow = 0;
94
95# ifndef IN_VBOXCRHGSMI
96#define VBOXWDDMDISP_DEBUG_DUMP_DEFAULT 0
97DWORD g_VBoxVDbgFDumpSetTexture = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
98DWORD g_VBoxVDbgFDumpDrawPrim = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
99DWORD g_VBoxVDbgFDumpTexBlt = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
100DWORD g_VBoxVDbgFDumpBlt = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
101DWORD g_VBoxVDbgFDumpRtSynch = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
102DWORD g_VBoxVDbgFDumpFlush = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
103DWORD g_VBoxVDbgFDumpShared = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
104DWORD g_VBoxVDbgFDumpLock = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
105DWORD g_VBoxVDbgFDumpUnlock = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
106DWORD g_VBoxVDbgFDumpPresentEnter = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
107DWORD g_VBoxVDbgFDumpPresentLeave = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
108DWORD g_VBoxVDbgFDumpScSync = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
109
110DWORD g_VBoxVDbgFBreakShared = VBOXWDDMDISP_DEBUG_DUMP_DEFAULT;
111DWORD g_VBoxVDbgFBreakDdi = 0;
112
113DWORD g_VBoxVDbgFCheckSysMemSync = 0;
114DWORD g_VBoxVDbgFCheckBlt = 0;
115DWORD g_VBoxVDbgFCheckTexBlt = 0;
116DWORD g_VBoxVDbgFCheckScSync = 0;
117
118DWORD g_VBoxVDbgFSkipCheckTexBltDwmWndUpdate = 1;
119
120DWORD g_VBoxVDbgCfgMaxDirectRts = 3;
121DWORD g_VBoxVDbgCfgForceDummyDevCreate = 0;
122
123PVBOXWDDMDISP_DEVICE g_VBoxVDbgInternalDevice = NULL;
124PVBOXWDDMDISP_RESOURCE g_VBoxVDbgInternalRc = NULL;
125
126DWORD g_VBoxVDbgCfgCreateSwapchainOnDdiOnce = 0;
127
128void vboxDispLogDbgPrintF(char * szString, ...)
129{
130 char szBuffer[4096] = {0};
131 va_list pArgList;
132 va_start(pArgList, szString);
133 vboxDispLogDbgFormatStringV(szBuffer, sizeof (szBuffer), szString, pArgList);
134 va_end(pArgList);
135
136 OutputDebugStringA(szBuffer);
137}
138
139VOID vboxVDbgDoPrintDmlCmd(const char* pszDesc, const char* pszCmd)
140{
141 vboxVDbgPrint(("<?dml?><exec cmd=\"%s\">%s</exec>, ( %s )\n", pszCmd, pszDesc, pszCmd));
142}
143
144VOID vboxVDbgDoPrintDumpCmd(const char* pszDesc, const void *pvData, uint32_t width, uint32_t height, uint32_t bpp, uint32_t pitch)
145{
146 char Cmd[1024];
147 sprintf(Cmd, "!vbvdbg.ms 0x%p 0n%d 0n%d 0n%d 0n%d", pvData, width, height, bpp, pitch);
148 vboxVDbgDoPrintDmlCmd(pszDesc, Cmd);
149}
150
151VOID vboxVDbgDoPrintLopLastCmd(const char* pszDesc)
152{
153 vboxVDbgDoPrintDmlCmd(pszDesc, "ed @@(&vboxVDbgLoop) 0");
154}
155
156typedef struct VBOXVDBG_DUMP_INFO
157{
158 DWORD fFlags;
159 PVBOXWDDMDISP_ALLOCATION pAlloc;
160 IDirect3DResource9 *pD3DRc;
161 RECT *pRect;
162} VBOXVDBG_DUMP_INFO, *PVBOXVDBG_DUMP_INFO;
163
164typedef DECLCALLBACK(void) FNVBOXVDBG_CONTENTS_DUMPER(PVBOXVDBG_DUMP_INFO pInfo, BOOLEAN fBreak, void *pvDumper);
165typedef FNVBOXVDBG_CONTENTS_DUMPER *PFNVBOXVDBG_CONTENTS_DUMPER;
166
167static VOID vboxVDbgDoDumpSummary(const char * pPrefix, PVBOXVDBG_DUMP_INFO pInfo, const char * pSuffix)
168{
169 PVBOXWDDMDISP_ALLOCATION pAlloc = pInfo->pAlloc;
170 IDirect3DResource9 *pD3DRc = pInfo->pD3DRc;
171 char rectBuf[24];
172 if (pInfo->pRect)
173 _snprintf(rectBuf, sizeof(rectBuf) / sizeof(rectBuf[0]), "(%d:%d);(%d:%d)",
174 pInfo->pRect->left, pInfo->pRect->top,
175 pInfo->pRect->right, pInfo->pRect->bottom);
176 else
177 strcpy(rectBuf, "n/a");
178
179 vboxVDbgPrint(("%s Sh(0x%p), Rc(0x%p), pAlloc(0x%x), pD3DIf(0x%p), Type(%s), Rect(%s), Locks(%d) %s",
180 pPrefix ? pPrefix : "",
181 pAlloc ? pAlloc->pRc->aAllocations[0].hSharedHandle : NULL,
182 pAlloc ? pAlloc->pRc : NULL,
183 pAlloc,
184 pD3DRc,
185 pD3DRc ? vboxDispLogD3DRcType(pD3DRc->GetType()) : "n/a",
186 rectBuf,
187 pAlloc ? pAlloc->LockInfo.cLocks : 0,
188 pSuffix ? pSuffix : ""));
189}
190
191VOID vboxVDbgDoDumpPerform(const char * pPrefix, PVBOXVDBG_DUMP_INFO pInfo, const char * pSuffix,
192 PFNVBOXVDBG_CONTENTS_DUMPER pfnCd, void *pvCd)
193{
194 DWORD fFlags = pInfo->fFlags;
195
196 if (!VBOXVDBG_DUMP_TYPE_ENABLED_FOR_INFO(pInfo, fFlags))
197 return;
198
199 if (!pInfo->pD3DRc && pInfo->pAlloc)
200 pInfo->pD3DRc = (IDirect3DResource9*)pInfo->pAlloc->pD3DIf;
201
202 BOOLEAN bLogOnly = VBOXVDBG_DUMP_TYPE_FLOW_ONLY(fFlags);
203 if (bLogOnly || !pfnCd)
204 {
205 vboxVDbgDoDumpSummary(pPrefix, pInfo, pSuffix);
206 if (VBOXVDBG_DUMP_FLAGS_IS_SET(fFlags, VBOXVDBG_DUMP_TYPEF_BREAK_ON_FLOW)
207 || (!bLogOnly && VBOXVDBG_DUMP_FLAGS_IS_CLEARED(fFlags, VBOXVDBG_DUMP_TYPEF_DONT_BREAK_ON_CONTENTS)))
208 Assert(0);
209 return;
210 }
211
212 vboxVDbgDoDumpSummary(pPrefix, pInfo, NULL);
213
214 pfnCd(pInfo, VBOXVDBG_DUMP_FLAGS_IS_CLEARED(fFlags, VBOXVDBG_DUMP_TYPEF_DONT_BREAK_ON_CONTENTS), pvCd);
215
216 if (pSuffix && pSuffix[0] != '\0')
217 vboxVDbgPrint(("%s", pSuffix));
218}
219
220static DECLCALLBACK(void) vboxVDbgAllocRectContentsDumperCb(PVBOXVDBG_DUMP_INFO pInfo, BOOLEAN fBreak, void *pvDumper)
221{
222 PVBOXWDDMDISP_ALLOCATION pAlloc = pInfo->pAlloc;
223 const RECT *pRect = pInfo->pRect;
224
225 Assert(pAlloc->hAllocation);
226
227 D3DDDICB_LOCK LockData;
228 LockData.hAllocation = pAlloc->hAllocation;
229 LockData.PrivateDriverData = 0;
230 LockData.NumPages = 0;
231 LockData.pPages = NULL;
232 LockData.pData = NULL; /* out */
233 LockData.Flags.Value = 0;
234 LockData.Flags.LockEntire =1;
235 LockData.Flags.ReadOnly = 1;
236
237 PVBOXWDDMDISP_DEVICE pDevice = pAlloc->pRc->pDevice;
238
239 HRESULT hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
240 Assert(hr == S_OK);
241 if (hr == S_OK)
242 {
243 UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
244 vboxVDbgDoPrintDumpCmd("Surf Info", LockData.pData, pAlloc->SurfDesc.d3dWidth, pAlloc->SurfDesc.height, bpp, pAlloc->SurfDesc.pitch);
245 if (pRect)
246 {
247 Assert(pRect->right > pRect->left);
248 Assert(pRect->bottom > pRect->top);
249 vboxVDbgDoPrintRect("rect: ", pRect, "\n");
250 vboxVDbgDoPrintDumpCmd("Rect Info", ((uint8_t*)LockData.pData) + (pRect->top * pAlloc->SurfDesc.pitch) + ((pRect->left * bpp) >> 3),
251 pRect->right - pRect->left, pRect->bottom - pRect->top, bpp, pAlloc->SurfDesc.pitch);
252 }
253 Assert(0);
254
255 D3DDDICB_UNLOCK DdiUnlock;
256
257 DdiUnlock.NumAllocations = 1;
258 DdiUnlock.phAllocations = &pAlloc->hAllocation;
259
260 hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &DdiUnlock);
261 Assert(hr == S_OK);
262 }
263}
264
265VOID vboxVDbgDoDumpAllocRect(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc, RECT *pRect, const char* pSuffix, DWORD fFlags)
266{
267 VBOXVDBG_DUMP_INFO Info;
268 Info.fFlags = fFlags;
269 Info.pAlloc = pAlloc;
270 Info.pD3DRc = NULL;
271 Info.pRect = pRect;
272 vboxVDbgDoDumpPerform(pPrefix, &Info, pSuffix, vboxVDbgAllocRectContentsDumperCb, NULL);
273}
274
275static DECLCALLBACK(void) vboxVDbgRcRectContentsDumperCb(PVBOXVDBG_DUMP_INFO pInfo, BOOLEAN fBreak, void *pvDumper)
276{
277 PVBOXWDDMDISP_ALLOCATION pAlloc = pInfo->pAlloc;
278 IDirect3DResource9 *pD3DRc = pInfo->pD3DRc;
279 const RECT *pRect = pInfo->pRect;
280 IDirect3DSurface9 *pSurf;
281 HRESULT hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pSurf);
282 if (hr != S_OK)
283 {
284 WARN(("VBoxD3DIfSurfGet failed, hr 0x%x", hr));
285 return;
286 }
287
288 D3DSURFACE_DESC Desc;
289 hr = pSurf->GetDesc(&Desc);
290 Assert(hr == S_OK);
291 if (hr == S_OK)
292 {
293 D3DLOCKED_RECT Lr;
294 hr = pSurf->LockRect(&Lr, NULL, D3DLOCK_READONLY);
295 Assert(hr == S_OK);
296 if (hr == S_OK)
297 {
298 UINT bpp = vboxWddmCalcBitsPerPixel((D3DDDIFORMAT)Desc.Format);
299 vboxVDbgDoPrintDumpCmd("Surf Info", Lr.pBits, Desc.Width, Desc.Height, bpp, Lr.Pitch);
300 if (pRect)
301 {
302 Assert(pRect->right > pRect->left);
303 Assert(pRect->bottom > pRect->top);
304 vboxVDbgDoPrintRect("rect: ", pRect, "\n");
305 vboxVDbgDoPrintDumpCmd("Rect Info", ((uint8_t*)Lr.pBits) + (pRect->top * Lr.Pitch) + ((pRect->left * bpp) >> 3),
306 pRect->right - pRect->left, pRect->bottom - pRect->top, bpp, Lr.Pitch);
307 }
308
309 if (fBreak)
310 {
311 Assert(0);
312 }
313 hr = pSurf->UnlockRect();
314 Assert(hr == S_OK);
315 }
316 }
317}
318
319VOID vboxVDbgDoDumpRcRect(const char * pPrefix, PVBOXWDDMDISP_ALLOCATION pAlloc,
320 IDirect3DResource9 *pD3DRc, RECT *pRect, const char * pSuffix, DWORD fFlags)
321{
322 VBOXVDBG_DUMP_INFO Info;
323 Info.fFlags = fFlags;
324 Info.pAlloc = pAlloc;
325 Info.pD3DRc = pD3DRc;
326 Info.pRect = pRect;
327 vboxVDbgDoDumpPerform(pPrefix, &Info, pSuffix, vboxVDbgRcRectContentsDumperCb, NULL);
328}
329
330VOID vboxVDbgDoDumpBb(const char * pPrefix, IDirect3DSwapChain9 *pSwapchainIf, const char * pSuffix, DWORD fFlags)
331{
332 IDirect3DSurface9 *pBb = NULL;
333 HRESULT hr = pSwapchainIf->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pBb);
334 Assert(hr == S_OK);
335 if (FAILED(hr))
336 {
337 return;
338 }
339
340 Assert(pBb);
341 vboxVDbgDoDumpRcRect(pPrefix, NULL, pBb, NULL, pSuffix, fFlags);
342 pBb->Release();
343}
344
345VOID vboxVDbgDoDumpFb(const char * pPrefix, IDirect3DSwapChain9 *pSwapchainIf, const char * pSuffix, DWORD fFlags)
346{
347 IDirect3DSurface9 *pBb = NULL;
348 HRESULT hr = pSwapchainIf->GetBackBuffer(-1, D3DBACKBUFFER_TYPE_MONO, &pBb);
349 Assert(hr == S_OK);
350 if (FAILED(hr))
351 {
352 return;
353 }
354
355 Assert(pBb);
356 vboxVDbgDoDumpRcRect(pPrefix, NULL, pBb, NULL, pSuffix, fFlags);
357 pBb->Release();
358}
359
360
361#define VBOXVDBG_STRCASE(_t) \
362 case _t: return #_t;
363#define VBOXVDBG_STRCASE_UNKNOWN() \
364 default: Assert(0); return "Unknown";
365
366const char* vboxVDbgStrCubeFaceType(D3DCUBEMAP_FACES enmFace)
367{
368 switch (enmFace)
369 {
370 VBOXVDBG_STRCASE(D3DCUBEMAP_FACE_POSITIVE_X);
371 VBOXVDBG_STRCASE(D3DCUBEMAP_FACE_NEGATIVE_X);
372 VBOXVDBG_STRCASE(D3DCUBEMAP_FACE_POSITIVE_Y);
373 VBOXVDBG_STRCASE(D3DCUBEMAP_FACE_NEGATIVE_Y);
374 VBOXVDBG_STRCASE(D3DCUBEMAP_FACE_POSITIVE_Z);
375 VBOXVDBG_STRCASE(D3DCUBEMAP_FACE_NEGATIVE_Z);
376 VBOXVDBG_STRCASE_UNKNOWN();
377 }
378}
379
380VOID vboxVDbgDoDumpRt(const char * pPrefix, PVBOXWDDMDISP_DEVICE pDevice, const char * pSuffix, DWORD fFlags)
381{
382 for (UINT i = 0; i < pDevice->cRTs; ++i)
383 {
384 IDirect3DSurface9 *pRt;
385 PVBOXWDDMDISP_ALLOCATION pAlloc = pDevice->apRTs[i];
386 IDirect3DDevice9 *pDeviceIf = pDevice->pDevice9If;
387 HRESULT hr = pDeviceIf->GetRenderTarget(i, &pRt);
388 Assert(hr == S_OK);
389 if (hr == S_OK)
390 {
391// Assert(pAlloc->pD3DIf == pRt);
392 vboxVDbgDoDumpRcRect(pPrefix, pAlloc, NULL, NULL, pSuffix, fFlags);
393 pRt->Release();
394 }
395 else
396 {
397 vboxVDbgPrint((__FUNCTION__": ERROR getting rt: 0x%x", hr));
398 }
399 }
400}
401
402VOID vboxVDbgDoDumpSamplers(const char * pPrefix, PVBOXWDDMDISP_DEVICE pDevice, const char * pSuffix, DWORD fFlags)
403{
404 for (UINT i = 0, iSampler = 0; iSampler < pDevice->cSamplerTextures; ++i)
405 {
406 Assert(i < RT_ELEMENTS(pDevice->aSamplerTextures));
407 if (!pDevice->aSamplerTextures[i]) continue;
408 PVBOXWDDMDISP_RESOURCE pRc = pDevice->aSamplerTextures[i];
409 for (UINT j = 0; j < pRc->cAllocations; ++j)
410 {
411 PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[j];
412 vboxVDbgDoDumpRcRect(pPrefix, pAlloc, NULL, NULL, pSuffix, fFlags);
413 }
414 ++iSampler;
415 }
416}
417
418static DECLCALLBACK(void) vboxVDbgLockUnlockSurfTexContentsDumperCb(PVBOXVDBG_DUMP_INFO pInfo, BOOLEAN fBreak, void *pvDumper)
419{
420 PVBOXWDDMDISP_ALLOCATION pAlloc = pInfo->pAlloc;
421 PRECT pRect = pInfo->pRect;
422 UINT bpp = vboxWddmCalcBitsPerPixel(pAlloc->SurfDesc.format);
423 uint32_t width, height, pitch;
424 void *pvData;
425 if (pAlloc->LockInfo.fFlags.AreaValid)
426 {
427 width = pAlloc->LockInfo.Area.left - pAlloc->LockInfo.Area.right;
428 height = pAlloc->LockInfo.Area.bottom - pAlloc->LockInfo.Area.top;
429 }
430 else
431 {
432 width = pAlloc->SurfDesc.width;
433 height = pAlloc->SurfDesc.height;
434 }
435
436 if (pAlloc->LockInfo.fFlags.NotifyOnly)
437 {
438 pitch = pAlloc->SurfDesc.pitch;
439 pvData = ((uint8_t*)pAlloc->pvMem) + pitch*pRect->top + ((bpp*pRect->left) >> 3);
440 }
441 else
442 {
443 pvData = pAlloc->LockInfo.pvData;
444 }
445
446 vboxVDbgDoPrintDumpCmd("Surf Info", pvData, width, height, bpp, pitch);
447
448 if (fBreak)
449 {
450 Assert(0);
451 }
452}
453
454VOID vboxVDbgDoDumpLockUnlockSurfTex(const char * pPrefix, const PVBOXWDDMDISP_ALLOCATION pAlloc, const char * pSuffix, DWORD fFlags)
455{
456 Assert(!pAlloc->hSharedHandle);
457
458 RECT Rect, *pRect;
459 Assert(!pAlloc->LockInfo.fFlags.RangeValid);
460 Assert(!pAlloc->LockInfo.fFlags.BoxValid);
461 if (pAlloc->LockInfo.fFlags.AreaValid)
462 {
463 pRect = &pAlloc->LockInfo.Area;
464 }
465 else
466 {
467 Rect.top = 0;
468 Rect.bottom = pAlloc->SurfDesc.height;
469 Rect.left = 0;
470 Rect.right = pAlloc->SurfDesc.width;
471 pRect = &Rect;
472 }
473
474 VBOXVDBG_DUMP_INFO Info;
475 Info.fFlags = fFlags;
476 Info.pAlloc = pAlloc;
477 Info.pD3DRc = NULL;
478 Info.pRect = pRect;
479 vboxVDbgDoDumpPerform(pPrefix, &Info, pSuffix, vboxVDbgLockUnlockSurfTexContentsDumperCb, NULL);
480}
481
482VOID vboxVDbgDoDumpLockSurfTex(const char * pPrefix, const D3DDDIARG_LOCK* pData, const char * pSuffix, DWORD fFlags)
483{
484 const PVBOXWDDMDISP_RESOURCE pRc = (const PVBOXWDDMDISP_RESOURCE)pData->hResource;
485 const PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
486 pAlloc->LockInfo.pvData = pData->pSurfData;
487 vboxVDbgDoDumpLockUnlockSurfTex(pPrefix, pAlloc, pSuffix, fFlags);
488}
489
490VOID vboxVDbgDoDumpUnlockSurfTex(const char * pPrefix, const D3DDDIARG_UNLOCK* pData, const char * pSuffix, DWORD fFlags)
491{
492 const PVBOXWDDMDISP_RESOURCE pRc = (const PVBOXWDDMDISP_RESOURCE)pData->hResource;
493 const PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
494 vboxVDbgDoDumpLockUnlockSurfTex(pPrefix, pAlloc, pSuffix, fFlags);
495}
496
497BOOL vboxVDbgDoCheckLRects(D3DLOCKED_RECT *pDstLRect, const RECT *pDstRect, D3DLOCKED_RECT *pSrcLRect, const RECT *pSrcRect, DWORD bpp, BOOL fBreakOnMismatch)
498{
499 LONG DstH, DstW, SrcH, SrcW, DstWBytes;
500 BOOL fMatch = FALSE;
501 DstH = pDstRect->bottom - pDstRect->top;
502 DstW = pDstRect->right - pDstRect->left;
503 SrcH = pSrcRect->bottom - pSrcRect->top;
504 SrcW = pSrcRect->right - pSrcRect->left;
505
506 DstWBytes = ((DstW * bpp + 7) >> 3);
507
508 if(DstW != SrcW && DstH != SrcH)
509 {
510 WARN(("stretched comparison not supported!!"));
511 return FALSE;
512 }
513
514 uint8_t *pDst = (uint8_t*)pDstLRect->pBits;
515 uint8_t *pSrc = (uint8_t*)pSrcLRect->pBits;
516 for (LONG i = 0; i < DstH; ++i)
517 {
518 if (!(fMatch = !memcmp(pDst, pSrc, DstWBytes)))
519 {
520 vboxVDbgPrint(("not match!\n"));
521 if (fBreakOnMismatch)
522 Assert(0);
523 break;
524 }
525 pDst += pDstLRect->Pitch;
526 pSrc += pSrcLRect->Pitch;
527 }
528 return fMatch;
529}
530
531BOOL vboxVDbgDoCheckRectsMatch(const PVBOXWDDMDISP_RESOURCE pDstRc, uint32_t iDstAlloc,
532 const PVBOXWDDMDISP_RESOURCE pSrcRc, uint32_t iSrcAlloc,
533 const RECT *pDstRect,
534 const RECT *pSrcRect,
535 BOOL fBreakOnMismatch)
536{
537 BOOL fMatch = FALSE;
538 RECT DstRect = {0}, SrcRect = {0};
539 if (!pDstRect)
540 {
541 DstRect.left = 0;
542 DstRect.right = pDstRc->aAllocations[iDstAlloc].SurfDesc.width;
543 DstRect.top = 0;
544 DstRect.bottom = pDstRc->aAllocations[iDstAlloc].SurfDesc.height;
545 pDstRect = &DstRect;
546 }
547
548 if (!pSrcRect)
549 {
550 SrcRect.left = 0;
551 SrcRect.right = pSrcRc->aAllocations[iSrcAlloc].SurfDesc.width;
552 SrcRect.top = 0;
553 SrcRect.bottom = pSrcRc->aAllocations[iSrcAlloc].SurfDesc.height;
554 pSrcRect = &SrcRect;
555 }
556
557 if (pDstRc == pSrcRc
558 && iDstAlloc == iSrcAlloc)
559 {
560 if (!memcmp(pDstRect, pSrcRect, sizeof (*pDstRect)))
561 {
562 vboxVDbgPrint(("matching same rect of one allocation, skipping..\n"));
563 return TRUE;
564 }
565 WARN(("matching different rects of the same allocation, unsupported!"));
566 return FALSE;
567 }
568
569 if (pDstRc->RcDesc.enmFormat != pSrcRc->RcDesc.enmFormat)
570 {
571 WARN(("matching different formats, unsupported!"));
572 return FALSE;
573 }
574
575 DWORD bpp = pDstRc->aAllocations[iDstAlloc].SurfDesc.bpp;
576 if (!bpp)
577 {
578 WARN(("uninited bpp! unsupported!"));
579 return FALSE;
580 }
581
582 LONG DstH, DstW, SrcH, SrcW;
583 DstH = pDstRect->bottom - pDstRect->top;
584 DstW = pDstRect->right - pDstRect->left;
585 SrcH = pSrcRect->bottom - pSrcRect->top;
586 SrcW = pSrcRect->right - pSrcRect->left;
587
588 if(DstW != SrcW && DstH != SrcH)
589 {
590 WARN(("stretched comparison not supported!!"));
591 return FALSE;
592 }
593
594 D3DLOCKED_RECT SrcLRect, DstLRect;
595 HRESULT hr = VBoxD3DIfLockRect(pDstRc, iDstAlloc, &DstLRect, pDstRect, D3DLOCK_READONLY);
596 if (FAILED(hr))
597 {
598 WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr));
599 return FALSE;
600 }
601
602 hr = VBoxD3DIfLockRect(pSrcRc, iSrcAlloc, &SrcLRect, pSrcRect, D3DLOCK_READONLY);
603 if (FAILED(hr))
604 {
605 WARN(("VBoxD3DIfLockRect failed, hr(0x%x)", hr));
606 hr = VBoxD3DIfUnlockRect(pDstRc, iDstAlloc);
607 return FALSE;
608 }
609
610 fMatch = vboxVDbgDoCheckLRects(&DstLRect, pDstRect, &SrcLRect, pSrcRect, bpp, fBreakOnMismatch);
611
612 hr = VBoxD3DIfUnlockRect(pDstRc, iDstAlloc);
613 Assert(hr == S_OK);
614
615 hr = VBoxD3DIfUnlockRect(pSrcRc, iSrcAlloc);
616 Assert(hr == S_OK);
617
618 return fMatch;
619}
620
621void vboxVDbgDoPrintAlloc(const char * pPrefix, const PVBOXWDDMDISP_RESOURCE pRc, uint32_t iAlloc, const char * pSuffix)
622{
623 Assert(pRc->cAllocations > iAlloc);
624 const PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[iAlloc];
625 BOOL bPrimary = pRc->RcDesc.fFlags.Primary;
626 BOOL bFrontBuf = FALSE;
627 if (bPrimary)
628 {
629 PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainForAlloc(pAlloc);
630 Assert(pSwapchain);
631 bFrontBuf = (vboxWddmSwapchainGetFb(pSwapchain)->pAlloc == pAlloc);
632 }
633 vboxVDbgPrint(("%s d3dWidth(%d), width(%d), height(%d), format(%d), usage(%s), %s", pPrefix,
634 pAlloc->SurfDesc.d3dWidth, pAlloc->SurfDesc.width, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format,
635 bPrimary ?
636 (bFrontBuf ? "Front Buffer" : "Back Buffer")
637 : "?Everage? Alloc",
638 pSuffix));
639}
640
641void vboxVDbgDoPrintRect(const char * pPrefix, const RECT *pRect, const char * pSuffix)
642{
643 vboxVDbgPrint(("%s left(%d), top(%d), right(%d), bottom(%d) %s", pPrefix, pRect->left, pRect->top, pRect->right, pRect->bottom, pSuffix));
644}
645
646# endif
647
648static VOID CALLBACK vboxVDbgTimerCb(__in PVOID lpParameter, __in BOOLEAN TimerOrWaitFired)
649{
650 Assert(0);
651}
652
653HRESULT vboxVDbgTimerStart(HANDLE hTimerQueue, HANDLE *phTimer, DWORD msTimeout)
654{
655 if (!CreateTimerQueueTimer(phTimer, hTimerQueue,
656 vboxVDbgTimerCb,
657 NULL,
658 msTimeout, /* ms*/
659 0,
660 WT_EXECUTEONLYONCE))
661 {
662 DWORD winEr = GetLastError();
663 AssertMsgFailed(("CreateTimerQueueTimer failed, winEr (%d)\n", winEr));
664 return E_FAIL;
665 }
666 return S_OK;
667}
668
669HRESULT vboxVDbgTimerStop(HANDLE hTimerQueue, HANDLE hTimer)
670{
671 if (!DeleteTimerQueueTimer(hTimerQueue, hTimer, NULL))
672 {
673 DWORD winEr = GetLastError();
674 AssertMsg(winEr == ERROR_IO_PENDING, ("DeleteTimerQueueTimer failed, winEr (%d)\n", winEr));
675 }
676 return S_OK;
677}
678#endif
679
680#if defined(VBOXWDDMDISP_DEBUG) || defined(VBOX_WDDMDISP_WITH_PROFILE)
681BOOL vboxVDbgDoCheckExe(const char * pszName)
682{
683 char *pszModule = vboxVDbgDoGetModuleName();
684 if (!pszModule)
685 return FALSE;
686 DWORD cbModule, cbName;
687 cbModule = strlen(pszModule);
688 cbName = strlen(pszName);
689 if (cbName > cbModule)
690 return FALSE;
691 if (_stricmp(pszName, pszModule + (cbModule - cbName)))
692 return FALSE;
693 return TRUE;
694}
695#endif
696
697#ifdef VBOXWDDMDISP_DEBUG_VEHANDLER
698
699static PVOID g_VBoxWDbgVEHandler = NULL;
700LONG WINAPI vboxVDbgVectoredHandler(struct _EXCEPTION_POINTERS *pExceptionInfo)
701{
702 PEXCEPTION_RECORD pExceptionRecord = pExceptionInfo->ExceptionRecord;
703 PCONTEXT pContextRecord = pExceptionInfo->ContextRecord;
704 switch (pExceptionRecord->ExceptionCode)
705 {
706 case EXCEPTION_BREAKPOINT:
707 case EXCEPTION_ACCESS_VIOLATION:
708 case EXCEPTION_STACK_OVERFLOW:
709 case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
710 case EXCEPTION_FLT_DIVIDE_BY_ZERO:
711 case EXCEPTION_FLT_INVALID_OPERATION:
712 case EXCEPTION_INT_DIVIDE_BY_ZERO:
713 case EXCEPTION_ILLEGAL_INSTRUCTION:
714 AssertRelease(0);
715 break;
716 default:
717 break;
718 }
719 return EXCEPTION_CONTINUE_SEARCH;
720}
721
722void vboxVDbgVEHandlerRegister()
723{
724 Assert(!g_VBoxWDbgVEHandler);
725 g_VBoxWDbgVEHandler = AddVectoredExceptionHandler(1,vboxVDbgVectoredHandler);
726 Assert(g_VBoxWDbgVEHandler);
727}
728
729void vboxVDbgVEHandlerUnregister()
730{
731 Assert(g_VBoxWDbgVEHandler);
732 ULONG uResult = RemoveVectoredExceptionHandler(g_VBoxWDbgVEHandler);
733 Assert(uResult);
734 g_VBoxWDbgVEHandler = NULL;
735}
736
737#endif
738
739#if defined(VBOXWDDMDISP_DEBUG) || defined(LOG_TO_BACKDOOR_DRV)
740void vboxDispLogDrvF(char * szString, ...)
741{
742 char szBuffer[4096] = {0};
743 va_list pArgList;
744 va_start(pArgList, szString);
745 vboxDispLogDbgFormatStringV(szBuffer, sizeof (szBuffer), szString, pArgList);
746 va_end(pArgList);
747
748 VBoxDispMpLoggerLog(szBuffer);
749}
750#endif
Note: See TracBrowser for help on using the repository browser.

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