VirtualBox

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

Last change on this file since 62679 was 62679, checked in by vboxsync, 9 years ago

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