Changeset 38982 in vbox for trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm

Timestamp:

Oct 12, 2011 8:20:21 PM (14 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

74369

Message:

wddm: proper ie rendering under win8 (shared resource open & destroy fixes, zero-init resources on creaate, etc.)

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video/mp/wddm

Files:

• VBoxMPMisc.cpp (modified) (1 diff)
• VBoxMPMisc.h (modified) (1 diff)
• VBoxMPTypes.h (modified) (6 diffs)
• VBoxMPVdma.h (modified) (1 diff)
• VBoxMPWddm.cpp (modified) (18 diffs)

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

@@ -1473 +1473 @@
     }
 }
+
+#if 0
+VOID vboxShRcTreeInit(PVBOXMP_DEVEXT pDevExt)
+{
+    ExInitializeFastMutex(&pDevExt->ShRcTreeMutex);
+    pDevExt->ShRcTree = NULL;
+}
+
+VOID vboxShRcTreeTerm(PVBOXMP_DEVEXT pDevExt)
+{
+    Assert(!pDevExt->ShRcTree);
+    pDevExt->ShRcTree = NULL;
+}
+
+BOOLEAN vboxShRcTreePut(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc)
+{
+    HANDLE hSharedRc = pAlloc->hSharedHandle;
+    if (!hSharedRc)
+    {
+        WARN(("invalid call with zero shared handle!"));
+        return FALSE;
+    }
+    pAlloc->ShRcTreeEntry.Key = (AVLPVKEY)hSharedRc;
+    ExAcquireFastMutex(&pDevExt->ShRcTreeMutex);
+    bool bRc = RTAvlPVInsert(&pDevExt->ShRcTree, &pAlloc->ShRcTreeEntry);
+    ExReleaseFastMutex(&pDevExt->ShRcTreeMutex);
+    Assert(bRc);
+    return (BOOLEAN)bRc;
+}
+
+#define PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(_p) ((PVBOXWDDM_ALLOCATION)(((uint8_t*)(_p)) - RT_OFFSETOF(VBOXWDDM_ALLOCATION, ShRcTreeEntry)))
+PVBOXWDDM_ALLOCATION vboxShRcTreeGet(PVBOXMP_DEVEXT pDevExt, HANDLE hSharedRc)
+{
+    ExAcquireFastMutex(&pDevExt->ShRcTreeMutex);
+    PAVLPVNODECORE pNode = RTAvlPVGet(&pDevExt->ShRcTree, (AVLPVKEY)hSharedRc);
+    ExReleaseFastMutex(&pDevExt->ShRcTreeMutex);
+    if (!pNode)
+        return NULL;
+    PVBOXWDDM_ALLOCATION pAlloc = PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(pNode);
+    return pAlloc;
+}
+
+BOOLEAN vboxShRcTreeRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc)
+{
+    HANDLE hSharedRc = pAlloc->hSharedHandle;
+    if (!hSharedRc)
+    {
+        WARN(("invalid call with zero shared handle!"));
+        return FALSE;
+    }
+    ExAcquireFastMutex(&pDevExt->ShRcTreeMutex);
+    PAVLPVNODECORE pNode = RTAvlPVRemove(&pDevExt->ShRcTree, (AVLPVKEY)hSharedRc);
+    ExReleaseFastMutex(&pDevExt->ShRcTreeMutex);
+    if (!pNode)
+        return NULL;
+    PVBOXWDDM_ALLOCATION pRetAlloc = PVBOXWDDM_ALLOCATION_FROM_SHRCTREENODE(pNode);
+    Assert(pRetAlloc == pAlloc);
+    return !!pRetAlloc;
+}
+#endif

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

@@ -151 +151 @@
 VOID vboxWddmCounterU32Wait(uint32_t volatile * pu32, uint32_t u32Val);
 
+#if 0
+/* wine shrc handle -> allocation map */
+VOID vboxShRcTreeInit(PVBOXMP_DEVEXT pDevExt);
+VOID vboxShRcTreeTerm(PVBOXMP_DEVEXT pDevExt);
+BOOLEAN vboxShRcTreePut(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc);
+PVBOXWDDM_ALLOCATION vboxShRcTreeGet(PVBOXMP_DEVEXT pDevExt, HANDLE hSharedRc);
+BOOLEAN vboxShRcTreeRemove(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_ALLOCATION pAlloc);
+#endif
+
 #endif /* #ifndef ___VBoxMPMisc_h__ */

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

@@ -32 +32 @@
 #include "VBoxMPVbva.h"
 
