VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/vboxext.c@ 42518

Last change on this file since 42518 was 42499, checked in by vboxsync, 13 years ago

crOgl/wddm: per-context connections
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.9 KB
Line 
1/* $Id: vboxext.c 42499 2012-08-01 10:26:43Z vboxsync $ */
2/** @file
3 *
4 * VBox extension to Wine D3D
5 *
6 * Copyright (C) 2011 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16#include "config.h"
17#include "wine/port.h"
18#include "wined3d_private.h"
19#include "vboxext.h"
20#ifdef VBOX_WITH_WDDM
21#include <VBox/VBoxCrHgsmi.h>
22#include <iprt/err.h>
23#endif
24
25WINE_DEFAULT_DEBUG_CHANNEL(d3d_vbox);
26
27typedef DECLCALLBACK(void) FNVBOXEXTWORKERCB(void *pvUser);
28typedef FNVBOXEXTWORKERCB *PFNVBOXEXTWORKERCB;
29
30HRESULT VBoxExtDwSubmitProcSync(PFNVBOXEXTWORKERCB pfnCb, void *pvCb);
31HRESULT VBoxExtDwSubmitProcAsync(PFNVBOXEXTWORKERCB pfnCb, void *pvCb);
32
33/*******************************/
34#ifdef VBOX_WITH_WDDM
35# if defined(VBOX_WDDM_WOW64)
36# define VBOXEXT_WINE_MODULE_NAME "wined3dwddm-x86.dll"
37# else
38# define VBOXEXT_WINE_MODULE_NAME "wined3dwddm.dll"
39# endif
40#else
41/* both 32bit and 64bit versions of xpdm wine libs are named identically */
42# define VBOXEXT_WINE_MODULE_NAME "wined3d.dll"
43#endif
44
45typedef struct VBOXEXT_WORKER
46{
47 CRITICAL_SECTION CritSect;
48
49 HANDLE hEvent;
50
51 HANDLE hThread;
52 DWORD idThread;
53 /* wine does not seem to guarantie the dll is not unloaded in case FreeLibrary is used
54 * while d3d object is not terminated, keep an extra reference to ensure we're not unloaded
55 * while we are active */
56 HMODULE hSelf;
57} VBOXEXT_WORKER, *PVBOXEXT_WORKER;
58
59
60
61HRESULT VBoxExtWorkerCreate(PVBOXEXT_WORKER pWorker);
62HRESULT VBoxExtWorkerDestroy(PVBOXEXT_WORKER pWorker);
63HRESULT VBoxExtWorkerSubmitProc(PVBOXEXT_WORKER pWorker, PFNVBOXEXTWORKERCB pfnCb, void *pvCb);
64
65
66/*******************************/
67typedef struct VBOXEXT_GLOBAL
68{
69 VBOXEXT_WORKER Worker;
70} VBOXEXT_GLOBAL, *PVBOXEXT_GLOBAL;
71
72static VBOXEXT_GLOBAL g_VBoxExtGlobal;
73
74#define WM_VBOXEXT_CALLPROC (WM_APP+1)
75#define WM_VBOXEXT_INIT_QUIT (WM_APP+2)
76
77typedef struct VBOXEXT_CALLPROC
78{
79 PFNVBOXEXTWORKERCB pfnCb;
80 void *pvCb;
81} VBOXEXT_CALLPROC, *PVBOXEXT_CALLPROC;
82
83static DWORD WINAPI vboxExtWorkerThread(void *pvUser)
84{
85 PVBOXEXT_WORKER pWorker = (PVBOXEXT_WORKER)pvUser;
86 MSG Msg;
87
88 PeekMessage(&Msg,
89 NULL /* HWND hWnd */,
90 WM_USER /* UINT wMsgFilterMin */,
91 WM_USER /* UINT wMsgFilterMax */,
92 PM_NOREMOVE);
93 SetEvent(pWorker->hEvent);
94
95 do
96 {
97 BOOL bResult = GetMessage(&Msg,
98 0 /*HWND hWnd*/,
99 0 /*UINT wMsgFilterMin*/,
100 0 /*UINT wMsgFilterMax*/
101 );
102
103 if(!bResult) /* WM_QUIT was posted */
104 break;
105
106 Assert(bResult != -1);
107 if(bResult == -1) /* error occurred */
108 break;
109
110 switch (Msg.message)
111 {
112 case WM_VBOXEXT_CALLPROC:
113 {
114 VBOXEXT_CALLPROC* pData = (VBOXEXT_CALLPROC*)Msg.lParam;
115 pData->pfnCb(pData->pvCb);
116 SetEvent(pWorker->hEvent);
117 break;
118 }
119 case WM_VBOXEXT_INIT_QUIT:
120 case WM_CLOSE:
121 {
122 PostQuitMessage(0);
123 break;
124 }
125 default:
126 TranslateMessage(&Msg);
127 DispatchMessage(&Msg);
128 }
129 } while (1);
130 return 0;
131}
132
133HRESULT VBoxExtWorkerCreate(PVBOXEXT_WORKER pWorker)
134{
135 if(!GetModuleHandleEx(0, VBOXEXT_WINE_MODULE_NAME, &pWorker->hSelf))
136 {
137 DWORD dwEr = GetLastError();
138 ERR("GetModuleHandleEx failed, %d", dwEr);
139 return E_FAIL;
140 }
141
142 InitializeCriticalSection(&pWorker->CritSect);
143 pWorker->hEvent = CreateEvent(NULL, /* LPSECURITY_ATTRIBUTES lpEventAttributes */
144 FALSE, /* BOOL bManualReset */
145 FALSE, /* BOOL bInitialState */
146 NULL /* LPCTSTR lpName */
147 );
148 if (pWorker->hEvent)
149 {
150 pWorker->hThread = CreateThread(
151 NULL /* LPSECURITY_ATTRIBUTES lpThreadAttributes */,
152 0 /* SIZE_T dwStackSize */,
153 vboxExtWorkerThread,
154 pWorker,
155 0 /* DWORD dwCreationFlags */,
156 &pWorker->idThread);
157 if (pWorker->hThread)
158 {
159 DWORD dwResult = WaitForSingleObject(pWorker->hEvent, INFINITE);
160 if (WAIT_OBJECT_0 == dwResult)
161 return S_OK;
162 ERR("WaitForSingleObject returned %d\n", dwResult);
163 }
164 else
165 {
166 DWORD winErr = GetLastError();
167 ERR("CreateThread failed, winErr = (%d)", winErr);
168 }
169
170 DeleteCriticalSection(&pWorker->CritSect);
171 }
172 else
173 {
174 DWORD winErr = GetLastError();
175 ERR("CreateEvent failed, winErr = (%d)", winErr);
176 }
177
178 FreeLibrary(pWorker->hSelf);
179
180 return E_FAIL;
181}
182
183HRESULT VBoxExtWorkerDestroy(PVBOXEXT_WORKER pWorker)
184{
185 BOOL bResult = PostThreadMessage(pWorker->idThread, WM_VBOXEXT_INIT_QUIT, 0, 0);
186 DWORD dwErr;
187 if (!bResult)
188 {
189 DWORD winErr = GetLastError();
190 ERR("PostThreadMessage failed, winErr = (%d)", winErr);
191 return E_FAIL;
192 }
193
194 dwErr = WaitForSingleObject(pWorker->hThread, INFINITE);
195 if (dwErr != WAIT_OBJECT_0)
196 {
197 ERR("WaitForSingleObject returned (%d)", dwErr);
198 return E_FAIL;
199 }
200
201 CloseHandle(pWorker->hEvent);
202 DeleteCriticalSection(&pWorker->CritSect);
203
204 FreeLibrary(pWorker->hSelf);
205
206 CloseHandle(pWorker->hThread);
207
208 return S_OK;
209}
210
211static HRESULT vboxExtWorkerSubmit(VBOXEXT_WORKER *pWorker, UINT Msg, LPARAM lParam, BOOL fSync)
212{
213 HRESULT hr = E_FAIL;
214 BOOL bResult;
215 /* need to serialize since vboxExtWorkerThread is using one pWorker->hEvent
216 * to signal job completion */
217 EnterCriticalSection(&pWorker->CritSect);
218 bResult = PostThreadMessage(pWorker->idThread, Msg, 0, lParam);
219 if (bResult)
220 {
221 if (fSync)
222 {
223 DWORD dwErr = WaitForSingleObject(pWorker->hEvent, INFINITE);
224 if (dwErr == WAIT_OBJECT_0)
225 {
226 hr = S_OK;
227 }
228 else
229 {
230 ERR("WaitForSingleObject returned (%d)", dwErr);
231 }
232 }
233 else
234 hr = S_OK;
235 }
236 else
237 {
238 DWORD winErr = GetLastError();
239 ERR("PostThreadMessage failed, winErr = (%d)", winErr);
240 return E_FAIL;
241 }
242 LeaveCriticalSection(&pWorker->CritSect);
243 return hr;
244}
245
246HRESULT VBoxExtWorkerSubmitProcSync(PVBOXEXT_WORKER pWorker, PFNVBOXEXTWORKERCB pfnCb, void *pvCb)
247{
248 VBOXEXT_CALLPROC Ctx;
249 Ctx.pfnCb = pfnCb;
250 Ctx.pvCb = pvCb;
251 return vboxExtWorkerSubmit(pWorker, WM_VBOXEXT_CALLPROC, (LPARAM)&Ctx, TRUE);
252}
253
254static DECLCALLBACK(void) vboxExtWorkerSubmitProcAsyncWorker(void *pvUser)
255{
256 PVBOXEXT_CALLPROC pCallInfo = (PVBOXEXT_CALLPROC)pvUser;
257 pCallInfo[1].pfnCb(pCallInfo[1].pvCb);
258 HeapFree(GetProcessHeap(), 0, pCallInfo);
259}
260
261HRESULT VBoxExtWorkerSubmitProcAsync(PVBOXEXT_WORKER pWorker, PFNVBOXEXTWORKERCB pfnCb, void *pvCb)
262{
263 HRESULT hr;
264 PVBOXEXT_CALLPROC pCallInfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof (VBOXEXT_CALLPROC) * 2);
265 if (!pCallInfo)
266 {
267 ERR("HeapAlloc failed\n");
268 return E_OUTOFMEMORY;
269 }
270 pCallInfo[0].pfnCb = vboxExtWorkerSubmitProcAsyncWorker;
271 pCallInfo[0].pvCb = pCallInfo;
272 pCallInfo[1].pfnCb = pfnCb;
273 pCallInfo[1].pvCb = pvCb;
274 hr = vboxExtWorkerSubmit(pWorker, WM_VBOXEXT_CALLPROC, (LPARAM)pCallInfo, FALSE);
275 if (FAILED(hr))
276 {
277 ERR("vboxExtWorkerSubmit failed, hr 0x%x\n", hr);
278 HeapFree(GetProcessHeap(), 0, pCallInfo);
279 return hr;
280 }
281 return S_OK;
282}
283
284
285static HRESULT vboxExtInit()
286{
287 HRESULT hr = S_OK;
288#ifdef VBOX_WITH_WDDM
289 int rc = VBoxCrHgsmiInit();
290 if (!RT_SUCCESS(rc))
291 {
292 ERR("VBoxCrHgsmiInit failed rc %d", rc);
293 return E_FAIL;
294 }
295#endif
296 memset(&g_VBoxExtGlobal, 0, sizeof (g_VBoxExtGlobal));
297 hr = VBoxExtWorkerCreate(&g_VBoxExtGlobal.Worker);
298 if (SUCCEEDED(hr))
299 return S_OK;
300
301 /* failure branch */
302#ifdef VBOX_WITH_WDDM
303 VBoxCrHgsmiTerm();
304#endif
305 return hr;
306}
307
308
309static HRESULT vboxExtWndCleanup();
310
311static HRESULT vboxExtTerm()
312{
313 HRESULT hr = vboxExtWndCleanup();
314 if (!SUCCEEDED(hr))
315 {
316 ERR("vboxExtWndCleanup failed, hr %d", hr);
317 return hr;
318 }
319
320 hr = VBoxExtWorkerDestroy(&g_VBoxExtGlobal.Worker);
321 if (!SUCCEEDED(hr))
322 {
323 ERR("VBoxExtWorkerDestroy failed, hr %d", hr);
324 return hr;
325 }
326
327#ifdef VBOX_WITH_WDDM
328 VBoxCrHgsmiTerm();
329#endif
330
331 return S_OK;
332}
333
334/* wine serializes all calls to us, so no need for any synchronization here */
335static DWORD g_cVBoxExtInits = 0;
336
337static DWORD vboxExtAddRef()
338{
339 return ++g_cVBoxExtInits;
340}
341
342static DWORD vboxExtRelease()
343{
344 DWORD cVBoxExtInits = --g_cVBoxExtInits;
345 Assert(cVBoxExtInits < UINT32_MAX/2);
346 return cVBoxExtInits;
347}
348
349static DWORD vboxExtGetRef()
350{
351 return g_cVBoxExtInits;
352}
353
354HRESULT VBoxExtCheckInit()
355{
356 HRESULT hr = S_OK;
357 if (!vboxExtGetRef())
358 {
359 hr = vboxExtInit();
360 if (FAILED(hr))
361 {
362 ERR("vboxExtInit failed, hr (0x%x)", hr);
363 return hr;
364 }
365 }
366 vboxExtAddRef();
367 return S_OK;
368}
369
370HRESULT VBoxExtCheckTerm()
371{
372 HRESULT hr = S_OK;
373 if (vboxExtGetRef() == 1)
374 {
375 hr = vboxExtTerm();
376 if (FAILED(hr))
377 {
378 ERR("vboxExtTerm failed, hr (0x%x)", hr);
379 return hr;
380 }
381 }
382 vboxExtRelease();
383 return S_OK;
384}
385
386HRESULT VBoxExtDwSubmitProcSync(PFNVBOXEXTWORKERCB pfnCb, void *pvCb)
387{
388 return VBoxExtWorkerSubmitProcSync(&g_VBoxExtGlobal.Worker, pfnCb, pvCb);
389}
390
391HRESULT VBoxExtDwSubmitProcAsync(PFNVBOXEXTWORKERCB pfnCb, void *pvCb)
392{
393 return VBoxExtWorkerSubmitProcAsync(&g_VBoxExtGlobal.Worker, pfnCb, pvCb);
394}
395
396#if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
397# ifndef VBOX_WITH_WDDM
398typedef struct VBOXEXT_GETDC_CB
399{
400 HWND hWnd;
401 HDC hDC;
402} VBOXEXT_GETDC_CB, *PVBOXEXT_GETDC_CB;
403
404static DECLCALLBACK(void) vboxExtGetDCWorker(void *pvUser)
405{
406 PVBOXEXT_GETDC_CB pData = (PVBOXEXT_GETDC_CB)pvUser;
407 pData->hDC = GetDC(pData->hWnd);
408}
409
410typedef struct VBOXEXT_RELEASEDC_CB
411{
412 HWND hWnd;
413 HDC hDC;
414 int ret;
415} VBOXEXT_RELEASEDC_CB, *PVBOXEXT_RELEASEDC_CB;
416
417static DECLCALLBACK(void) vboxExtReleaseDCWorker(void *pvUser)
418{
419 PVBOXEXT_RELEASEDC_CB pData = (PVBOXEXT_RELEASEDC_CB)pvUser;
420 pData->ret = ReleaseDC(pData->hWnd, pData->hDC);
421}
422
423HDC VBoxExtGetDC(HWND hWnd)
424{
425 HRESULT hr;
426 VBOXEXT_GETDC_CB Data = {0};
427 Data.hWnd = hWnd;
428 Data.hDC = NULL;
429
430 hr = VBoxExtDwSubmitProcSync(vboxExtGetDCWorker, &Data);
431 if (FAILED(hr))
432 {
433 ERR("VBoxExtDwSubmitProcSync feiled, hr (0x%x)\n", hr);
434 return NULL;
435 }
436
437 return Data.hDC;
438}
439
440int VBoxExtReleaseDC(HWND hWnd, HDC hDC)
441{
442 HRESULT hr;
443 VBOXEXT_RELEASEDC_CB Data = {0};
444 Data.hWnd = hWnd;
445 Data.hDC = hDC;
446 Data.ret = 0;
447
448 hr = VBoxExtDwSubmitProcSync(vboxExtReleaseDCWorker, &Data);
449 if (FAILED(hr))
450 {
451 ERR("VBoxExtDwSubmitProcSync feiled, hr (0x%x)\n", hr);
452 return -1;
453 }
454
455 return Data.ret;
456}
457# endif /* #ifndef VBOX_WITH_WDDM */
458
459static DECLCALLBACK(void) vboxExtReleaseContextWorker(void *pvUser)
460{
461 struct wined3d_context *context = (struct wined3d_context *)pvUser;
462 wined3d_mutex_lock();
463 VBoxTlsRefRelease(context);
464 wined3d_mutex_unlock();
465}
466
467void VBoxExtReleaseContextAsync(struct wined3d_context *context)
468{
469 HRESULT hr;
470
471 hr = VBoxExtDwSubmitProcAsync(vboxExtReleaseContextWorker, context);
472 if (FAILED(hr))
473 {
474 ERR("VBoxExtDwSubmitProcAsync feiled, hr (0x%x)\n", hr);
475 return;
476 }
477}
478
479#endif /* #if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT) */
480
481/* window creation API */
482static LRESULT CALLBACK vboxExtWndProc(HWND hwnd,
483 UINT uMsg,
484 WPARAM wParam,
485 LPARAM lParam
486)
487{
488 switch(uMsg)
489 {
490 case WM_CLOSE:
491 TRACE("got WM_CLOSE for hwnd(0x%x)", hwnd);
492 return 0;
493 case WM_DESTROY:
494 TRACE("got WM_DESTROY for hwnd(0x%x)", hwnd);
495 return 0;
496 case WM_NCHITTEST:
497 TRACE("got WM_NCHITTEST for hwnd(0x%x)\n", hwnd);
498 return HTNOWHERE;
499 }
500
501 return DefWindowProc(hwnd, uMsg, wParam, lParam);
502}
503
504#define VBOXEXTWND_NAME "VboxDispD3DWineWnd"
505
506static HRESULT vboxExtWndDoCleanup()
507{
508 HRESULT hr = S_OK;
509 HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
510 WNDCLASS wc;
511 if (GetClassInfo(hInstance, VBOXEXTWND_NAME, &wc))
512 {
513 if (!UnregisterClass(VBOXEXTWND_NAME, hInstance))
514 {
515 DWORD winEr = GetLastError();
516 ERR("UnregisterClass failed, winErr(%d)\n", winEr);
517 hr = E_FAIL;
518 }
519 }
520 return hr;
521}
522
523static HRESULT vboxExtWndDoCreate(DWORD w, DWORD h, HWND *phWnd, HDC *phDC)
524{
525 HRESULT hr = S_OK;
526 HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
527 /* Register the Window Class. */
528 WNDCLASS wc;
529 if (!GetClassInfo(hInstance, VBOXEXTWND_NAME, &wc))
530 {
531 wc.style = 0;//CS_OWNDC;
532 wc.lpfnWndProc = vboxExtWndProc;
533 wc.cbClsExtra = 0;
534 wc.cbWndExtra = 0;
535 wc.hInstance = hInstance;
536 wc.hIcon = NULL;
537 wc.hCursor = NULL;
538 wc.hbrBackground = NULL;
539 wc.lpszMenuName = NULL;
540 wc.lpszClassName = VBOXEXTWND_NAME;
541 if (!RegisterClass(&wc))
542 {
543 DWORD winErr = GetLastError();
544 ERR("RegisterClass failed, winErr(%d)\n", winErr);
545 hr = E_FAIL;
546 }
547 }
548
549 if (hr == S_OK)
550 {
551 HWND hWnd = CreateWindowEx (WS_EX_TOOLWINDOW,
552 VBOXEXTWND_NAME, VBOXEXTWND_NAME,
553 WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_DISABLED,
554 0, 0,
555 w, h,
556 NULL, //GetDesktopWindow() /* hWndParent */,
557 NULL /* hMenu */,
558 hInstance,
559 NULL /* lpParam */);
560 Assert(hWnd);
561 if (hWnd)
562 {
563 *phWnd = hWnd;
564 *phDC = GetDC(hWnd);
565 /* make sure we keep inited until the window is active */
566 vboxExtAddRef();
567 }
568 else
569 {
570 DWORD winErr = GetLastError();
571 ERR("CreateWindowEx failed, winErr(%d)\n", winErr);
572 hr = E_FAIL;
573 }
574 }
575
576 return hr;
577}
578
579static HRESULT vboxExtWndDoDestroy(HWND hWnd, HDC hDC)
580{
581 BOOL bResult;
582 DWORD winErr;
583 ReleaseDC(hWnd, hDC);
584 bResult = DestroyWindow(hWnd);
585 Assert(bResult);
586 if (bResult)
587 {
588 /* release the reference we previously acquired on window creation */
589 vboxExtRelease();
590 return S_OK;
591 }
592
593 winErr = GetLastError();
594 ERR("DestroyWindow failed, winErr(%d) for hWnd(0x%x)\n", winErr, hWnd);
595
596 return E_FAIL;
597}
598
599typedef struct VBOXEXTWND_CREATE_INFO
600{
601 int hr;
602 HWND hWnd;
603 HDC hDC;
604 DWORD width;
605 DWORD height;
606} VBOXEXTWND_CREATE_INFO;
607
608typedef struct VBOXEXTWND_DESTROY_INFO
609{
610 int hr;
611 HWND hWnd;
612 HDC hDC;
613} VBOXEXTWND_DESTROY_INFO;
614
615typedef struct VBOXEXTWND_CLEANUP_INFO
616{
617 int hr;
618} VBOXEXTWND_CLEANUP_INFO;
619
620static DECLCALLBACK(void) vboxExtWndDestroyWorker(void *pvUser)
621{
622 VBOXEXTWND_DESTROY_INFO *pInfo = (VBOXEXTWND_DESTROY_INFO*)pvUser;
623 pInfo->hr = vboxExtWndDoDestroy(pInfo->hWnd, pInfo->hDC);
624 Assert(pInfo->hr == S_OK);
625}
626
627static DECLCALLBACK(void) vboxExtWndCreateWorker(void *pvUser)
628{
629 VBOXEXTWND_CREATE_INFO *pInfo = (VBOXEXTWND_CREATE_INFO*)pvUser;
630 pInfo->hr = vboxExtWndDoCreate(pInfo->width, pInfo->height, &pInfo->hWnd, &pInfo->hDC);
631 Assert(pInfo->hr == S_OK);
632}
633
634static DECLCALLBACK(void) vboxExtWndCleanupWorker(void *pvUser)
635{
636 VBOXEXTWND_CLEANUP_INFO *pInfo = (VBOXEXTWND_CLEANUP_INFO*)pvUser;
637 pInfo-> hr = vboxExtWndDoCleanup();
638}
639
640HRESULT VBoxExtWndDestroy(HWND hWnd, HDC hDC)
641{
642 HRESULT hr;
643 VBOXEXTWND_DESTROY_INFO Info;
644 Info.hr = E_FAIL;
645 Info.hWnd = hWnd;
646 Info.hDC = hDC;
647 hr = VBoxExtDwSubmitProcSync(vboxExtWndDestroyWorker, &Info);
648 if (!SUCCEEDED(hr))
649 {
650 ERR("VBoxExtDwSubmitProcSync-vboxExtWndDestroyWorker failed hr %d", hr);
651 return hr;
652 }
653
654 if (!SUCCEEDED(Info.hr))
655 {
656 ERR("vboxExtWndDestroyWorker failed hr %d", Info.hr);
657 return Info.hr;
658 }
659
660 return S_OK;
661}
662
663HRESULT VBoxExtWndCreate(DWORD width, DWORD height, HWND *phWnd, HDC *phDC)
664{
665 HRESULT hr;
666 VBOXEXTWND_CREATE_INFO Info;
667 Info.hr = E_FAIL;
668 Info.width = width;
669 Info.height = height;
670 hr = VBoxExtDwSubmitProcSync(vboxExtWndCreateWorker, &Info);
671 if (!SUCCEEDED(hr))
672 {
673 ERR("VBoxExtDwSubmitProcSync-vboxExtWndCreateWorker failed hr %d", hr);
674 return hr;
675 }
676
677 Assert(Info.hr == S_OK);
678 if (!SUCCEEDED(Info.hr))
679 {
680 ERR("vboxExtWndCreateWorker failed hr %d", Info.hr);
681 return Info.hr;
682 }
683
684 *phWnd = Info.hWnd;
685 *phDC = Info.hDC;
686 return S_OK;
687}
688
689static HRESULT vboxExtWndCleanup()
690{
691 HRESULT hr;
692 VBOXEXTWND_CLEANUP_INFO Info;
693 Info.hr = E_FAIL;
694 hr = VBoxExtDwSubmitProcSync(vboxExtWndCleanupWorker, &Info);
695 if (!SUCCEEDED(hr))
696 {
697 ERR("VBoxExtDwSubmitProcSync-vboxExtWndCleanupWorker failed hr %d", hr);
698 return hr;
699 }
700
701 if (!SUCCEEDED(Info.hr))
702 {
703 ERR("vboxExtWndCleanupWorker failed hr %d", Info.hr);
704 return Info.hr;
705 }
706
707 return S_OK;
708}
709
710
711/* hash map impl */
712static void vboxExtHashInitEntries(PVBOXEXT_HASHMAP pMap)
713{
714 uint32_t i;
715 pMap->cEntries = 0;
716 for (i = 0; i < RT_ELEMENTS(pMap->aBuckets); ++i)
717 {
718 RTListInit(&pMap->aBuckets[i].EntryList);
719 }
720}
721
722void VBoxExtHashInit(PVBOXEXT_HASHMAP pMap, PFNVBOXEXT_HASHMAP_HASH pfnHash, PFNVBOXEXT_HASHMAP_EQUAL pfnEqual)
723{
724 pMap->pfnHash = pfnHash;
725 pMap->pfnEqual = pfnEqual;
726 vboxExtHashInitEntries(pMap);
727}
728
729static DECLINLINE(uint32_t) vboxExtHashIdx(uint32_t u32Hash)
730{
731 return u32Hash % VBOXEXT_HASHMAP_NUM_BUCKETS;
732}
733
734#define VBOXEXT_FOREACH_NODE(_pNode, _pList, _op) do { \
735 PRTLISTNODE _pNode; \
736 PRTLISTNODE __pNext; \
737 for (_pNode = (_pList)->pNext; \
738 _pNode != (_pList); \
739 _pNode = __pNext) \
740 { \
741 __pNext = _pNode->pNext; /* <- the _pNode should not be referenced after the _op */ \
742 _op \
743 } \
744 } while (0)
745
746DECLINLINE(PVBOXEXT_HASHMAP_ENTRY) vboxExtHashSearchEntry(PVBOXEXT_HASHMAP pMap, void *pvKey)
747{
748 uint32_t u32Hash = pMap->pfnHash(pvKey);
749 uint32_t u32HashIdx = vboxExtHashIdx(u32Hash);
750 PVBOXEXT_HASHMAP_BUCKET pBucket = &pMap->aBuckets[u32HashIdx];
751 PVBOXEXT_HASHMAP_ENTRY pEntry;
752 VBOXEXT_FOREACH_NODE(pNode, &pBucket->EntryList,
753 pEntry = RT_FROM_MEMBER(pNode, VBOXEXT_HASHMAP_ENTRY, ListNode);
754 if (pEntry->u32Hash != u32Hash)
755 continue;
756
757 if (!pMap->pfnEqual(pvKey, pEntry->pvKey))
758 continue;
759 return pEntry;
760 );
761 return NULL;
762}
763
764void* VBoxExtHashRemoveEntry(PVBOXEXT_HASHMAP pMap, PVBOXEXT_HASHMAP_ENTRY pEntry)
765{
766 RTListNodeRemove(&pEntry->ListNode);
767 --pMap->cEntries;
768 Assert(pMap->cEntries <= UINT32_MAX/2);
769 return pEntry->pvKey;
770}
771
772static void vboxExtHashPutEntry(PVBOXEXT_HASHMAP pMap, PVBOXEXT_HASHMAP_BUCKET pBucket, PVBOXEXT_HASHMAP_ENTRY pEntry)
773{
774 RTListNodeInsertAfter(&pBucket->EntryList, &pEntry->ListNode);
775 ++pMap->cEntries;
776}
777
778PVBOXEXT_HASHMAP_ENTRY VBoxExtHashRemove(PVBOXEXT_HASHMAP pMap, void *pvKey)
779{
780 PVBOXEXT_HASHMAP_ENTRY pEntry = vboxExtHashSearchEntry(pMap, pvKey);
781 if (!pEntry)
782 return NULL;
783
784 VBoxExtHashRemoveEntry(pMap, pEntry);
785 return pEntry;
786}
787
788PVBOXEXT_HASHMAP_ENTRY VBoxExtHashPut(PVBOXEXT_HASHMAP pMap, void *pvKey, PVBOXEXT_HASHMAP_ENTRY pEntry)
789{
790 PVBOXEXT_HASHMAP_ENTRY pOldEntry = VBoxExtHashRemove(pMap, pvKey);
791 uint32_t u32Hash = pMap->pfnHash(pvKey);
792 uint32_t u32HashIdx = vboxExtHashIdx(u32Hash);
793 pEntry->pvKey = pvKey;
794 pEntry->u32Hash = u32Hash;
795 vboxExtHashPutEntry(pMap, &pMap->aBuckets[u32HashIdx], pEntry);
796 return pOldEntry;
797}
798
799
800PVBOXEXT_HASHMAP_ENTRY VBoxExtHashGet(PVBOXEXT_HASHMAP pMap, void *pvKey)
801{
802 return vboxExtHashSearchEntry(pMap, pvKey);
803}
804
805void VBoxExtHashVisit(PVBOXEXT_HASHMAP pMap, PFNVBOXEXT_HASHMAP_VISITOR pfnVisitor, void *pvVisitor)
806{
807 uint32_t iBucket = 0, iEntry = 0;
808 uint32_t cEntries = pMap->cEntries;
809
810 if (!cEntries)
811 return;
812
813 for (; ; ++iBucket)
814 {
815 PVBOXEXT_HASHMAP_ENTRY pEntry;
816 PVBOXEXT_HASHMAP_BUCKET pBucket = &pMap->aBuckets[iBucket];
817 Assert(iBucket < RT_ELEMENTS(pMap->aBuckets));
818 VBOXEXT_FOREACH_NODE(pNode, &pBucket->EntryList,
819 pEntry = RT_FROM_MEMBER(pNode, VBOXEXT_HASHMAP_ENTRY, ListNode);
820 if (!pfnVisitor(pMap, pEntry->pvKey, pEntry, pvVisitor))
821 return;
822
823 if (++iEntry == cEntries)
824 return;
825 );
826 }
827
828 /* should not be here! */
829 AssertFailed();
830}
831
832void VBoxExtHashCleanup(PVBOXEXT_HASHMAP pMap, PFNVBOXEXT_HASHMAP_VISITOR pfnVisitor, void *pvVisitor)
833{
834 VBoxExtHashVisit(pMap, pfnVisitor, pvVisitor);
835 vboxExtHashInitEntries(pMap);
836}
837
838static DECLCALLBACK(bool) vboxExtCacheCleanupCb(struct VBOXEXT_HASHMAP *pMap, void *pvKey, struct VBOXEXT_HASHMAP_ENTRY *pValue, void *pvVisitor)
839{
840 PVBOXEXT_HASHCACHE pCache = VBOXEXT_HASHCACHE_FROM_MAP(pMap);
841 PVBOXEXT_HASHCACHE_ENTRY pCacheEntry = VBOXEXT_HASHCACHE_ENTRY_FROM_MAP(pValue);
842 pCache->pfnCleanupEntry(pvKey, pCacheEntry);
843 return TRUE;
844}
845
846void VBoxExtCacheCleanup(PVBOXEXT_HASHCACHE pCache)
847{
848 VBoxExtHashCleanup(&pCache->Map, vboxExtCacheCleanupCb, NULL);
849}
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