+#if 0
+#include <iprt/avl.h>
+#endif
+
 /* one page size */
 #define VBOXWDDM_C_DMA_BUFFER_SIZE         0x1000
@@ -118 +122 @@
     VBOXWDDM_ALLOC_TYPE enmType;
     volatile uint32_t cRefs;
-//    VBOXWDDM_ALLOCUSAGE_TYPE enmCurrentUsage;
     D3DDDI_RESOURCEFLAGS fRcFlags;
     UINT SegmentId;
@@ -128 +131 @@
     BOOLEAN bVisible;
     BOOLEAN bAssigned;
+#ifdef DEBUG
+    /* current for shared rc handling assumes that once resource has no opens, it can not be openned agaion */
+    BOOLEAN fAssumedDeletion;
+#endif
     VBOXWDDM_SURFACE_DESC SurfDesc;
     struct VBOXWDDM_RESOURCE *pResource;
@@ -133 +140 @@
     DXGK_ALLOCATIONUSAGEHINT UsageHint;
     uint32_t iIndex;
+    uint32_t cOpens;
+    LIST_ENTRY OpenList;
+    /* helps tracking when to release wine shared resource */
+    uint32_t cShRcRefs;
+    HANDLE hSharedHandle;
+#if 0
+    AVLPVNODECORE ShRcTreeEntry;
+#endif
     VBOXUHGSMI_SYNCHOBJECT_TYPE enmSynchType;
     union
@@ -143 +158 @@
 typedef struct VBOXWDDM_RESOURCE
 {
-    uint32_t fFlags;
+    VBOXWDDMDISP_RESOURCE_FLAGS fFlags;
     volatile uint32_t cRefs;
     VBOXWDDM_RC_DESC RcDesc;
@@ -251 +266 @@
 } VBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD, *PVBOXWDDM_DMA_PRIVATEDATA_CHROMIUM_CMD;
 
+typedef struct VBOXWDDM_DMA_PRIVATEDATA_ALLOCINFO_ON_SUBMIT
+{
+    VBOXWDDM_DMA_PRIVATEDATA_BASEHDR Base;
+    VBOXWDDM_DMA_ALLOCINFO aInfos[1];
+} VBOXWDDM_DMA_PRIVATEDATA_ALLOCINFO_ON_SUBMIT, *PVBOXWDDM_DMA_PRIVATEDATA_ALLOCINFO_ON_SUBMIT;
+
 typedef struct VBOXWDDM_OPENALLOCATION
 {
+    LIST_ENTRY ListEntry;
     D3DKMT_HANDLE  hAllocation;
+    PVBOXWDDM_ALLOCATION pAllocation;
+    PVBOXWDDM_DEVICE pDevice;
+    uint32_t cShRcRefs;
 } VBOXWDDM_OPENALLOCATION, *PVBOXWDDM_OPENALLOCATION;
 

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

@@ -178 +178 @@
     PVBOXWDDM_ALLOCATION pAlloc;
     VBOXVIDEOOFFSET offAlloc;
-    UINT segmentIdAlloc;
+    UINT segmentIdAlloc : 31;
+    UINT fWriteOp : 1;
     D3DDDI_VIDEO_PRESENT_SOURCE_ID srcId;
 } VBOXWDDM_DMA_ALLOCINFO, *PVBOXWDDM_DMA_ALLOCINFO;

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

@@ -51 +51 @@
 }
 
-DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromOpenData(PVBOXMP_DEVEXT pDevExt, PVBOXWDDM_OPENALLOCATION pOa)
+DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromHandle(PVBOXMP_DEVEXT pDevExt, D3DKMT_HANDLE hAllocation)
 {
     DXGKARGCB_GETHANDLEDATA GhData;
-    GhData.hObject = pOa->hAllocation;
+    GhData.hObject = hAllocation;
     GhData.Type = DXGK_HANDLE_ALLOCATION;
     GhData.Flags.Value = 0;
@@ -62 +62 @@
 DECLINLINE(PVBOXWDDM_ALLOCATION) vboxWddmGetAllocationFromAllocList(PVBOXMP_DEVEXT pDevExt, DXGK_ALLOCATIONLIST *pAllocList)
 {
-    return vboxWddmGetAllocationFromOpenData(pDevExt, (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation);
+    PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)pAllocList->hDeviceSpecificAllocation;
+    return pOa->pAllocation;
 }
 
@@ -955 +956 @@
                     VBoxMPCmnInitCustomVideoModes(pContext);
                     VBoxWddmInvalidateVideoModesInfo(pContext);
+#if 0
+                    vboxShRcTreeInit(pContext);
+#endif
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -1010 +1014 @@
 #ifdef VBOX_WITH_VIDEOHWACCEL
     vboxVhwaFree(pDevExt);
+#endif
+#if 0
+    vboxShRcTreeTerm(pDevExt);
 #endif
 
@@ -1794 +1801 @@
                 vboxWddmAssignPrimary(pDevExt, &pDevExt->aSources[pAllocation->SurfDesc.VidPnSourceId], NULL, pAllocation->SurfDesc.VidPnSourceId);
             }
+
+#if 0
+            if (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC)
+            {
+                if (pAllocation->hSharedHandle)
+                {
+                    vboxShRcTreeRemove(pDevExt, pAllocation);
+                }
+            }
+#endif
             break;
         }
@@ -1903 +1920 @@
             pAllocation->bVisible = FALSE;
             pAllocation->bAssigned = FALSE;
+            InitializeListHead(&pAllocation->OpenList);
 
             switch (pAllocInfo->enmType)
@@ -1957 +1975 @@
                                 {
                                     pAllocationInfo->Flags.CpuVisible = 1;
+                                }
+                                else
+                                {
+                                    pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle;
+#if 0
+                                    if (pAllocation->hSharedHandle)
+                                    {
+                                        vboxShRcTreePut(pDevExt, pAllocation);
+                                    }
+#endif
                                 }
                             }
@@ -3212 +3240 @@
         case DXGK_OPERATION_FILL:
         {
+            Assert(pBuildPagingBuffer->Fill.FillPattern == 0);
+            PVBOXWDDM_ALLOCATION pAlloc = (PVBOXWDDM_ALLOCATION)pBuildPagingBuffer->Fill.hAllocation;
 //            pBuildPagingBuffer->pDmaBuffer = (uint8_t*)pBuildPagingBuffer->pDmaBuffer + VBOXVDMACMD_SIZE(VBOXVDMACMD_DMA_BPB_FILL);
             break;
@@ -3556 +3586 @@
             case VBOXESC_UHGSMI_SUBMIT:
             {
+                /* submit UHGSMI command */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_UHGSMI_SUBMIT pSubmit = (PVBOXDISPIFESCAPE_UHGSMI_SUBMIT)pEscapeHdr;
@@ -3574 +3605 @@
             case VBOXESC_UHGSMI_ALLOCATE:
             {
+                /* allocate UHGSMI buffer */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE pAlocate = (PVBOXDISPIFESCAPE_UHGSMI_ALLOCATE)pEscapeHdr;
@@ -3589 +3621 @@
             case VBOXESC_UHGSMI_DEALLOCATE:
             {
+                /* deallocate UHGSMI buffer */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE pDealocate = (PVBOXDISPIFESCAPE_UHGSMI_DEALLOCATE)pEscapeHdr;
@@ -3604 +3637 @@
             case VBOXESC_GETVBOXVIDEOCMCMD:
             {
+                /* get the list of r0->r3 commands (d3d window visible regions reporting )*/
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD pRegions = (PVBOXDISPIFESCAPE_GETVBOXVIDEOCMCMD)pEscapeHdr;
@@ -3619 +3653 @@
             case VBOXESC_SETVISIBLEREGION:
             {
+                /* visible regions for seamless */
                 LPRGNDATA lpRgnData = VBOXDISPIFESCAPE_DATA(pEscapeHdr, RGNDATA);
                 uint32_t cbData = VBOXDISPIFESCAPE_DATA_SIZE(pEscape->PrivateDriverDataSize);
@@ -3682 +3717 @@
             case VBOXESC_SCREENLAYOUT:
             {
+                /* set screen layout (unused currently) */
                 Assert(pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT));
                 if (pEscape->PrivateDriverDataSize >= sizeof (VBOXDISPIFESCAPE_SCREENLAYOUT))
@@ -3711 +3747 @@
             case VBOXESC_SWAPCHAININFO:
             {
+                /* set swapchain information */
                 PVBOXWDDM_CONTEXT pContext = (PVBOXWDDM_CONTEXT)pEscape->hContext;
                 Status = vboxWddmSwapchainCtxEscape(pDevExt, pContext, (PVBOXDISPIFESCAPE_SWAPCHAININFO)pEscapeHdr, pEscape->PrivateDriverDataSize);
@@ -3717 +3754 @@
             }
             case VBOXESC_REINITVIDEOMODES:
+            {
+                /* clear driver's internal videomodes cache */
                 VBoxWddmInvalidateVideoModesInfo(pDevExt);
                 Status = STATUS_SUCCESS;
                 break;
+            }
+            case VBOXESC_SHRC_ADDREF:
+            case VBOXESC_SHRC_RELEASE:
+            {
+                PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)pEscape->hDevice;
+                /* query whether the allocation represanted by the given [wine-generated] shared resource handle still exists */
+                if (pEscape->PrivateDriverDataSize != sizeof (VBOXDISPIFESCAPE_SHRC_REF))
+                {
+                    WARN(("invalid buffer size for VBOXDISPIFESCAPE_SHRC_REF, was(%d), but expected (%d)",
+                            pEscape->PrivateDriverDataSize, sizeof (VBOXDISPIFESCAPE_SHRC_REF)));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                PVBOXDISPIFESCAPE_SHRC_REF pShRcRef = (PVBOXDISPIFESCAPE_SHRC_REF)pEscapeHdr;
+                PVBOXWDDM_ALLOCATION pAlloc = vboxWddmGetAllocationFromHandle(pDevExt, (D3DKMT_HANDLE)pShRcRef->hAlloc);
+                if (!pAlloc)
+                {
+                    WARN(("failed to get allocation from handle"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                PVBOXWDDM_OPENALLOCATION pOa = NULL;
+                for (PLIST_ENTRY pCur = pAlloc->OpenList.Flink; pCur != &pAlloc->OpenList; pCur = pCur->Flink)
+                {
+                    PVBOXWDDM_OPENALLOCATION pCurOa = CONTAINING_RECORD(pCur, VBOXWDDM_OPENALLOCATION, ListEntry);
+                    if (pCurOa->pDevice == pDevice)
+                    {
+                        pOa = pCurOa;
+                        break;
+                    }
+                }
+
+                if (!pOa)
+                {
+                    WARN(("failed to get open allocation from alloc"));
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+
+                Assert(pAlloc->cShRcRefs >= pOa->cShRcRefs);
+
+                if (pEscapeHdr->escapeCode == VBOXESC_SHRC_ADDREF)
+                {
+#ifdef DEBUG
+                    Assert(!pAlloc->fAssumedDeletion);
+#endif
+                    ++pAlloc->cShRcRefs;
+                    ++pOa->cShRcRefs;
+                }
+                else
+                {
+                    Assert(pAlloc->cShRcRefs);
+                    Assert(pOa->cShRcRefs);
+                    --pAlloc->cShRcRefs;
+                    --pOa->cShRcRefs;
+#ifdef DEBUG
+                    Assert(!pAlloc->fAssumedDeletion);
+                    if (!pAlloc->cShRcRefs)
+                    {
+                        pAlloc->fAssumedDeletion = TRUE;
+                    }
+#endif
+                }
+
+                pShRcRef->EscapeHdr.u32CmdSpecific = pAlloc->cShRcRefs;
+                Status = STATUS_SUCCESS;
+                break;
+            }
             case VBOXESC_DBGPRINT:
             {
@@ -4580 +4689 @@
     if (Status == STATUS_SUCCESS)
     {
-        for (UINT i = 0; i < pOpenAllocation->NumAllocations; ++i)
+        UINT i = 0;
+        for (; i < pOpenAllocation->NumAllocations; ++i)
         {
             DXGK_OPENALLOCATIONINFO* pInfo = &pOpenAllocation->pOpenAllocation[i];
             Assert(pInfo->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
             Assert(pInfo->pPrivateDriverData);
+            PVBOXWDDM_ALLOCATION pAllocation = vboxWddmGetAllocationFromHandle(pDevExt, pInfo->hAllocation);
+            if (!pAllocation)
+            {
+                WARN(("invalid handle"));
+                Status = STATUS_INVALID_PARAMETER;
+                break;
+            }
+
             PVBOXWDDM_OPENALLOCATION pOa = (PVBOXWDDM_OPENALLOCATION)vboxWddmMemAllocZero(sizeof (VBOXWDDM_OPENALLOCATION));
+            if (!pOa)
+            {
+                WARN(("failed to allocation alloc info"));
+                Status = STATUS_INSUFFICIENT_RESOURCES;
+                break;
+            }
+
+#ifdef DEBUG
+            for (PLIST_ENTRY pCur = pAllocation->OpenList.Flink; pCur != &pAllocation->OpenList; pCur = pCur->Flink)
+            {
+                PVBOXWDDM_OPENALLOCATION pCurOa = CONTAINING_RECORD(pCur, VBOXWDDM_OPENALLOCATION, ListEntry);
+                if (pCurOa->pDevice == pDevice)
+                {
+                    /* should not happen */
+                    Assert(0);
+                    break;
+                }
+            }
+            Assert(!pAllocation->fAssumedDeletion);
+#endif
+            InsertHeadList(&pAllocation->OpenList, &pOa->ListEntry);
             pOa->hAllocation = pInfo->hAllocation;
+            pOa->pAllocation = pAllocation;
+            pOa->pDevice = pDevice;
             pInfo->hDeviceSpecificAllocation = pOa;
 
+
             if (pRcInfo)
             {
+                Assert(pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC);
+
+                if (pInfo->PrivateDriverDataSize < sizeof (VBOXWDDM_ALLOCINFO)
+                        || !pInfo->pPrivateDriverData)
+                {
+                    WARN(("invalid data size"));
+                    vboxWddmMemFree(pOa);
+                    Status = STATUS_INVALID_PARAMETER;
+                    break;
+                }
+                PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
+
 #ifdef VBOX_WITH_VIDEOHWACCEL
                 if (pRcInfo->RcDesc.fFlags.Overlay)
                 {
-                    if (pInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
-                    {
-                        PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pInfo->pPrivateDriverData;
-                        PVBOXWDDM_ALLOCATION pAllocation = vboxWddmGetAllocationFromOpenData(pDevExt, pOa);
-                        Assert(pAllocation);
-                        if (pAllocation)
-                        {
-                            /* we have queried host for some surface info, like pitch & size,
-                             * need to return it back to the UMD (User Mode Drive) */
-                            pAllocInfo->SurfDesc = pAllocation->SurfDesc;
-                            /* success, just continue */
-                            continue;
-                        }
-                        else
-                            Status = STATUS_INVALID_PARAMETER;
-                    }
-                    else
-                        Status = STATUS_INVALID_PARAMETER;
-
-                    /* we are here in case of error */
-                    AssertBreakpoint();
-
-                    for (UINT j = 0; j < i; ++j)
-                    {
-                        DXGK_OPENALLOCATIONINFO* pInfo2Free = &pOpenAllocation->pOpenAllocation[j];
-                        PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pInfo2Free->hDeviceSpecificAllocation;
-                        vboxWddmMemFree(pOa2Free);
-                    }
+                    /* we have queried host for some surface info, like pitch & size,
+                     * need to return it back to the UMD (User Mode Drive) */
+                    pAllocInfo->SurfDesc = pAllocation->SurfDesc;
+                    /* success, just continue */
                 }
 #endif
+            }
+
+            ++pAllocation->cOpens;
+        }
+
+        if (Status != STATUS_SUCCESS)
+        {
+            for (UINT j = 0; j < i; ++j)
+            {
+                DXGK_OPENALLOCATIONINFO* pInfo2Free = &pOpenAllocation->pOpenAllocation[j];
+                PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pInfo2Free->hDeviceSpecificAllocation;
+                PVBOXWDDM_ALLOCATION pAllocation = pOa2Free->pAllocation;
+                RemoveEntryList(&pOa2Free->ListEntry);
+                Assert(pAllocation->cOpens);
+                --pAllocation->cOpens;
+                vboxWddmMemFree(pOa2Free);
             }
         }
@@ -4645 +4791 @@
     vboxVDbgBreakFv();
 
+    PVBOXWDDM_DEVICE pDevice = (PVBOXWDDM_DEVICE)hDevice;
+    PVBOXMP_DEVEXT pDevExt = pDevice->pAdapter;
+
     for (UINT i = 0; i < pCloseAllocation->NumAllocations; ++i)
     {
-        vboxWddmMemFree(pCloseAllocation->pOpenHandleList[i]);
+        PVBOXWDDM_OPENALLOCATION pOa2Free = (PVBOXWDDM_OPENALLOCATION)pCloseAllocation->pOpenHandleList[i];
+        PVBOXWDDM_ALLOCATION pAllocation = pOa2Free->pAllocation;
+        RemoveEntryList(&pOa2Free->ListEntry);
+        Assert(pAllocation->cShRcRefs >= pOa2Free->cShRcRefs);
+        pAllocation->cShRcRefs -= pOa2Free->cShRcRefs;
+        Assert(pAllocation->cOpens);
+        --pAllocation->cOpens;
+        vboxWddmMemFree(pOa2Free);
     }