Changeset 108880 in vbox

Timestamp:

Apr 8, 2025 9:27:48 AM (12 days ago)

Author:

vboxsync

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

168331

Message:

WDDM: UMD: use KMRESOURCE instead of hAllocation as parameter for StorePatchLocation; cleanup. bugref:10885

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx

Files:

• VBoxDX.cpp (modified) (91 diffs)
• VBoxDX.h (modified) (10 diffs)
• VBoxDXCmd.cpp (modified) (57 diffs)
• VBoxDXCmd.h (modified) (15 diffs)
• VBoxDXDDI.cpp (modified) (7 diffs)
• VBoxDXVideo.cpp (modified) (16 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDX.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2022-2024 Oracle and/or its affiliates.
+ * Copyright (C) 2022-2025 Oracle and/or its affiliates.
  *
  * This file is part of VirtualBox base platform packages, as
@@ -46 +46 @@
 
 
-static uint32_t vboxDXGetSubresourceOffset(PVBOXDX_RESOURCE pResource, UINT Subresource)
+static uint32_t vboxDXGetSubresourceOffset(VBOXDXALLOCATIONDESC const *pAllocationDesc, UINT Subresource)
 {
     surf_size_struct baseLevelSize;
-    baseLevelSize.width  = pResource->AllocationDesc.surfaceInfo.size.width;
-    baseLevelSize.height = pResource->AllocationDesc.surfaceInfo.size.height;
-    baseLevelSize.depth  = pResource->AllocationDesc.surfaceInfo.size.depth;
-
-    uint32_t const numMipLevels = pResource->AllocationDesc.surfaceInfo.numMipLevels;
+    baseLevelSize.width  = pAllocationDesc->surfaceInfo.size.width;
+    baseLevelSize.height = pAllocationDesc->surfaceInfo.size.height;
+    baseLevelSize.depth  = pAllocationDesc->surfaceInfo.size.depth;
+
+    uint32_t const numMipLevels = pAllocationDesc->surfaceInfo.numMipLevels;
     uint32_t const face = Subresource / numMipLevels;
     uint32_t const mip = Subresource % numMipLevels;
-    return svga3dsurface_get_image_offset(pResource->AllocationDesc.surfaceInfo.format,
+    return svga3dsurface_get_image_offset(pAllocationDesc->surfaceInfo.format,
                                           baseLevelSize, numMipLevels, face, mip);
 }
 
 
-static uint32_t vboxDXGetSubresourceSize(PVBOXDX_RESOURCE pResource, UINT Subresource)
+static uint32_t vboxDXGetSubresourceSize(VBOXDXALLOCATIONDESC const *pAllocationDesc, UINT Subresource)
 {
     surf_size_struct baseLevelSize;
-    baseLevelSize.width  = pResource->AllocationDesc.surfaceInfo.size.width;
-    baseLevelSize.height = pResource->AllocationDesc.surfaceInfo.size.height;
-    baseLevelSize.depth  = pResource->AllocationDesc.surfaceInfo.size.depth;
-
-    uint32_t const numMipLevels = pResource->AllocationDesc.surfaceInfo.numMipLevels;
+    baseLevelSize.width  = pAllocationDesc->surfaceInfo.size.width;
+    baseLevelSize.height = pAllocationDesc->surfaceInfo.size.height;
+    baseLevelSize.depth  = pAllocationDesc->surfaceInfo.size.depth;
+
+    uint32_t const numMipLevels = pAllocationDesc->surfaceInfo.numMipLevels;
     /*uint32_t const face = Subresource / numMipLevels; - unused */
     uint32_t const mip = Subresource % numMipLevels;
 
-    const struct svga3d_surface_desc *desc = svga3dsurface_get_desc(pResource->AllocationDesc.surfaceInfo.format);
+    const struct svga3d_surface_desc *desc = svga3dsurface_get_desc(pAllocationDesc->surfaceInfo.format);
 
     surf_size_struct mipSize = svga3dsurface_get_mip_size(baseLevelSize, mip);
@@ -79 +79 @@
 
 
-static void vboxDXGetSubresourcePitch(PVBOXDX_RESOURCE pResource, UINT Subresource, UINT *pRowPitch, UINT *pDepthPitch)
-{
-    if (pResource->AllocationDesc.surfaceInfo.format == SVGA3D_BUFFER)
-    {
-        *pRowPitch = pResource->AllocationDesc.surfaceInfo.size.width;
+static void vboxDXGetSubresourcePitch(VBOXDXALLOCATIONDESC const *pAllocationDesc, UINT Subresource, UINT *pRowPitch, UINT *pDepthPitch)
+{
+    if (pAllocationDesc->surfaceInfo.format == SVGA3D_BUFFER)
+    {
+        *pRowPitch = pAllocationDesc->surfaceInfo.size.width;
         *pDepthPitch = *pRowPitch;
         return;
     }
 
-    uint32_t const numMipLevels = pResource->AllocationDesc.surfaceInfo.numMipLevels;
+    uint32_t const numMipLevels = pAllocationDesc->surfaceInfo.numMipLevels;
     /* uint32_t const face = Subresource / numMipLevels; - unused */
     uint32_t const mip = Subresource % numMipLevels;
 
     surf_size_struct baseLevelSize;
-    baseLevelSize.width  = pResource->AllocationDesc.surfaceInfo.size.width;
-    baseLevelSize.height = pResource->AllocationDesc.surfaceInfo.size.height;
-    baseLevelSize.depth  = pResource->AllocationDesc.surfaceInfo.size.depth;
-
-    const struct svga3d_surface_desc *desc = svga3dsurface_get_desc(pResource->AllocationDesc.surfaceInfo.format);
+    baseLevelSize.width  = pAllocationDesc->surfaceInfo.size.width;
+    baseLevelSize.height = pAllocationDesc->surfaceInfo.size.height;
+    baseLevelSize.depth  = pAllocationDesc->surfaceInfo.size.depth;
+
+    const struct svga3d_surface_desc *desc = svga3dsurface_get_desc(pAllocationDesc->surfaceInfo.format);
 
     surf_size_struct mipSize = svga3dsurface_get_mip_size(baseLevelSize, mip);
@@ -108 +108 @@
 
 
-static void vboxDXGetResourceBoxDimensions(PVBOXDX_RESOURCE pResource, UINT Subresource, SVGA3dBox *pBox,
+static void vboxDXGetResourceBoxDimensions(VBOXDXALLOCATIONDESC const *pAllocationDesc, UINT Subresource, SVGA3dBox *pBox,
                                            uint32_t *pOffPixel, uint32_t *pcbRow, uint32_t *pcRows, uint32_t *pDepth)
 {
-    if (pResource->AllocationDesc.surfaceInfo.format == SVGA3D_BUFFER)
+    if (pAllocationDesc->surfaceInfo.format == SVGA3D_BUFFER)
     {
         *pOffPixel = pBox->x;
@@ -120 +120 @@
     }
 
-    const struct svga3d_surface_desc *desc = svga3dsurface_get_desc(pResource->AllocationDesc.surfaceInfo.format);
+    const struct svga3d_surface_desc *desc = svga3dsurface_get_desc(pAllocationDesc->surfaceInfo.format);
 
     surf_size_struct baseLevelSize;
-    baseLevelSize.width  = pResource->AllocationDesc.surfaceInfo.size.width;
-    baseLevelSize.height = pResource->AllocationDesc.surfaceInfo.size.height;
-    baseLevelSize.depth  = pResource->AllocationDesc.surfaceInfo.size.depth;
-
-    uint32_t const numMipLevels = pResource->AllocationDesc.surfaceInfo.numMipLevels;
+    baseLevelSize.width  = pAllocationDesc->surfaceInfo.size.width;
+    baseLevelSize.height = pAllocationDesc->surfaceInfo.size.height;
+    baseLevelSize.depth  = pAllocationDesc->surfaceInfo.size.depth;
+
+    uint32_t const numMipLevels = pAllocationDesc->surfaceInfo.numMipLevels;
     uint32_t const mip = Subresource % numMipLevels;
 
@@ -139 +139 @@
     svga3dsurface_get_size_in_blocks(desc, &boxSize, &blocks);
 
-    *pOffPixel = svga3dsurface_get_pixel_offset(pResource->AllocationDesc.surfaceInfo.format,
+    *pOffPixel = svga3dsurface_get_pixel_offset(pAllocationDesc->surfaceInfo.format,
                                                 mipSize.width, mipSize.height,
                                                 pBox->x, pBox->y, pBox->z);
@@ -147 +147 @@
 }
 
-static void vboxDXGetSubresourceBox(PVBOXDX_RESOURCE pResource, UINT Subresource, SVGA3dBox *pBox)
+
+static void vboxDXGetSubresourceBox(VBOXDXALLOCATIONDESC const *pAllocationDesc, UINT Subresource, SVGA3dBox *pBox)
 {
     surf_size_struct baseLevelSize;
-    baseLevelSize.width  = pResource->AllocationDesc.surfaceInfo.size.width;
-    baseLevelSize.height = pResource->AllocationDesc.surfaceInfo.size.height;
-    baseLevelSize.depth  = pResource->AllocationDesc.surfaceInfo.size.depth;
-
-    uint32_t const numMipLevels = pResource->AllocationDesc.surfaceInfo.numMipLevels;
+    baseLevelSize.width  = pAllocationDesc->surfaceInfo.size.width;
+    baseLevelSize.height = pAllocationDesc->surfaceInfo.size.height;
+    baseLevelSize.depth  = pAllocationDesc->surfaceInfo.size.depth;
+
+    uint32_t const numMipLevels = pAllocationDesc->surfaceInfo.numMipLevels;
     uint32_t const mip = Subresource % numMipLevels;
 
@@ -235 +236 @@
 
 
-void vboxDXStorePatchLocation(PVBOXDX_DEVICE pDevice, void *pvPatch, VBOXDXALLOCATIONTYPE enmAllocationType,
-                              D3DKMT_HANDLE hAllocation, uint32_t offAllocation, bool fWriteOperation)
-{
+void vboxDXStorePatchLocation(PVBOXDX_DEVICE pDevice, void *pvPatch, PVBOXDXKMRESOURCE pKMResource,
+                              uint32_t offAllocation, bool fWriteOperation)
+{
+    D3DKMT_HANDLE hAllocation = vboxDXGetAllocation(pKMResource);
     if (!hAllocation)
         return;
@@ -272 +274 @@
     pPatchLocation->AllocationIndex = idxAllocation;
     pPatchLocation->Value = 0;
-    pPatchLocation->DriverId = enmAllocationType;
+    pPatchLocation->DriverId = pKMResource->AllocationDesc.enmAllocationType;
     pPatchLocation->AllocationOffset = offAllocation;
     pPatchLocation->PatchOffset = (uintptr_t)pvPatch - (uintptr_t)pDevice->pCommandBuffer;
     pPatchLocation->SplitOffset = pDevice->cbCommandBuffer;
     ++pDevice->cPatchLocations;
+
+    /* Move the KM resource to the head of the resource list. */
+    RTListNodeRemove(&pKMResource->nodeResource);
+    RTListPrepend(&pDevice->listResources, &pKMResource->nodeResource);
 }
 
@@ -313 +319 @@
             if (pResource)
             {
-                D3DKMT_HANDLE const hAllocation = vboxDXGetAllocation(pResource);
+                PVBOXDXKMRESOURCE const pKMResource = vboxDXGetKMResource(pResource);
                 uint32 const offsetInBytes = pCBS->aFirstConstant[i] * (4 * sizeof(UINT));
                 uint32 const sizeInBytes = pCBS->aNumConstants[i] * (4 * sizeof(UINT));
                 LogFunc(("type %d, slot %d, off %d, size %d, cbAllocation %d",
-                         enmShaderType, i, offsetInBytes, sizeInBytes, pResource->AllocationDesc.cbAllocation));
-
-                vgpu10SetSingleConstantBuffer(pDevice, i, enmShaderType, hAllocation, offsetInBytes, sizeInBytes);
+                         enmShaderType, i, offsetInBytes, sizeInBytes, pKMResource->AllocationDesc.cbAllocation));
+
+                vgpu10SetSingleConstantBuffer(pDevice, i, enmShaderType, pKMResource, offsetInBytes, sizeInBytes);
             }
             else
@@ -349 +355 @@
 
     /* Fetch allocation handles. */
-    D3DKMT_HANDLE aAllocations[SVGA3D_MAX_VERTEX_ARRAYS];
+    PVBOXDXKMRESOURCE aKMResources[SVGA3D_MAX_VERTEX_ARRAYS];
     for (unsigned i = pVBS->StartSlot; i < pVBS->StartSlot + pVBS->NumBuffers; ++i)
     {
         PVBOXDX_RESOURCE pResource = pVBS->apResource[i];
-        aAllocations[i] = vboxDXGetAllocation(pResource);
-    }
-
-    vgpu10SetVertexBuffers(pDevice, pVBS->StartSlot, pVBS->NumBuffers, aAllocations,
+        aKMResources[i] = vboxDXGetKMResource(pResource);
+    }
+
+    vgpu10SetVertexBuffers(pDevice, pVBS->StartSlot, pVBS->NumBuffers, aKMResources,
                            &pVBS->aStrides[pVBS->StartSlot], &pVBS->aOffsets[pVBS->StartSlot]);
 
@@ -381 +387 @@
     PVBOXDXINDEXBUFFERSTATE pIBS = &pDevice->pipeline.IndexBuffer;
 
-    D3DKMT_HANDLE const hAllocation = vboxDXGetAllocation(pIBS->pBuffer);
+    PVBOXDXKMRESOURCE const pKMResource = vboxDXGetKMResource(pIBS->pBuffer);
     SVGA3dSurfaceFormat const svgaFormat = vboxDXDxgiToSvgaFormat(pIBS->Format);
-    vgpu10SetIndexBuffer(pDevice, hAllocation, svgaFormat, pIBS->Offset);
+    vgpu10SetIndexBuffer(pDevice, pKMResource, svgaFormat, pIBS->Offset);
 }
 
@@ -577 +583 @@
 
 
-static uint32_t vboxDXCalcResourceAllocationSize(PVBOXDX_RESOURCE pResource)
+PVBOXDXKMRESOURCE vboxDXAllocateKMResource(PVBOXDX_DEVICE pDevice, HANDLE hResource,
+                                           PFNVBOXDXINITALLOCATIONDESC pfnInitAllocationDesc,
+                                           void const *pvInitData, bool fZero)
+{
+    PVBOXDXKMRESOURCE pKMResource = (PVBOXDXKMRESOURCE)RTMemAllocZ(sizeof(VBOXDXKMRESOURCE));
+    AssertReturnStmt(pKMResource, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), NULL);
+
+    pfnInitAllocationDesc(&pKMResource->AllocationDesc, pvInitData);
+
+    D3DDDI_ALLOCATIONINFO2 ddiAllocationInfo;
+    RT_ZERO(ddiAllocationInfo);
+    ddiAllocationInfo.pPrivateDriverData    = &pKMResource->AllocationDesc;
+    ddiAllocationInfo.PrivateDriverDataSize = sizeof(pKMResource->AllocationDesc);
+    if (pKMResource->AllocationDesc.fPrimary)
+    {
+        ddiAllocationInfo.VidPnSourceId     = pKMResource->AllocationDesc.PrimaryDesc.VidPnSourceId;
+        ddiAllocationInfo.Flags.Primary     = 1;
+    }
+
+    D3DDDICB_ALLOCATE ddiAllocate;
+    RT_ZERO(ddiAllocate);
+    ddiAllocate.hResource        = hResource;
+    ddiAllocate.NumAllocations   = 1;
+    ddiAllocate.pAllocationInfo2 = &ddiAllocationInfo;
+
+    HRESULT hr = pDevice->pRTCallbacks->pfnAllocateCb(pDevice->hRTDevice.handle, &ddiAllocate);
+    LogFlowFunc(("pfnAllocateCb returned 0x%x, hKMResource 0x%X, hAllocation 0x%X", hr, ddiAllocate.hKMResource, ddiAllocationInfo.hAllocation));
+    AssertReturnStmt(SUCCEEDED(hr),
+                     vboxDXDeallocateKMResource(pDevice, pKMResource); vboxDXDeviceSetError(pDevice, hr),
+                     false);
+
+    pKMResource->hAllocation = ddiAllocationInfo.hAllocation;
+
+    if (fZero)
+    {
+        D3DDDICB_LOCK ddiLock;
+        RT_ZERO(ddiLock);
+        ddiLock.hAllocation = ddiAllocationInfo.hAllocation;
+        ddiLock.Flags.WriteOnly = 1;
+        hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
+        if (SUCCEEDED(hr))
+        {
+            memset(ddiLock.pData, 0, pKMResource->AllocationDesc.cbAllocation);
+
+            D3DDDICB_UNLOCK ddiUnlock;
+            ddiUnlock.NumAllocations = 1;
+            ddiUnlock.phAllocations = &ddiLock.hAllocation;
+            hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
+        }
+        AssertReturnStmt(SUCCEEDED(hr),
+                         vboxDXDeallocateKMResource(pDevice, pKMResource); vboxDXDeviceSetError(pDevice, hr),
+                         false);
+    }
+
+    return pKMResource;
+}
+
+
+PVBOXDXKMRESOURCE vboxDXOpenKMResource(PVBOXDX_DEVICE pDevice, D3DKMT_HANDLE hAllocation,
+                                       VBOXDXALLOCATIONDESC const *pDesc)
+{
+    PVBOXDXKMRESOURCE pKMResource = (PVBOXDXKMRESOURCE)RTMemAllocZ(sizeof(VBOXDXKMRESOURCE));
+    AssertReturnStmt(pKMResource, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), NULL);
+
+    pKMResource->hAllocation = hAllocation;
+    pKMResource->AllocationDesc = *pDesc;
+    pKMResource->flags.fOpened = 1;
+    return pKMResource;
+}
+
+
+void vboxDXDeallocateKMResource(PVBOXDX_DEVICE pDevice, PVBOXDXKMRESOURCE pKMResource)
+{
+    if (pKMResource)
+    {
+        Assert(!pKMResource->flags.fOpened);
+
+        if (pKMResource->hAllocation)
+        {
+            D3DDDICB_DEALLOCATE ddiDeallocate;
+            RT_ZERO(ddiDeallocate);
+            //ddiDeallocate.hResource    = NULL;
+            ddiDeallocate.NumAllocations = 1;
+            ddiDeallocate.HandleList     = &pKMResource->hAllocation;
+
+            HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
+            LogFlowFunc(("pfnDeallocateCb returned 0x%x, hAllocation 0x%x", hr, pKMResource->hAllocation));
+            AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
+        }
+
+        RTMemFree(pKMResource);
+    }
+}
+
+
+static uint32_t vboxDXCalcResourceAllocationSize(VBOXDXALLOCATIONDESC const *pAllocationDesc)
 {
     /* The allocation holds the entire resource:
@@ -585 +686 @@
      */
     surf_size_struct base_level_size;
-    base_level_size.width  = pResource->AllocationDesc.surfaceInfo.size.width;
-    base_level_size.height = pResource->AllocationDesc.surfaceInfo.size.height;
-    base_level_size.depth  = pResource->AllocationDesc.surfaceInfo.size.depth;
-
-    return svga3dsurface_get_serialized_size_extended(pResource->AllocationDesc.surfaceInfo.format,
+    base_level_size.width  = pAllocationDesc->surfaceInfo.size.width;
+    base_level_size.height = pAllocationDesc->surfaceInfo.size.height;
+    base_level_size.depth  = pAllocationDesc->surfaceInfo.size.depth;
+
+    return svga3dsurface_get_serialized_size_extended(pAllocationDesc->surfaceInfo.format,
                                                       base_level_size,
-                                                      pResource->AllocationDesc.surfaceInfo.numMipLevels,
-                                                      pResource->AllocationDesc.surfaceInfo.arraySize,
-                                                      pResource->AllocationDesc.surfaceInfo.multisampleCount);
+                                                      pAllocationDesc->surfaceInfo.numMipLevels,
+                                                      pAllocationDesc->surfaceInfo.arraySize,
+                                                      pAllocationDesc->surfaceInfo.multisampleCount);
 }
 
@@ -695 +796 @@
 
 
-int vboxDXInitResourceData(PVBOXDX_RESOURCE pResource, const D3D11DDIARG_CREATERESOURCE *pCreateResource)
-{
-    /* Store data which might be needed later. */
-    pResource->ResourceDimension = pCreateResource->ResourceDimension;
-    pResource->Usage             = (D3D10_DDI_RESOURCE_USAGE)pCreateResource->Usage;
-    for (UINT i = 0; i < pCreateResource->MipLevels; ++i)
-        pResource->aMipInfoList[i] = pCreateResource->pMipInfoList[i];
+static void resourceAllocationDesc(VBOXDXALLOCATIONDESC *pDesc, void const *pvInitData)
+{
+    const D3D11DDIARG_CREATERESOURCE *pCreateResource = (const D3D11DDIARG_CREATERESOURCE *)pvInitData;
 
     /* Init surface information which will be used by the miniport to define the surface. */
-    VBOXDXALLOCATIONDESC *pDesc = &pResource->AllocationDesc;
     pDesc->surfaceInfo.surfaceFlags       = vboxDXCalcSurfaceFlags(pCreateResource);
     pDesc->surfaceInfo.format             = vboxDXDxgiToSvgaFormat(pCreateResource->Format);
@@ -741 +837 @@
     /* Finally set the allocation type and compute the size. */
     pDesc->enmAllocationType = VBOXDXALLOCATIONTYPE_SURFACE;
-    pDesc->cbAllocation = vboxDXCalcResourceAllocationSize(pResource);
-
-    /* Init remaining fields. */
+    pDesc->cbAllocation = vboxDXCalcResourceAllocationSize(pDesc);
+}
+
+
+bool vboxDXCreateResource(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pResource,
+                          const D3D11DDIARG_CREATERESOURCE *pCreateResource)
+{
+    bool const fZero = pCreateResource->pInitialDataUP == NULL
+                    && (   pCreateResource->Usage == D3D10_DDI_USAGE_DYNAMIC
+                        || pCreateResource->Usage == D3D10_DDI_USAGE_STAGING);
+
+    pResource->pKMResource = vboxDXAllocateKMResource(pDevice, pResource->hRTResource.handle,
+                                                      resourceAllocationDesc, pCreateResource, fZero);
+    if (!pResource->pKMResource)
+    {
+        /* Might be not enough memory due to temporary staging buffers. */
+        vboxDXFlush(pDevice, true);
+        pResource->pKMResource = vboxDXAllocateKMResource(pDevice, pResource->hRTResource.handle,
+                                                          resourceAllocationDesc, pCreateResource, fZero);
+    }
+
+    if (!pResource->pKMResource)
+        return false;
+
+    pResource->ResourceDimension = pCreateResource->ResourceDimension;
+    pResource->Usage             = (D3D10_DDI_RESOURCE_USAGE)pCreateResource->Usage;
+    for (UINT i = 0; i < pCreateResource->MipLevels; ++i)
+        pResource->aMipInfoList[i] = pCreateResource->pMipInfoList[i];
     pResource->cSubresources = pCreateResource->MipLevels * pCreateResource->ArraySize;
-    pResource->pKMResource = NULL;
     pResource->uMap = 0;
+
     RTListInit(&pResource->listSRV);
     RTListInit(&pResource->listRTV);
@@ -755 +876 @@
     RTListInit(&pResource->listVPOV);
 
-    return VINF_SUCCESS;
-}
-
-
-static HRESULT dxAllocate(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pResource, D3DKMT_HANDLE *phAllocation)
-{
-    D3DDDI_ALLOCATIONINFO2 ddiAllocationInfo;
-    RT_ZERO(ddiAllocationInfo);
-    //ddiAllocationInfo.pSystemMem            = 0;
-    ddiAllocationInfo.pPrivateDriverData    = &pResource->AllocationDesc;
-    ddiAllocationInfo.PrivateDriverDataSize = sizeof(pResource->AllocationDesc);
-    if (pResource->AllocationDesc.fPrimary)
-    {
-        ddiAllocationInfo.VidPnSourceId     = pResource->AllocationDesc.PrimaryDesc.VidPnSourceId;
-        ddiAllocationInfo.Flags.Primary     = pResource->AllocationDesc.fPrimary;
-    }
-
-    D3DDDICB_ALLOCATE ddiAllocate;
-    RT_ZERO(ddiAllocate);
-    //ddiAllocate.pPrivateDriverData    = NULL;
-    //ddiAllocate.PrivateDriverDataSize = 0;
-    ddiAllocate.hResource             = pResource->hRTResource.handle;
-    ddiAllocate.NumAllocations        = 1;
-    ddiAllocate.pAllocationInfo2      = &ddiAllocationInfo;
-
-    HRESULT hr = pDevice->pRTCallbacks->pfnAllocateCb(pDevice->hRTDevice.handle, &ddiAllocate);
-    LogFlowFunc((" pfnAllocateCb returned %d, hKMResource 0x%X, hAllocation 0x%X", hr, ddiAllocate.hKMResource, ddiAllocationInfo.hAllocation));
-
-    if (SUCCEEDED(hr))
-        *phAllocation = ddiAllocationInfo.hAllocation;
-
-    return hr;
-}
-
-
-bool vboxDXCreateResource(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pResource,
-                          const D3D11DDIARG_CREATERESOURCE *pCreateResource)
-{
-    pResource->pKMResource = (PVBOXDXKMRESOURCE)RTMemAllocZ(sizeof(VBOXDXKMRESOURCE));
-    AssertReturnStmt(pResource->pKMResource, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), false);
-
-    D3DKMT_HANDLE hAllocation = 0;
-    HRESULT hr = dxAllocate(pDevice, pResource, &hAllocation);
-    if (FAILED(hr))
-    {
-        /* Might be not enough memory due to temporary staging buffers. */
-        vboxDXFlush(pDevice, true);
-        hr = dxAllocate(pDevice, pResource, &hAllocation);
-    }
-    AssertReturnStmt(SUCCEEDED(hr), RTMemFree(pResource->pKMResource); vboxDXDeviceSetError(pDevice, hr), false);
-
-    pResource->pKMResource->pResource = pResource;
-    pResource->pKMResource->hAllocation = hAllocation;
+    pResource->pKMResource->resource.pResource = pResource;
+
     RTListAppend(&pDevice->listResources, &pResource->pKMResource->nodeResource);
 
@@ -813 +883 @@
     {
         /* Upload the data to the resource. */
-        for (unsigned i = 0; i < pResource->cSubresources; ++i)
+        for (UINT i = 0; i < pResource->cSubresources; ++i)
             vboxDXResourceUpdateSubresourceUP(pDevice, pResource, i, NULL,
                                               pCreateResource->pInitialDataUP[i].pSysMem,
@@ -820 +890 @@
 
     }
-    else
-    {
-        /** @todo Test Lock/Unlock. Not sure if memset is really necessary. */
-        if (   pResource->Usage == D3D10_DDI_USAGE_DYNAMIC
-            || pResource->Usage == D3D10_DDI_USAGE_STAGING)
-        {
-            /* Zero the allocation. */
-            D3DDDICB_LOCK ddiLock;
-            RT_ZERO(ddiLock);
-            ddiLock.hAllocation = vboxDXGetAllocation(pResource);
-            ddiLock.Flags.WriteOnly = 1;
-            hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
-            if (SUCCEEDED(hr))
-            {
-                memset(ddiLock.pData, 0, pResource->AllocationDesc.cbAllocation);
-
-                hAllocation = vboxDXGetAllocation(pResource);
-
-                D3DDDICB_UNLOCK ddiUnlock;
-                ddiUnlock.NumAllocations = 1;
-                ddiUnlock.phAllocations = &hAllocation;
-                hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
-            }
-        }
-    }
 
     return true;
@@ -858 +903 @@
                      vboxDXDeviceSetError(pDevice, E_INVALIDARG), false);
 
-    pResource->pKMResource = (PVBOXDXKMRESOURCE)RTMemAllocZ(sizeof(VBOXDXKMRESOURCE));
-    AssertReturnStmt(pResource->pKMResource, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), false);
-
-    VBOXDXALLOCATIONDESC const *pDesc = (VBOXDXALLOCATIONDESC *)pOpenResource->pOpenAllocationInfo2[0].pPrivateDriverData;
+    pResource->pKMResource = vboxDXOpenKMResource(pDevice, pOpenResource->pOpenAllocationInfo2[0].hAllocation,
+                                                  (VBOXDXALLOCATIONDESC *)pOpenResource->pOpenAllocationInfo2[0].pPrivateDriverData);
+    if (!pResource->pKMResource)
+        return false;
+
+    VBOXDXALLOCATIONDESC const *pDesc = vboxDXGetAllocationDesc(pResource);
 
     /* Restore resource data. */
@@ -868 +915 @@
     for (UINT i = 0; i < pDesc->surfaceInfo.numMipLevels; ++i)
         RT_ZERO(pResource->aMipInfoList[i]);
-
-    pResource->AllocationDesc = *pDesc;
-    pResource->AllocationDesc.resourceInfo.MiscFlags |= D3D10_DDI_RESOURCE_MISC_SHARED;
-
-    /* Init remaining fields. */
     pResource->cSubresources = pDesc->surfaceInfo.numMipLevels * pDesc->surfaceInfo.arraySize;
-    pResource->uMap             = 0;
+    pResource->uMap = 0;
+
     RTListInit(&pResource->listSRV);
     RTListInit(&pResource->listRTV);
@@ -883 +926 @@
     RTListInit(&pResource->listVPOV);
 
-    pResource->pKMResource->pResource = pResource;
-    pResource->pKMResource->hAllocation = pOpenResource->pOpenAllocationInfo2[0].hAllocation;
+    pResource->pKMResource->resource.pResource = pResource;
+
     RTListAppend(&pDevice->listResources, &pResource->pKMResource->nodeResource);
+
     return true;
 }
@@ -912 +956 @@
     RTListNodeRemove(&pResource->pKMResource->nodeResource);
 
-    if (pResource->AllocationDesc.fPrimary)
+    if (pResource->pKMResource->AllocationDesc.fPrimary)
     {
         /* Delete immediately. */
-        D3DDDICB_DEALLOCATE ddiDeallocate;
-        RT_ZERO(ddiDeallocate);
-        //ddiDeallocate.hResource      = NULL;
-        ddiDeallocate.NumAllocations = 1;
-        ddiDeallocate.HandleList     = &pResource->pKMResource->hAllocation;
-
-        HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
-        LogFlowFunc(("pfnDeallocateCb returned %d", hr));
-        AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
-
-        RTMemFree(pResource->pKMResource);
+        vboxDXDeallocateKMResource(pDevice, pResource->pKMResource);
+        pResource->pKMResource = 0;
     }
     else
     {
-        if (!RT_BOOL(pResource->AllocationDesc.resourceInfo.MiscFlags & D3D10_DDI_RESOURCE_MISC_SHARED))
+        if (   !pResource->pKMResource->flags.fOpened
+            && !RT_BOOL(pResource->pKMResource->AllocationDesc.resourceInfo.MiscFlags & D3D10_DDI_RESOURCE_MISC_SHARED))
         {
             /* Set the resource for deferred destruction. */
-            pResource->pKMResource->pResource = NULL;
+            pResource->pKMResource->resource.pResource = NULL;
             RTListAppend(&pDevice->listDestroyedResources, &pResource->pKMResource->nodeResource);
         }
@@ -1508 +1544 @@
 {
     vboxDXSetupPipeline(pDevice);
-    vgpu10DrawIndexedInstancedIndirect(pDevice, vboxDXGetAllocation(pResource), AlignedByteOffsetForArgs);
+    vgpu10DrawIndexedInstancedIndirect(pDevice, vboxDXGetKMResource(pResource), AlignedByteOffsetForArgs);
 }
 
@@ -1515 +1551 @@
 {
     vboxDXSetupPipeline(pDevice);
-    vgpu10DrawInstancedIndirect(pDevice, vboxDXGetAllocation(pResource), AlignedByteOffsetForArgs);
+    vgpu10DrawInstancedIndirect(pDevice, vboxDXGetKMResource(pResource), AlignedByteOffsetForArgs);
 }
 
@@ -1533 +1569 @@
 
 
-static void vboxDXDestroyCOAllocation(PVBOXDX_DEVICE pDevice, PVBOXDXCOALLOCATION pCOAllocation)
+static void vboxDXDestroyCOAllocation(PVBOXDX_DEVICE pDevice, PVBOXDXKMRESOURCE pCOAllocation)
 {
     if (pCOAllocation)
     {
-        if (pCOAllocation->hCOAllocation)
-        {
-            D3DDDICB_DEALLOCATE ddiDeallocate;
-            RT_ZERO(ddiDeallocate);
-            ddiDeallocate.NumAllocations = 1;
-            ddiDeallocate.HandleList     = &pCOAllocation->hCOAllocation;
-
-            HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
-            LogFlowFunc(("pfnDeallocateCb returned %d", hr));
-            AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
-
-            pCOAllocation->hCOAllocation = 0;
-        }
-
-        RTMemFree(pCOAllocation);
-    }
-}
-
-
-static bool vboxDXCreateCOAllocation(PVBOXDX_DEVICE pDevice, RTLISTANCHOR *pList, PVBOXDXCOALLOCATION *ppCOAllocation, uint32_t cbAllocation)
-{
-    PVBOXDXCOALLOCATION pCOAllocation = (PVBOXDXCOALLOCATION)RTMemAllocZ(sizeof(VBOXDXCOALLOCATION));
-    AssertReturnStmt(pCOAllocation, vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY), false);
-
-    VBOXDXALLOCATIONDESC desc;
-    RT_ZERO(desc);
-    desc.enmAllocationType = VBOXDXALLOCATIONTYPE_CO;
-    desc.cbAllocation      = cbAllocation;
-
-    D3DDDI_ALLOCATIONINFO2 ddiAllocationInfo;
-    RT_ZERO(ddiAllocationInfo);
-    ddiAllocationInfo.pPrivateDriverData    = &desc;
-    ddiAllocationInfo.PrivateDriverDataSize = sizeof(desc);
-
-    D3DDDICB_ALLOCATE ddiAllocate;
-    RT_ZERO(ddiAllocate);
-    ddiAllocate.NumAllocations   = 1;
-    ddiAllocate.pAllocationInfo2 = &ddiAllocationInfo;
-
-    HRESULT hr = pDevice->pRTCallbacks->pfnAllocateCb(pDevice->hRTDevice.handle, &ddiAllocate);
-    LogFlowFunc(("pfnAllocateCb returned %d, hKMResource 0x%X, hAllocation 0x%X", hr, ddiAllocate.hKMResource, ddiAllocationInfo.hAllocation));
-    AssertReturnStmt(SUCCEEDED(hr),
-                     vboxDXDestroyCOAllocation(pDevice, pCOAllocation); vboxDXDeviceSetError(pDevice, hr), false);
-
-    pCOAllocation->hCOAllocation = ddiAllocationInfo.hAllocation;
-
-    D3DDDICB_LOCK ddiLock;
-    RT_ZERO(ddiLock);
-    ddiLock.hAllocation = ddiAllocationInfo.hAllocation;
-    ddiLock.Flags.WriteOnly = 1;
-    hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
-    if (SUCCEEDED(hr))
-    {
-        memset(ddiLock.pData, 0, cbAllocation);
-
-        D3DDDICB_UNLOCK ddiUnlock;
-        ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &ddiAllocationInfo.hAllocation;
-        hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
-    }
-    AssertReturnStmt(SUCCEEDED(hr),
-                     vboxDXDestroyCOAllocation(pDevice, pCOAllocation); vboxDXDeviceSetError(pDevice, hr), false);
-
-    pCOAllocation->cbAllocation = cbAllocation;
+        Assert(pCOAllocation->AllocationDesc.enmAllocationType == VBOXDXALLOCATIONTYPE_CO);
+
+        /* Remove from the global list of resources. */
+        RTListNodeRemove(&pCOAllocation->nodeResource);
+        vboxDXDeallocateKMResource(pDevice, pCOAllocation);
+    }
+}
+
+
+static void coAllocationDesc(VBOXDXALLOCATIONDESC *pDesc, void const *pvInitData)
+{
+    pDesc->enmAllocationType = VBOXDXALLOCATIONTYPE_CO; /* Context Object allocation. */
+    pDesc->cbAllocation      = *(uint32_t *)pvInitData;
+}
+
+
+static bool vboxDXCreateCOAllocation(PVBOXDX_DEVICE pDevice, RTLISTANCHOR *pList, PVBOXDXKMRESOURCE *ppCOAllocation, uint32_t cbAllocation)
+{
+    PVBOXDXKMRESOURCE pCOAllocation = vboxDXAllocateKMResource(pDevice, 0, coAllocationDesc, &cbAllocation, true);
+    if (!pCOAllocation)
+        return false;
 
     /* Initially the allocation contains one big free block and zero sized free blocks. */
-    pCOAllocation->aOffset[0] = 0;
-    for (unsigned i = 1; i < RT_ELEMENTS(pCOAllocation->aOffset); ++i)
-        pCOAllocation->aOffset[i] = cbAllocation;
-
-    RTListAppend(pList, &pCOAllocation->nodeAllocationsChain);
+    pCOAllocation->co.aOffset[0] = 0;
+    for (unsigned i = 1; i < RT_ELEMENTS(pCOAllocation->co.aOffset); ++i)
+        pCOAllocation->co.aOffset[i] = cbAllocation;
+
+    /* Add to the chain of COAs. */
+    RTListAppend(pList, &pCOAllocation->co.nodeAllocationsChain);
+
+    /* Add to the global list of resources. */
+    RTListAppend(&pDevice->listResources, &pCOAllocation->nodeResource);
 
     *ppCOAllocation = pCOAllocation;
@@ -1613 +1610 @@
 }
 
-#define IS_CO_BLOCK_FREE(_a, _i) (((_a)->u64Bitmap & (1ULL << (_i))) == 0)
-#define IS_CO_BLOCK_USED(_a, _i) (((_a)->u64Bitmap & (1ULL << (_i))) != 0)
-#define SET_CO_BLOCK_FREE(_a, _i) (((_a)->u64Bitmap &= ~(1ULL << (_i))))
-#define SET_CO_BLOCK_USED(_a, _i) (((_a)->u64Bitmap |= (1ULL << (_i))))
-
-static bool vboxDXCOABlockAlloc(PVBOXDXCOALLOCATION pCOAllocation, uint32_t cb, uint32_t *poff)
-{
+#define IS_CO_BLOCK_FREE(_a, _i) (((_a)->co.u64Bitmap & (1ULL << (_i))) == 0)
+#define IS_CO_BLOCK_USED(_a, _i) (((_a)->co.u64Bitmap & (1ULL << (_i))) != 0)
+#define SET_CO_BLOCK_FREE(_a, _i) (((_a)->co.u64Bitmap &= ~(1ULL << (_i))))
+#define SET_CO_BLOCK_USED(_a, _i) (((_a)->co.u64Bitmap |= (1ULL << (_i))))
+
+static bool vboxDXCOABlockAlloc(PVBOXDXKMRESOURCE pCOAllocation, uint32_t cb, uint32_t *poff)
+{
+    Assert(pCOAllocation->AllocationDesc.enmAllocationType == VBOXDXALLOCATIONTYPE_CO);
+
     //DEBUG_BREAKPOINT_TEST();
     /* Search for a big enough free block. The last block is a special case. */
     unsigned i = 0;
-    for (; i < RT_ELEMENTS(pCOAllocation->aOffset) - 1; ++i)
+    for (; i < RT_ELEMENTS(pCOAllocation->co.aOffset) - 1; ++i)
     {
         if (   IS_CO_BLOCK_FREE(pCOAllocation, i)
-            && pCOAllocation->aOffset[i + 1] - pCOAllocation->aOffset[i] >= cb)
+            && pCOAllocation->co.aOffset[i + 1] - pCOAllocation->co.aOffset[i] >= cb)
         {
             /* Found one. */
@@ -1633 +1632 @@
             /* If the next block is free, then add the remaining space to it. */
             if (IS_CO_BLOCK_FREE(pCOAllocation, i + 1))
-                pCOAllocation->aOffset[i + 1] = pCOAllocation->aOffset[i] + cb;
-
-            *poff = pCOAllocation->aOffset[i];
+                pCOAllocation->co.aOffset[i + 1] = pCOAllocation->co.aOffset[i] + cb;
+
+            *poff = pCOAllocation->co.aOffset[i];
             return true;
         }
@@ -1642 +1641 @@
     /* Last block. */
     if (   IS_CO_BLOCK_FREE(pCOAllocation, i)
-        && pCOAllocation->cbAllocation - pCOAllocation->aOffset[i] >= cb)
+        && pCOAllocation->AllocationDesc.cbAllocation - pCOAllocation->co.aOffset[i] >= cb)
     {
         /* Found one. */
         SET_CO_BLOCK_USED(pCOAllocation, i);
 
-        *poff = pCOAllocation->aOffset[i];
+        *poff = pCOAllocation->co.aOffset[i];
         return true;
     }
@@ -1655 +1654 @@
 
 
-static void vboxDXCOABlockFree(PVBOXDXCOALLOCATION pCOAllocation, uint32_t offBlock)
-{
+static void vboxDXCOABlockFree(PVBOXDXKMRESOURCE pCOAllocation, uint32_t offBlock)
+{
+    Assert(pCOAllocation->AllocationDesc.enmAllocationType == VBOXDXALLOCATIONTYPE_CO);
+
     //DEBUG_BREAKPOINT_TEST();
-    for (unsigned i = 0; i < RT_ELEMENTS(pCOAllocation->aOffset); ++i)
-    {
-        if (pCOAllocation->aOffset[i] == offBlock)
+    for (unsigned i = 0; i < RT_ELEMENTS(pCOAllocation->co.aOffset); ++i)
+    {
+        if (pCOAllocation->co.aOffset[i] == offBlock)
         {
             Assert(IS_CO_BLOCK_USED(pCOAllocation, i));
@@ -1672 +1673 @@
 
 
+static void shadersAllocationDesc(VBOXDXALLOCATIONDESC *pDesc, void const *pvInitData)
+{
+    pDesc->enmAllocationType = VBOXDXALLOCATIONTYPE_SHADERS;
+    pDesc->cbAllocation      = *(uint32_t *)pvInitData;
+}
+
+
 static bool vboxDXEnsureShaderAllocation(PVBOXDX_DEVICE pDevice)
 {
-    if (!pDevice->hShaderAllocation)
-    {
-        VBOXDXALLOCATIONDESC desc;
-        RT_ZERO(desc);
-        desc.enmAllocationType = VBOXDXALLOCATIONTYPE_SHADERS;
-        desc.cbAllocation      = SVGA3D_MAX_SHADER_MEMORY_BYTES;
-
-        D3DDDI_ALLOCATIONINFO2 ddiAllocationInfo;
-        RT_ZERO(ddiAllocationInfo);
-        //ddiAllocationInfo.pSystemMem            = 0;
-        ddiAllocationInfo.pPrivateDriverData    = &desc;
-        ddiAllocationInfo.PrivateDriverDataSize = sizeof(desc);
-        //ddiAllocationInfo.VidPnSourceId         = 0;
-        //ddiAllocationInfo.Flags.Value           = 0;
-
-        D3DDDICB_ALLOCATE ddiAllocate;
-        RT_ZERO(ddiAllocate);
-        //ddiAllocate.pPrivateDriverData    = NULL;
-        //ddiAllocate.PrivateDriverDataSize = 0;
-        //ddiAllocate.hResource             = 0;
-        ddiAllocate.NumAllocations        = 1;
-        ddiAllocate.pAllocationInfo2      = &ddiAllocationInfo;
-
-        HRESULT hr = pDevice->pRTCallbacks->pfnAllocateCb(pDevice->hRTDevice.handle, &ddiAllocate);
-        LogFlowFunc((" pfnAllocateCb returned %d, hKMResource 0x%X, hAllocation 0x%X", hr, ddiAllocate.hKMResource, ddiAllocationInfo.hAllocation));
-        AssertReturnStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr), false);
-
-        pDevice->hShaderAllocation  = ddiAllocationInfo.hAllocation;
-        pDevice->cbShaderAllocation = SVGA3D_MAX_SHADER_MEMORY_BYTES;
-        pDevice->cbShaderAvailable  = SVGA3D_MAX_SHADER_MEMORY_BYTES;
+    if (!pDevice->pShadersKMResource)
+    {
+        uint32_t const cbAllocation = SVGA3D_MAX_SHADER_MEMORY_BYTES;
+        pDevice->pShadersKMResource = vboxDXAllocateKMResource(pDevice, 0, shadersAllocationDesc,
+                                                               &cbAllocation, false);
+        if (!pDevice->pShadersKMResource)
+            return false;
+
+        pDevice->cbShaderAvailable  = cbAllocation;
         pDevice->offShaderFree      = 0;
+
+        RTListAppend(&pDevice->listResources, &pDevice->pShadersKMResource->nodeResource);
     }
 
@@ -1772 +1761 @@
 
     uint32_t const cbShaderTotal = pShader->cbShader + pShader->cbSignatures;
-    if (pDevice->cbShaderAllocation - pDevice->offShaderFree < cbShaderTotal)
+    if (pDevice->pShadersKMResource->AllocationDesc.cbAllocation - pDevice->offShaderFree < cbShaderTotal)
     {
         if (pDevice->cbShaderAvailable < cbShaderTotal)
@@ -1824 +1813 @@
     D3DDDICB_LOCK ddiLock;
     RT_ZERO(ddiLock);
-    ddiLock.hAllocation = pDevice->hShaderAllocation;
+    ddiLock.hAllocation = vboxDXGetAllocation(pDevice->pShadersKMResource);
     ddiLock.Flags.WriteOnly = 1;
     HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -1838 +1827 @@
         D3DDDICB_UNLOCK ddiUnlock;
         ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &pDevice->hShaderAllocation;
+        ddiUnlock.phAllocations = &ddiLock.hAllocation;
         hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
     }
@@ -1851 +1840 @@
 
     vgpu10DefineShader(pDevice, pShader->uShaderId, pShader->enmShaderType, cbShaderTotal);
-    vgpu10BindShader(pDevice, pShader->uShaderId, pDevice->hShaderAllocation, pShader->offShader);
+    vgpu10BindShader(pDevice, pShader->uShaderId, pDevice->pShadersKMResource, pShader->offShader);
 }
 
@@ -1880 +1869 @@
     pShader->gs.cbOutputStreamDecls = pShader->gs.NumEntries * sizeof(*pOutputStreamDecl);
     pShader->gs.pCOAllocation = NULL;
-    PVBOXDXCOALLOCATION pIter;
-    RTListForEach(&pDevice->listCOAStreamOutput, pIter, VBOXDXCOALLOCATION, nodeAllocationsChain)
+    PVBOXDXKMRESOURCE pIter;
+    RTListForEach(&pDevice->listCOAStreamOutput, pIter, VBOXDXKMRESOURCE, co.nodeAllocationsChain)
     {
         if (vboxDXCOABlockAlloc(pIter, pShader->gs.cbOutputStreamDecls, &pShader->gs.offStreamOutputDecls))
@@ -1904 +1893 @@
     D3DDDICB_LOCK ddiLock;
     RT_ZERO(ddiLock);
-    ddiLock.hAllocation = pShader->gs.pCOAllocation->hCOAllocation;
+    ddiLock.hAllocation = vboxDXGetAllocation(pShader->gs.pCOAllocation);
     ddiLock.Flags.WriteOnly = 1;
     HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -1927 +1916 @@
         D3DDDICB_UNLOCK ddiUnlock;
         ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &pShader->gs.pCOAllocation->hCOAllocation;
+        ddiUnlock.phAllocations = &ddiLock.hAllocation;
         hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
     }
     AssertReturnVoidStmt(SUCCEEDED(hr),
-                         vboxDXHandleFree(pDevice->hHTShader, &pShader->uShaderId);
+                         vboxDXHandleFree(pDevice->hHTStreamOutput, &pShader->gs.uStreamOutputId);
                          vboxDXDeviceSetError(pDevice, hr));
 
@@ -1937 +1926 @@
     vgpu10DefineStreamOutputWithMob(pDevice, pShader->gs.uStreamOutputId, pShader->gs.NumEntries, pShader->gs.NumStrides,
                                     pShader->gs.BufferStridesInBytes, pShader->gs.RasterizedStream);
-    vgpu10BindStreamOutput(pDevice, pShader->gs.uStreamOutputId, pShader->gs.pCOAllocation->hCOAllocation,
+    vgpu10BindStreamOutput(pDevice, pShader->gs.uStreamOutputId, pShader->gs.pCOAllocation,
                            pShader->gs.offStreamOutputDecls, pShader->gs.cbOutputStreamDecls);
 }
@@ -2054 +2043 @@
     pQuery->pCOAllocation = NULL;
     uint32_t const cbAlloc = (pQuery->Query != D3D10DDI_QUERY_EVENT ? sizeof(uint32_t) : 0) + pQueryInfo->cbDataSvga;
-    PVBOXDXCOALLOCATION pIter;
-    RTListForEach(&pDevice->listCOAQuery, pIter, VBOXDXCOALLOCATION, nodeAllocationsChain)
+    PVBOXDXKMRESOURCE pIter;
+    RTListForEach(&pDevice->listCOAQuery, pIter, VBOXDXKMRESOURCE, co.nodeAllocationsChain)
     {
         if (vboxDXCOABlockAlloc(pIter, cbAlloc, &pQuery->offQuery))
@@ -2082 +2071 @@
         D3DDDICB_LOCK ddiLock;
         RT_ZERO(ddiLock);
-        ddiLock.hAllocation = pQuery->pCOAllocation->hCOAllocation;
+        ddiLock.hAllocation = vboxDXGetAllocation(pQuery->pCOAllocation);
         ddiLock.Flags.WriteOnly = 1;
         HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -2091 +2080 @@
             D3DDDICB_UNLOCK ddiUnlock;
             ddiUnlock.NumAllocations = 1;
-            ddiUnlock.phAllocations = &pQuery->pCOAllocation->hCOAllocation;
+            ddiUnlock.phAllocations = &ddiLock.hAllocation;
             hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
         }
@@ -2097 +2086 @@
 
         vgpu10DefineQuery(pDevice, pQuery->uQueryId, pQuery->svga.queryType, pQuery->svga.flags);
-        vgpu10BindQuery(pDevice, pQuery->uQueryId, pQuery->pCOAllocation->hCOAllocation);
+        vgpu10BindQuery(pDevice, pQuery->uQueryId, pQuery->pCOAllocation);
         vgpu10SetQueryOffset(pDevice, pQuery->uQueryId, pQuery->offQuery);
     }
@@ -2145 +2134 @@
     {
         pQuery->u64Value = ASMAtomicIncU64(&pDevice->u64MobFenceValue);
-        vgpu10MobFence64(pDevice, pQuery->u64Value, pQuery->pCOAllocation->hCOAllocation, pQuery->offQuery);
+        vgpu10MobFence64(pDevice, pQuery->u64Value, pQuery->pCOAllocation, pQuery->offQuery);
         return;
     }
@@ -2166 +2155 @@
         D3DDDICB_LOCK ddiLock;
         RT_ZERO(ddiLock);
-        ddiLock.hAllocation = pQuery->pCOAllocation->hCOAllocation;
+        ddiLock.hAllocation = vboxDXGetAllocation(pQuery->pCOAllocation);
         ddiLock.Flags.ReadOnly = 1;
         HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -2175 +2164 @@
             D3DDDICB_UNLOCK ddiUnlock;
             ddiUnlock.NumAllocations = 1;
-            ddiUnlock.phAllocations = &pQuery->pCOAllocation->hCOAllocation;
+            ddiUnlock.phAllocations = &ddiLock.hAllocation;
             hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
         }
@@ -2204 +2193 @@
     D3DDDICB_LOCK ddiLock;
     RT_ZERO(ddiLock);
-    ddiLock.hAllocation = pQuery->pCOAllocation->hCOAllocation;
+    ddiLock.hAllocation = vboxDXGetAllocation(pQuery->pCOAllocation);
     ddiLock.Flags.ReadOnly = 1;
     HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -2216 +2205 @@
         D3DDDICB_UNLOCK ddiUnlock;
         ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &pQuery->pCOAllocation->hCOAllocation;
+        ddiUnlock.phAllocations = &ddiLock.hAllocation;
         hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
     }
@@ -2383 +2372 @@
 
 void vboxDXSoSetTargets(PVBOXDX_DEVICE pDevice, uint32_t NumTargets,
-                        D3DKMT_HANDLE *paAllocations, uint32_t *paOffsets, uint32_t *paSizes)
-{
-    vgpu10SoSetTargets(pDevice, NumTargets, paAllocations, paOffsets, paSizes);
+                        PVBOXDXKMRESOURCE *papKMResources, uint32_t *paOffsets, uint32_t *paSizes)
+{
+    vgpu10SoSetTargets(pDevice, NumTargets, papKMResources, paOffsets, paSizes);
 }
 
@@ -2397 +2386 @@
                      || pDstResource->Usage == D3D10_DDI_USAGE_STAGING,
                      vboxDXDeviceSetError(pDevice, E_INVALIDARG), false);
+
+    VBOXDXALLOCATIONDESC const *pDstAllocationDesc = vboxDXGetAllocationDesc(pDstResource);
+    AssertReturn(pDstAllocationDesc, false);
 
     SVGA3dBox destBox;
@@ -2410 +2402 @@
     else
     {
-        vboxDXGetSubresourceBox(pDstResource, DstSubresource, &destBox);
+        vboxDXGetSubresourceBox(pDstAllocationDesc, DstSubresource, &destBox);
     }
 
@@ -2417 +2409 @@
     uint32_t cRows;
     uint32_t Depth;
-    vboxDXGetResourceBoxDimensions(pDstResource, DstSubresource, &destBox, &offPixel, &cbRow, &cRows, &Depth);
+    vboxDXGetResourceBoxDimensions(pDstAllocationDesc, DstSubresource, &destBox, &offPixel, &cbRow, &cRows, &Depth);
 
     UINT DstRowPitch;
     UINT DstDepthPitch;
-    vboxDXGetSubresourcePitch(pDstResource, DstSubresource, &DstRowPitch, &DstDepthPitch);
+    vboxDXGetSubresourcePitch(pDstAllocationDesc, DstSubresource, &DstRowPitch, &DstDepthPitch);
 
     /* The allocation contains all subresources, so get subresource offset too. */
-    offPixel += vboxDXGetSubresourceOffset(pDstResource, DstSubresource);
-    //uint32_t const cbSubresource = vboxDXGetSubresourceSize(pDstResource, DstSubresource);
+    offPixel += vboxDXGetSubresourceOffset(pDstAllocationDesc, DstSubresource);
+    //uint32_t const cbSubresource = vboxDXGetSubresourceSize(pDstAllocationDesc, DstSubresource);
 
     D3DDDICB_LOCK ddiLock;
@@ -2446 +2438 @@
         }
 
-        D3DKMT_HANDLE const hAllocation = vboxDXGetAllocation(pDstResource);
-
         D3DDDICB_UNLOCK ddiUnlock;
         ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &hAllocation;
+        ddiUnlock.phAllocations = &ddiLock.hAllocation;
         hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
         if (SUCCEEDED(hr))
@@ -2456 +2446 @@
             /* Inform the host that the resource has been updated. */
             SVGA3dBox box;
-            vboxDXGetSubresourceBox(pDstResource, DstSubresource, &box);
-            vgpu10UpdateSubResource(pDevice, vboxDXGetAllocation(pDstResource), DstSubresource, &box);
+            vboxDXGetSubresourceBox(pDstAllocationDesc, DstSubresource, &box);
+            vgpu10UpdateSubResource(pDevice, vboxDXGetKMResource(pDstResource), DstSubresource, &box);
             return true;
         }
@@ -2490 +2480 @@
         }
 
-        D3DKMT_HANDLE const hAllocation = vboxDXGetAllocation(pBuffer);
-
         D3DDDICB_UNLOCK ddiUnlock;
         ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &hAllocation;
+        ddiUnlock.phAllocations = &ddiLock.hAllocation;
         hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
         if (SUCCEEDED(hr))
@@ -2538 +2526 @@
 
     pStagingResource->hRTResource.handle = 0; /* This resource has not been created by D3D runtime. */
-    int rc = vboxDXInitResourceData(pStagingResource, &createResource);
-    if (RT_SUCCESS(rc))
-    {
-        if (vboxDXCreateResource(pDevice, pStagingResource, &createResource))
-            return pStagingResource;
-    }
+    if (vboxDXCreateResource(pDevice, pStagingResource, &createResource))
+        return pStagingResource;
+
     RTMemFree(pStagingResource);
     vboxDXDeviceSetError(pDevice, E_OUTOFMEMORY);
@@ -2601 +2586 @@
      */
 
+    VBOXDXALLOCATIONDESC const *pDstAllocationDesc = vboxDXGetAllocationDesc(pDstResource);
+    AssertReturnVoid(pDstAllocationDesc);
+
     /*
      * Allocate a staging buffer big enough to hold the entire subresource.
      */
-    uint32_t const cbStagingBuffer = vboxDXGetSubresourceSize(pDstResource, DstSubresource);
+    uint32_t const cbStagingBuffer = vboxDXGetSubresourceSize(pDstAllocationDesc, DstSubresource);
     PVBOXDX_RESOURCE pStagingBuffer = vboxDXCreateStagingBuffer(pDevice, cbStagingBuffer);
     if (!pStagingBuffer)
@@ -2623 +2611 @@
     }
     else
-        vboxDXGetSubresourceBox(pDstResource, DstSubresource, &destBox);
+        vboxDXGetSubresourceBox(pDstAllocationDesc, DstSubresource, &destBox);
 
     uint32_t offPixel;
@@ -2629 +2617 @@
     UINT cRows;
     UINT Depth;
-    vboxDXGetResourceBoxDimensions(pDstResource, DstSubresource, &destBox, &offPixel, &cbRow, &cRows, &Depth);
+    vboxDXGetResourceBoxDimensions(pDstAllocationDesc, DstSubresource, &destBox, &offPixel, &cbRow, &cRows, &Depth);
 
     UINT cbRowPitch;
     UINT cbDepthPitch;
-    vboxDXGetSubresourcePitch(pDstResource, DstSubresource, &cbRowPitch, &cbDepthPitch);
+    vboxDXGetSubresourcePitch(pDstAllocationDesc, DstSubresource, &cbRowPitch, &cbDepthPitch);
 
     if (!vboxDXUpdateStagingBufferUP(pDevice, pStagingBuffer,
@@ -2651 +2639 @@
     box.h = 1;
     box.d = 1;
-    vgpu10UpdateSubResource(pDevice, vboxDXGetAllocation(pStagingBuffer), 0, &box);
+    vgpu10UpdateSubResource(pDevice, vboxDXGetKMResource(pStagingBuffer), 0, &box);
 
     /* Issue SVGA_3D_CMD_DX_TRANSFER_FROM_BUFFER */
@@ -2657 +2645 @@
     uint32 srcPitch = cbRowPitch;
     uint32 srcSlicePitch = cbDepthPitch;
-    vgpu10TransferFromBuffer(pDevice, vboxDXGetAllocation(pStagingBuffer), srcOffset, srcPitch, srcSlicePitch,
-                             vboxDXGetAllocation(pDstResource), DstSubresource, destBox);
-
-    RTListPrepend(&pDevice->listStagingResources, &pStagingBuffer->pKMResource->nodeStaging);
+    vgpu10TransferFromBuffer(pDevice, vboxDXGetKMResource(pStagingBuffer), srcOffset, srcPitch, srcSlicePitch,
+                             vboxDXGetKMResource(pDstResource), DstSubresource, destBox);
+
+    RTListPrepend(&pDevice->listStagingResources, &pStagingBuffer->pKMResource->resource.nodeStaging);
 }
 
@@ -2670 +2658 @@
                        D3D10_DDI_MAP DDIMap, UINT Flags, D3D10DDI_MAPPED_SUBRESOURCE *pMappedSubResource)
 {
+    D3DKMT_HANDLE const hAllocation = vboxDXGetAllocation(pResource);
+    AssertReturnVoidStmt(hAllocation, vboxDXDeviceSetError(pDevice, E_INVALIDARG));
+
     /** @todo Need to take into account various variants Dynamic/Staging/ Discard/NoOverwrite, etc. */
     Assert(pResource->uMap == 0); /* Must not be already mapped */
 
-    if (dxIsAllocationInUse(pDevice, vboxDXGetAllocation(pResource)))
+    if (dxIsAllocationInUse(pDevice, hAllocation))
     {
         vboxDXFlush(pDevice, true);
@@ -2687 +2678 @@
     if (DDIMap == D3D10_DDI_MAP_READ || DDIMap == D3D10_DDI_MAP_READWRITE)
     {
-        vgpu10ReadbackSubResource(pDevice, vboxDXGetAllocation(pResource), Subresource);
+        vgpu10ReadbackSubResource(pDevice, vboxDXGetKMResource(pResource), Subresource);
         vboxDXFlush(pDevice, true);
         /* DXGK now knows that the allocation is in use. So pfnLockCb waits until the data is ready. */
@@ -2697 +2688 @@
     {
         RT_ZERO(ddiLock);
-        ddiLock.hAllocation = vboxDXGetAllocation(pResource);
+        ddiLock.hAllocation = hAllocation;
         ddiLock.Flags.ReadOnly =   DDIMap == D3D10_DDI_MAP_READ;
         ddiLock.Flags.WriteOnly =  DDIMap == D3D10_DDI_MAP_WRITE
@@ -2727 +2718 @@
             pResource->pKMResource->hAllocation = ddiLock.hAllocation;
 
-        uint32_t const offSubresource = vboxDXGetSubresourceOffset(pResource, Subresource);
+        VBOXDXALLOCATIONDESC const *pAllocationDesc = vboxDXGetAllocationDesc(pResource);
+
+        uint32_t const offSubresource = vboxDXGetSubresourceOffset(pAllocationDesc, Subresource);
         pMappedSubResource->pData = (uint8_t *)ddiLock.pData + offSubresource;
-        vboxDXGetSubresourcePitch(pResource, Subresource, &pMappedSubResource->RowPitch, &pMappedSubResource->DepthPitch);
+        vboxDXGetSubresourcePitch(pAllocationDesc, Subresource, &pMappedSubResource->RowPitch, &pMappedSubResource->DepthPitch);
 
         pResource->DDIMap = DDIMap;
@@ -2741 +2734 @@
 {
     D3DKMT_HANDLE const hAllocation = vboxDXGetAllocation(pResource);
+    AssertReturnVoidStmt(hAllocation, vboxDXDeviceSetError(pDevice, E_INVALIDARG));
 
     D3DDDICB_UNLOCK ddiUnlock;
@@ -2754 +2748 @@
             /* Inform the host that the resource has been updated. */
             SVGA3dBox box;
-            vboxDXGetSubresourceBox(pResource, Subresource, &box);
-            vgpu10UpdateSubResource(pDevice, vboxDXGetAllocation(pResource), Subresource, &box);
+            vboxDXGetSubresourceBox(vboxDXGetAllocationDesc(pResource), Subresource, &box);
+            vgpu10UpdateSubResource(pDevice, vboxDXGetKMResource(pResource), Subresource, &box);
         }
 
@@ -2831 +2825 @@
     }
 
-    vgpu10DefineShaderResourceView(pDevice, pShaderResourceView->uShaderResourceViewId, vboxDXGetAllocation(pShaderResourceView->pResource),
+    vgpu10DefineShaderResourceView(pDevice, pShaderResourceView->uShaderResourceViewId, vboxDXGetKMResource(pShaderResourceView->pResource),
                                    pShaderResourceView->svga.format, pShaderResourceView->svga.resourceDimension,
                                    &pShaderResourceView->svga.desc);
@@ -2896 +2890 @@
     }
 
-    vgpu10DefineRenderTargetView(pDevice, pRenderTargetView->uRenderTargetViewId, vboxDXGetAllocation(pRenderTargetView->pResource),
+    vgpu10DefineRenderTargetView(pDevice, pRenderTargetView->uRenderTargetViewId, vboxDXGetKMResource(pRenderTargetView->pResource),
                                  pRenderTargetView->svga.format, pRenderTargetView->svga.resourceDimension,
                                  &pRenderTargetView->svga.desc);
@@ -2965 +2959 @@
     pDepthStencilView->svga.flags = pDepthStencilView->Flags;
 
-    vgpu10DefineDepthStencilView(pDevice, pDepthStencilView->uDepthStencilViewId, vboxDXGetAllocation(pDepthStencilView->pResource),
+    vgpu10DefineDepthStencilView(pDevice, pDepthStencilView->uDepthStencilViewId, vboxDXGetKMResource(pDepthStencilView->pResource),
                                  pDepthStencilView->svga.format, pDepthStencilView->svga.resourceDimension,
                                  pDepthStencilView->svga.mipSlice, pDepthStencilView->svga.firstArraySlice,
@@ -3082 +3076 @@
         if (pResource)
         {
-            uint32_t const cMaxConstants = pResource->AllocationDesc.cbAllocation / (4 * sizeof(UINT));
+            uint32_t const cMaxConstants = pResource->pKMResource->AllocationDesc.cbAllocation / (4 * sizeof(UINT));
             uint32_t const FirstConstant = pFirstConstant ? pFirstConstant[i] : 0;
             uint32_t NumConstants = pNumConstants ? pNumConstants[i] : cMaxConstants;
@@ -3102 +3096 @@
         LogFunc(("type %d, slot %d, first %d, num %d, cbAllocation %d",
                  enmShaderType, StartSlot + i, pCBS->aFirstConstant[StartSlot + i], pCBS->aNumConstants[StartSlot + i],
-                 pResource ? pResource->AllocationDesc.cbAllocation : -1));
+                 pResource ? pResource->pKMResource->AllocationDesc.cbAllocation : -1));
     }
 
@@ -3139 +3133 @@
     else
     {
-        vboxDXGetSubresourceBox(pSrcResource, SrcSubresource, &srcBox);
-    }
-
-    vgpu10ResourceCopyRegion(pDevice, vboxDXGetAllocation(pDstResource), DstSubresource,
-                              DstX, DstY, DstZ, vboxDXGetAllocation(pSrcResource), SrcSubresource, srcBox);
+        vboxDXGetSubresourceBox(vboxDXGetAllocationDesc(pSrcResource), SrcSubresource, &srcBox);
+    }
+
+    vgpu10ResourceCopyRegion(pDevice, vboxDXGetKMResource(pDstResource), DstSubresource,
+                              DstX, DstY, DstZ, vboxDXGetKMResource(pSrcResource), SrcSubresource, srcBox);
 }
 
@@ -3149 +3143 @@
 void vboxDXResourceCopy(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pDstResource, PVBOXDX_RESOURCE pSrcResource)
 {
-    vgpu10ResourceCopy(pDevice, vboxDXGetAllocation(pDstResource), vboxDXGetAllocation(pSrcResource));
+    vgpu10ResourceCopy(pDevice, vboxDXGetKMResource(pDstResource), vboxDXGetKMResource(pSrcResource));
 }
 
@@ -3157 +3151 @@
 {
     SVGA3dSurfaceFormat const copyFormat = vboxDXDxgiToSvgaFormat(ResolveFormat);
-    vgpu10ResolveCopy(pDevice, vboxDXGetAllocation(pDstResource), DstSubresource,
-                      vboxDXGetAllocation(pSrcResource), SrcSubresource, copyFormat);
+    vgpu10ResolveCopy(pDevice, vboxDXGetKMResource(pDstResource), DstSubresource,
+                      vboxDXGetKMResource(pSrcResource), SrcSubresource, copyFormat);
 }
 
@@ -3243 +3237 @@
         if (!pShaderResourceView->fDefined)
         {
-            vgpu10DefineShaderResourceView(pDevice, pShaderResourceView->uShaderResourceViewId, vboxDXGetAllocation(pShaderResourceView->pResource),
+            vgpu10DefineShaderResourceView(pDevice, pShaderResourceView->uShaderResourceViewId, vboxDXGetKMResource(pShaderResourceView->pResource),
                                            pShaderResourceView->svga.format, pShaderResourceView->svga.resourceDimension,
                                            &pShaderResourceView->svga.desc);
@@ -3255 +3249 @@
         if (!pRenderTargetView->fDefined)
         {
-            vgpu10DefineRenderTargetView(pDevice, pRenderTargetView->uRenderTargetViewId, vboxDXGetAllocation(pRenderTargetView->pResource),
+            vgpu10DefineRenderTargetView(pDevice, pRenderTargetView->uRenderTargetViewId, vboxDXGetKMResource(pRenderTargetView->pResource),
                                          pRenderTargetView->svga.format, pRenderTargetView->svga.resourceDimension,
                                          &pRenderTargetView->svga.desc);
@@ -3267 +3261 @@
         if (!pDepthStencilView->fDefined)
         {
-            vgpu10DefineDepthStencilView(pDevice, pDepthStencilView->uDepthStencilViewId, vboxDXGetAllocation(pDepthStencilView->pResource),
+            vgpu10DefineDepthStencilView(pDevice, pDepthStencilView->uDepthStencilViewId, vboxDXGetKMResource(pDepthStencilView->pResource),
                                          pDepthStencilView->svga.format, pDepthStencilView->svga.resourceDimension,
                                          pDepthStencilView->svga.mipSlice, pDepthStencilView->svga.firstArraySlice,
@@ -3280 +3274 @@
         if (!pUnorderedAccessView->fDefined)
         {
-            vgpu10DefineUAView(pDevice, pUnorderedAccessView->uUnorderedAccessViewId, vboxDXGetAllocation(pUnorderedAccessView->pResource),
+            vgpu10DefineUAView(pDevice, pUnorderedAccessView->uUnorderedAccessViewId, vboxDXGetKMResource(pUnorderedAccessView->pResource),
                                pUnorderedAccessView->svga.format, pUnorderedAccessView->svga.resourceDimension,
                                pUnorderedAccessView->svga.desc);
@@ -3293 +3287 @@
         {
             vgpu10DefineVideoDecoderOutputView(pDevice, pVDOV->uVideoDecoderOutputViewId,
-                                               vboxDXGetAllocation(pVDOV->pResource),
+                                               vboxDXGetKMResource(pVDOV->pResource),
                                                pVDOV->svga.desc);
             pVDOV->fDefined = true;
@@ -3305 +3299 @@
         {
             vgpu10DefineVideoProcessorInputView(pDevice, pVPIV->uVideoProcessorInputViewId,
-                                                vboxDXGetAllocation(pVPIV->pResource),
+                                                vboxDXGetKMResource(pVPIV->pResource),
                                                 pVPIV->svga.ContentDesc, pVPIV->svga.VPIVDesc);
             pVPIV->fDefined = true;
@@ -3317 +3311 @@
         {
             vgpu10DefineVideoProcessorOutputView(pDevice, pVPOV->uVideoProcessorOutputViewId,
-                                                 vboxDXGetAllocation(pVPOV->pResource),
+                                                 vboxDXGetKMResource(pVPOV->pResource),
                                                  pVPOV->svga.ContentDesc, pVPOV->svga.VPOVDesc);
             pVPOV->fDefined = true;
@@ -3594 +3588 @@
     }
 
-    vgpu10DefineUAView(pDevice, pUnorderedAccessView->uUnorderedAccessViewId, vboxDXGetAllocation(pUnorderedAccessView->pResource),
+    vgpu10DefineUAView(pDevice, pUnorderedAccessView->uUnorderedAccessViewId, vboxDXGetKMResource(pUnorderedAccessView->pResource),
                        pUnorderedAccessView->svga.format, pUnorderedAccessView->svga.resourceDimension,
                        pUnorderedAccessView->svga.desc);
@@ -3681 +3675 @@
 {
     vboxDXSetupPipeline(pDevice);
-    vgpu10DispatchIndirect(pDevice, vboxDXGetAllocation(pResource), AlignedByteOffsetForArgs);
+    vgpu10DispatchIndirect(pDevice, vboxDXGetKMResource(pResource), AlignedByteOffsetForArgs);
 }
 
@@ -3687 +3681 @@
 void vboxDXCopyStructureCount(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pDstBuffer, UINT DstAlignedByteOffset, PVBOXDXUNORDEREDACCESSVIEW pSrcView)
 {
-    vgpu10CopyStructureCount(pDevice, pSrcView->uUnorderedAccessViewId, vboxDXGetAllocation(pDstBuffer), DstAlignedByteOffset);
+    vgpu10CopyStructureCount(pDevice, pSrcView->uUnorderedAccessViewId, vboxDXGetKMResource(pDstBuffer), DstAlignedByteOffset);
 }
 
@@ -3700 +3694 @@
 
     SVGA3dBox boxSrc;
-    vboxDXGetSubresourceBox(pSrcResource, SrcSubresource, &boxSrc); /* Entire subresource. */
+    vboxDXGetSubresourceBox(vboxDXGetAllocationDesc(pSrcResource), SrcSubresource, &boxSrc); /* Entire subresource. */
 
     SVGA3dBox boxDest;
@@ -3712 +3706 @@
     SVGA3dDXPresentBltMode mode = 0;
 
-    vgpu10PresentBlt(pDevice, vboxDXGetAllocation(pSrcResource), SrcSubresource, vboxDXGetAllocation(pDstResource), DstSubresource,
+    vgpu10PresentBlt(pDevice, vboxDXGetKMResource(pSrcResource), SrcSubresource, vboxDXGetKMResource(pDstResource), DstSubresource,
                      boxSrc, boxDest, mode);
     return S_OK;
@@ -3749 +3743 @@
     /* Move staging resources to the deferred destruction queue. */
     PVBOXDXKMRESOURCE pKMResource, pNextKMResource;
-    RTListForEachSafe(&pDevice->listStagingResources, pKMResource, pNextKMResource, VBOXDXKMRESOURCE, nodeStaging)
-    {
-        RTListNodeRemove(&pKMResource->nodeStaging);
-
-        PVBOXDX_RESOURCE pStagingResource = pKMResource->pResource;
-        pKMResource->pResource = NULL;
+    RTListForEachSafe(&pDevice->listStagingResources, pKMResource, pNextKMResource, VBOXDXKMRESOURCE, resource.nodeStaging)
+    {
+        RTListNodeRemove(&pKMResource->resource.nodeStaging);
+
+        PVBOXDX_RESOURCE pStagingResource = pKMResource->resource.pResource;
+        pKMResource->resource.pResource = NULL;
 
         Assert(pStagingResource->pKMResource == pKMResource);
@@ -3774 +3768 @@
     {
         RTListNodeRemove(&pKMResource->nodeResource);
-
-        D3DDDICB_DEALLOCATE ddiDeallocate;
-        RT_ZERO(ddiDeallocate);
-        //ddiDeallocate.hResource      = NULL;
-        ddiDeallocate.NumAllocations = 1;
-        ddiDeallocate.HandleList     = &pKMResource->hAllocation;
-
-        HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
-        LogFlowFunc(("pfnDeallocateCb returned %d", hr));
-        AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
-
-        RTMemFree(pKMResource);
+        vboxDXDeallocateKMResource(pDevice, pKMResource);
     }
 }
@@ -4065 +4048 @@
     PVBOXDXKMRESOURCE pKMResource, pNextKMResource;
     RTListForEachSafe(&pDevice->listResources, pKMResource, pNextKMResource, VBOXDXKMRESOURCE, nodeResource)
-        vboxDXDestroyResource(pDevice, pKMResource->pResource);
+    {
+        if (pKMResource->AllocationDesc.enmAllocationType == VBOXDXALLOCATIONTYPE_SURFACE)
+            vboxDXDestroyResource(pDevice, pKMResource->resource.pResource);
+    }
 
     dxDestroyDeferredResources(pDevice);
@@ -4077 +4063 @@
         vboxDXDestroyQuery(pDevice, pQuery);
 
-    PVBOXDXCOALLOCATION pCOA, pNextCOA;
-    RTListForEachSafe(&pDevice->listCOAQuery, pCOA, pNextCOA, VBOXDXCOALLOCATION, nodeAllocationsChain)
+    PVBOXDXKMRESOURCE pCOA, pNextCOA;
+    RTListForEachSafe(&pDevice->listCOAQuery, pCOA, pNextCOA, VBOXDXKMRESOURCE, co.nodeAllocationsChain)
         vboxDXDestroyCOAllocation(pDevice, pCOA);
-    RTListForEachSafe(&pDevice->listCOAStreamOutput, pCOA, pNextCOA, VBOXDXCOALLOCATION, nodeAllocationsChain)
+    RTListForEachSafe(&pDevice->listCOAStreamOutput, pCOA, pNextCOA, VBOXDXKMRESOURCE, co.nodeAllocationsChain)
         vboxDXDestroyCOAllocation(pDevice, pCOA);
 
-    if (pDevice->hShaderAllocation)
-    {
-        D3DDDICB_DEALLOCATE ddiDeallocate;
-        RT_ZERO(ddiDeallocate);
-        ddiDeallocate.NumAllocations = 1;
-        ddiDeallocate.HandleList     = &pDevice->hShaderAllocation;
-
-        HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
-        LogFlowFunc(("pfnDeallocateCb returned %d", hr));
-        AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
-
-        pDevice->hShaderAllocation = 0;
+    if (pDevice->pShadersKMResource)
+    {
+        RTListNodeRemove(&pDevice->pShadersKMResource->nodeResource);
+        vboxDXDeallocateKMResource(pDevice, pDevice->pShadersKMResource);
+        pDevice->pShadersKMResource = 0;
     }
 

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDX.h

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2011-2024 Oracle and/or its affiliates.
+ * Copyright (C) 2011-2025 Oracle and/or its affiliates.
  *
  * This file is part of VirtualBox base platform packages, as
@@ -117 +117 @@
 
 /*
- * A Context Object Allocation holds up to VBOXDX_COALLOCATION_MAX_OBJECTS objects (queries, etc)
+ * A Context Object Allocation (COA) holds up to VBOXDX_COALLOCATION_MAX_OBJECTS objects (queries, etc)
  */
 #define VBOXDX_COALLOCATION_MAX_OBJECTS (64)                /* Use a 64 bit field as free bitmap. */
-typedef struct VBOXDXCOALLOCATION                           /* Allocation for context objects (query, etc). */
-{
-    RTLISTNODE                  nodeAllocationsChain;       /* Allocations can be chained. */
-    D3DKMT_HANDLE               hCOAllocation;              /* Allocation handle. */
-    uint32_t                    cbAllocation;               /* Size of this allocation. */
-    uint64_t                    u64Bitmap;                  /* Bitmap of allocated blocks. */
-    uint32_t                    aOffset[VBOXDX_COALLOCATION_MAX_OBJECTS]; /* Start offsets of blocks. */
-} VBOXDXCOALLOCATION, *PVBOXDXCOALLOCATION;
+
+/*
+ * This structure is allocated by the driver. It is used for accounting of allocations
+ * and for storing information which might be needed after the resource is destroyed by D3D runtime.
+ * KM stands for Kernel Mode.
+ */
+typedef struct VBOXDXKMRESOURCE
+{
+    RTLISTNODE                     nodeResource;            /* VBOXDX_DEVICE::listResources, listDestroyedResources. */
+    D3DKMT_HANDLE                  hAllocation;
+    struct
+    {
+        uint32_t                   fOpened : 1;
+        uint32_t                   fReserved : 31;
+    } flags;
+    VBOXDXALLOCATIONDESC           AllocationDesc;
+    union
+    {
+        struct /* D3D resource */
+        {
+            struct VBOXDX_RESOURCE *pResource;              /* The structure allocated by D3D runtime. */
+            RTLISTNODE             nodeStaging;             /* VBOXDX_DEVICE::listStagingResources if this resource is a staging buffer. */
+        } resource;
+        struct /* Context object allocation */
+        {
+            RTLISTNODE             nodeAllocationsChain;    /* CO allocations can be chained. */
+            uint64_t               u64Bitmap;               /* Bitmap of allocated blocks. */
+            uint32_t               aOffset[VBOXDX_COALLOCATION_MAX_OBJECTS]; /* Start offsets of blocks. */
+        } co;
+    };
+} VBOXDXKMRESOURCE, *PVBOXDXKMRESOURCE;
 
 typedef struct VBOXDXSHADER
@@ -149 +172 @@
         uint32_t                offStreamOutputDecls;       /* Offset of the declarations in the CO allocation. */
         uint32_t                cbOutputStreamDecls;
-        PVBOXDXCOALLOCATION     pCOAllocation;
+        PVBOXDXKMRESOURCE       pCOAllocation;
     } gs;                                                   /* For GS. */
     /* shader bytecode */
@@ -179 +202 @@
     uint32_t                    uQueryId;
     uint32_t                    offQuery;                   /* Offset of the query in the query allocation. */
-    PVBOXDXCOALLOCATION         pCOAllocation;
+    PVBOXDXKMRESOURCE           pCOAllocation;
     uint64_t u64Value;
     /* Result for queries in SIGNALED state. */
 } VBOXDXQUERY, *PVBOXDXQUERY;
 
-/*
- * This structure is allocated by the driver. It is used for accounting of resources
- * and for storing information which might be needed after the resource is destroyed by runtime.
- * KM stands for Kernel Mode.
- */
-typedef struct VBOXDXKMRESOURCE
-{
-    RTLISTNODE                  nodeResource;               /* VBOXDX_DEVICE::listResources, listDestroyedResources. */
-    struct VBOXDX_RESOURCE     *pResource;                  /* The structure allocated by D3D runtime. */
-    D3DKMT_HANDLE               hAllocation;
-    RTLISTNODE                  nodeStaging;                /* VBOXDX_DEVICE::listStagingResources if this resource is a staging buffer. */
-} VBOXDXKMRESOURCE, *PVBOXDXKMRESOURCE;
-
 typedef struct VBOXDX_RESOURCE
 {
     PVBOXDXKMRESOURCE              pKMResource;
-    //RTLISTNODE                     nodeResource;            /* VBOXDX_DEVICE::listResources. */
     D3D10DDI_HRTRESOURCE           hRTResource;
     D3D10DDIRESOURCE_TYPE          ResourceDimension;
     D3D10_DDI_RESOURCE_USAGE       Usage;
-    VBOXDXALLOCATIONDESC           AllocationDesc;
     UINT                           cSubresources;
     union
@@ -581 +589 @@
 
     /* Shaders */
-    D3DKMT_HANDLE               hShaderAllocation;          /* Shader allocation for this context. */
-    uint32_t                    cbShaderAllocation;         /* Size of the shader's allocation: SVGA3D_MAX_SHADER_MEMORY_BYTES. */
+    PVBOXDXKMRESOURCE           pShadersKMResource;         /* Shader's allocation: SVGA3D_MAX_SHADER_MEMORY_BYTES. */
     uint32_t                    cbShaderAvailable;          /* How many bytes is free in the shader's allocation. */
     uint32_t                    offShaderFree;              /* Offset of the next free byte in the shader's allocation. */
@@ -589 +596 @@
     /* Queries */
     RTLISTANCHOR                listQueries;                /* All queries of this device, to be able to repack them in the allocation. */
-    RTLISTANCHOR                listCOAQuery;               /* List of VBOXDXCOALLOCATION for all query types. */
+    RTLISTANCHOR                listCOAQuery;               /* List of COA VBOXDXKMRESOURCEs for all query types. */
     uint64_t volatile           u64MobFenceValue;
 
     /* Stream output declarations */
-    RTLISTANCHOR                listCOAStreamOutput;        /* List of VBOXDXCOALLOCATION for stream output declarations. */
+    RTLISTANCHOR                listCOAStreamOutput;        /* List of COA VBOXDXKMRESOURCEs for stream output declarations. */
 
     /* Pipeline state. */
@@ -614 +621 @@
     struct
     {
-        D3DKMT_HANDLE           hAllocation;                /* For querying capabilities of the host device. */
-        uint32_t                cbAllocation;
+        PVBOXDXKMRESOURCE       pKMResource;                /* For querying capabilities of the host device. */
         uint64_t volatile       u64MobFenceValue;           /* Fence value for host queries. */
 
@@ -645 +651 @@
 void vboxDXCommandBufferCommit(PVBOXDX_DEVICE pDevice);
 
-void vboxDXStorePatchLocation(PVBOXDX_DEVICE pDevice, void *pvPatch, VBOXDXALLOCATIONTYPE enmAllocationType,
-                              D3DKMT_HANDLE hAllocation, uint32_t offAllocation, bool fWriteOperation);
+void vboxDXStorePatchLocation(PVBOXDX_DEVICE pDevice, void *pvPatch, PVBOXDXKMRESOURCE pKMResource,
+                              uint32_t offAllocation, bool fWriteOperation);
+
+typedef void FNVBOXDXINITALLOCATIONDESC(VBOXDXALLOCATIONDESC *pDesc, void const *pvInitData);
+typedef FNVBOXDXINITALLOCATIONDESC *PFNVBOXDXINITALLOCATIONDESC;
+PVBOXDXKMRESOURCE vboxDXAllocateKMResource(PVBOXDX_DEVICE pDevice, HANDLE hResource,
+                                           PFNVBOXDXINITALLOCATIONDESC pfnInitAllocationDesc,
+                                           void const *pvInitData, bool fZero);
+void vboxDXDeallocateKMResource(PVBOXDX_DEVICE pDevice, PVBOXDXKMRESOURCE pKMResource);
 
 SVGA3dSurfaceFormat vboxDXDxgiToSvgaFormat(DXGI_FORMAT enmDxgiFormat);
 
-int vboxDXInitResourceData(PVBOXDX_RESOURCE pResource, const D3D11DDIARG_CREATERESOURCE *pCreateResource);
 bool vboxDXCreateResource(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pResource,
                           const D3D11DDIARG_CREATERESOURCE *pCreateResource);
@@ -711 +723 @@
                               D3D10_DDI_MAP DDIMap, UINT Flags, D3D10DDI_MAPPED_SUBRESOURCE *pMappedSubResource);
 void vboxDXResourceUnmap(PVBOXDX_DEVICE pDevice, PVBOXDX_RESOURCE pResource, UINT Subresource);
-void vboxDXSoSetTargets(PVBOXDX_DEVICE pDevice, uint32_t NumTargets, D3DKMT_HANDLE *paAllocations, uint32_t *paOffsets, uint32_t *paSizes);
+void vboxDXSoSetTargets(PVBOXDX_DEVICE pDevice, uint32_t NumTargets, PVBOXDXKMRESOURCE *papKMResources, uint32_t *paOffsets, uint32_t *paSizes);
 void vboxDXCreateShaderResourceView(PVBOXDX_DEVICE pDevice, PVBOXDXSHADERRESOURCEVIEW pShaderResourceView);
 void vboxDXGenMips(PVBOXDX_DEVICE pDevice, PVBOXDXSHADERRESOURCEVIEW pShaderResourceView);
@@ -833 +845 @@
 }
 
+DECLINLINE(PVBOXDXKMRESOURCE) vboxDXGetKMResource(PVBOXDX_RESOURCE pResource)
+{
+    return pResource ? pResource->pKMResource : 0;
+}
+
+DECLINLINE(D3DKMT_HANDLE) vboxDXGetAllocation(PVBOXDXKMRESOURCE pKMResource)
+{
+    return pKMResource ? pKMResource->hAllocation : 0;
+}
+
 DECLINLINE(D3DKMT_HANDLE) vboxDXGetAllocation(PVBOXDX_RESOURCE pResource)
 {
-    return pResource ? pResource->pKMResource->hAllocation : 0;
+    return pResource ? vboxDXGetAllocation(pResource->pKMResource) : 0;
 }
 
+DECLINLINE(VBOXDXALLOCATIONDESC *) vboxDXGetAllocationDesc(PVBOXDXKMRESOURCE pKMResource)
+{
+    return pKMResource ? &pKMResource->AllocationDesc : 0;
+}
+
+DECLINLINE(VBOXDXALLOCATIONDESC *) vboxDXGetAllocationDesc(PVBOXDX_RESOURCE pResource)
+{
+    return pResource ? vboxDXGetAllocationDesc(pResource->pKMResource) : 0;
+}
+
 #endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_disp_wddm_dx_VBoxDX_h */

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXCmd.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2022-2024 Oracle and/or its affiliates.
+ * Copyright (C) 2022-2025 Oracle and/or its affiliates.
  *
  * This file is part of VirtualBox base platform packages, as
@@ -656 +656 @@
 int vgpu10BindStreamOutput(PVBOXDX_DEVICE pDevice,
                            SVGA3dStreamOutputId soid,
-                           D3DKMT_HANDLE hAllocation,
+                           PVBOXDXKMRESOURCE pKMResource,
                            uint32 offsetInBytes,
                            uint32 sizeInBytes)
@@ -671 +671 @@
     SET_CMD_FIELD(sizeInBytes);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->mobid, VBOXDXALLOCATIONTYPE_CO,
-                             hAllocation, offsetInBytes, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->mobid, pKMResource,
+                             offsetInBytes, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -712 +712 @@
 int vgpu10BindShader(PVBOXDX_DEVICE pDevice,
                      uint32_t shid,
-                     D3DKMT_HANDLE hAllocation,
+                     PVBOXDXKMRESOURCE pKMResource,
                      uint32_t offsetInBytes)
 {
@@ -726 +726 @@
     SET_CMD_FIELD(offsetInBytes);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->mobid, VBOXDXALLOCATIONTYPE_SHADERS,
-                             hAllocation, offsetInBytes, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->mobid, pKMResource,
+                             offsetInBytes, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -753 +753 @@
                            uint32_t startBuffer,
                            uint32_t numBuffers,
-                           D3DKMT_HANDLE *paAllocations,
+                           PVBOXDXKMRESOURCE *papKMResources,
                            const UINT *paStrides,
                            const UINT *paOffsets)
@@ -773 +773 @@
         pVertexBuffer->stride = paStrides[i];
         pVertexBuffer->offset = paOffsets[i];
-        vboxDXStorePatchLocation(pDevice, &pVertexBuffer->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                                 paAllocations[i], 0, false);
+        vboxDXStorePatchLocation(pDevice, &pVertexBuffer->sid, papKMResources[i],
+                                 0, false);
     }
 
@@ -782 +782 @@
 
 int vgpu10SetIndexBuffer(PVBOXDX_DEVICE pDevice,
-                         D3DKMT_HANDLE hAllocation,
+                         PVBOXDXKMRESOURCE pKMResource,
                          SVGA3dSurfaceFormat format,
                          uint32_t offset)
@@ -795 +795 @@
     SET_CMD_FIELD(format);
     SET_CMD_FIELD(offset);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -804 +804 @@
 int vgpu10SoSetTargets(PVBOXDX_DEVICE pDevice,
                        uint32_t numTargets,
-                       D3DKMT_HANDLE *paAllocations,
+                       PVBOXDXKMRESOURCE *papKMResources,
                        uint32_t *paOffsets,
                        uint32_t *paSizes)
@@ -824 +824 @@
         pSoTarget->offset      = paOffsets[i];
         pSoTarget->sizeInBytes = paSizes[i];
-        vboxDXStorePatchLocation(pDevice, &pSoTarget->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                                 paAllocations[i], 0, true);
+        vboxDXStorePatchLocation(pDevice, &pSoTarget->sid, papKMResources[i],
+                                 0, true);
     }
 
@@ -835 +835 @@
 int vgpu10DefineShaderResourceView(PVBOXDX_DEVICE pDevice,
                                    SVGA3dShaderResourceViewId shaderResourceViewId,
-                                   D3DKMT_HANDLE hAllocation,
+                                   PVBOXDXKMRESOURCE pKMResource,
                                    SVGA3dSurfaceFormat format,
                                    SVGA3dResourceType resourceDimension,
@@ -851 +851 @@
     SET_CMD_FIELD(resourceDimension);
     cmd->desc = *pDesc;
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -893 +893 @@
 int vgpu10DefineRenderTargetView(PVBOXDX_DEVICE pDevice,
                                  SVGA3dRenderTargetViewId renderTargetViewId,
-                                 D3DKMT_HANDLE hAllocation,
+                                 PVBOXDXKMRESOURCE pKMResource,
                                  SVGA3dSurfaceFormat format,
                                  SVGA3dResourceType resourceDimension,
@@ -909 +909 @@
     SET_CMD_FIELD(resourceDimension);
     cmd->desc = *pDesc;
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1026 +1026 @@
 int vgpu10DefineDepthStencilView(PVBOXDX_DEVICE pDevice,
                                  SVGA3dDepthStencilViewId depthStencilViewId,
-                                 D3DKMT_HANDLE hAllocation,
+                                 PVBOXDXKMRESOURCE pKMResource,
                                  SVGA3dSurfaceFormat format,
                                  SVGA3dResourceType resourceDimension,
@@ -1048 +1048 @@
     SET_CMD_FIELD(arraySize);
     SET_CMD_FIELD(flags);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1146 +1146 @@
                                   uint32 slot,
                                   SVGA3dShaderType type,
-                                  D3DKMT_HANDLE hAllocation,
+                                  PVBOXDXKMRESOURCE pKMResource,
                                   uint32 offsetInBytes,
                                   uint32 sizeInBytes)
@@ -1161 +1161 @@
     SET_CMD_FIELD(offsetInBytes);
     SET_CMD_FIELD(sizeInBytes);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1170 +1170 @@
 
 int vgpu10UpdateSubResource(PVBOXDX_DEVICE pDevice,
-                            D3DKMT_HANDLE hAllocation,
+                            PVBOXDXKMRESOURCE pKMResource,
                             uint32 subResource,
                             const SVGA3dBox *pBox)
@@ -1183 +1183 @@
     SET_CMD_FIELD(subResource);
     cmd->box = *pBox;
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1192 +1192 @@
 
 int vgpu10ReadbackSubResource(PVBOXDX_DEVICE pDevice,
-                              D3DKMT_HANDLE hAllocation,
+                              PVBOXDXKMRESOURCE pKMResource,
                               uint32 subResource)
 {
@@ -1207 +1207 @@
      * before getting the allocation data in pfnLockCb.
      */
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1216 +1216 @@
 
 int vgpu10TransferFromBuffer(PVBOXDX_DEVICE pDevice,
-                             D3DKMT_HANDLE hSrcAllocation,
+                             PVBOXDXKMRESOURCE pSrcKMResource,
                              uint32 srcOffset,
                              uint32 srcPitch,
                              uint32 srcSlicePitch,
-                             D3DKMT_HANDLE hDstAllocation,
+                             PVBOXDXKMRESOURCE pDstKMResource,
                              uint32 destSubResource,
                              SVGA3dBox const &destBox)
@@ -1237 +1237 @@
     SET_CMD_FIELD(destSubResource);
     SET_CMD_FIELD(destBox);
-    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hSrcAllocation, 0, false);
-    vboxDXStorePatchLocation(pDevice, &cmd->destSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hDstAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, pSrcKMResource,
+                             0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->destSid, pDstKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1248 +1248 @@
 
 int vgpu10ResourceCopyRegion(PVBOXDX_DEVICE pDevice,
-                             D3DKMT_HANDLE hDstAllocation,
+                             PVBOXDXKMRESOURCE pDstKMResource,
                              uint32 dstSubResource,
                              uint32 dstX,
                              uint32 dstY,
                              uint32 dstZ,
-                             D3DKMT_HANDLE hSrcAllocation,
+                             PVBOXDXKMRESOURCE pSrcKMResource,
                              uint32 srcSubResource,
                              SVGA3dBox const &srcBox)
@@ -1277 +1277 @@
     cmd->box.srcz = srcBox.z;
 
-    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hDstAllocation, 0, true);
-    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hSrcAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, pDstKMResource,
+                             0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, pSrcKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1288 +1288 @@
 
 int vgpu10ResourceCopy(PVBOXDX_DEVICE pDevice,
-                       D3DKMT_HANDLE hDstAllocation,
-                       D3DKMT_HANDLE hSrcAllocation)
+                       PVBOXDXKMRESOURCE pDstKMResource,
+                       PVBOXDXKMRESOURCE pSrcKMResource)
 {
     void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_PRED_COPY,
@@ -1300 +1300 @@
     cmd->srcSid = SVGA3D_INVALID_ID;
 
-    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hDstAllocation, 0, true);
-    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hSrcAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, pDstKMResource,
+                             0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, pSrcKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1311 +1311 @@
 
 int vgpu10ResolveCopy(PVBOXDX_DEVICE pDevice,
-                      D3DKMT_HANDLE hDstAllocation,
+                      PVBOXDXKMRESOURCE pDstKMResource,
                       uint32 dstSubResource,
-                      D3DKMT_HANDLE hSrcAllocation,
+                      PVBOXDXKMRESOURCE pSrcKMResource,
                       uint32 srcSubResource,
                       SVGA3dSurfaceFormat copyFormat)
@@ -1329 +1329 @@
     SET_CMD_FIELD(copyFormat);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hDstAllocation, 0, true);
-    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hSrcAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, pDstKMResource,
+                             0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, pSrcKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1341 +1341 @@
 int vgpu10MobFence64(PVBOXDX_DEVICE pDevice,
                      uint64 value,
-                     D3DKMT_HANDLE hAllocation,
+                     PVBOXDXKMRESOURCE pKMResource,
                      uint32 mobOffset)
 {
@@ -1354 +1354 @@
     SET_CMD_FIELD(mobOffset);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->mobId, VBOXDXALLOCATIONTYPE_CO,
-                             hAllocation, mobOffset, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->mobId, pKMResource,
+                             mobOffset, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1400 +1400 @@
 int vgpu10BindQuery(PVBOXDX_DEVICE pDevice,
                     SVGA3dQueryId queryId,
-                    D3DKMT_HANDLE hAllocation)
+                    PVBOXDXKMRESOURCE pKMResource)
 {
     void *pvCmd = vboxDXCommandBufferReserve(pDevice, SVGA_3D_CMD_DX_BIND_QUERY,
@@ -1411 +1411 @@
     cmd->mobid = SVGA3D_INVALID_ID;
 
-    vboxDXStorePatchLocation(pDevice, &cmd->mobid, VBOXDXALLOCATIONTYPE_CO,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->mobid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1505 +1505 @@
 int vgpu10DefineUAView(PVBOXDX_DEVICE pDevice,
                        SVGA3dUAViewId uaViewId,
-                       D3DKMT_HANDLE hAllocation,
+                       PVBOXDXKMRESOURCE pKMResource,
                        SVGA3dSurfaceFormat format,
                        SVGA3dResourceType resourceDimension,
@@ -1521 +1521 @@
     SET_CMD_FIELD(resourceDimension);
     SET_CMD_FIELD(desc);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1666 +1666 @@
 
 int vgpu10DispatchIndirect(PVBOXDX_DEVICE pDevice,
-                           D3DKMT_HANDLE hAllocation,
+                           PVBOXDXKMRESOURCE pKMResource,
                            uint32 byteOffsetForArgs)
 {
@@ -1678 +1678 @@
     SET_CMD_FIELD(byteOffsetForArgs);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->argsBufferSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->argsBufferSid, pKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1687 +1687 @@
 
 int vgpu10DrawIndexedInstancedIndirect(PVBOXDX_DEVICE pDevice,
-                                       D3DKMT_HANDLE hAllocation,
+                                       PVBOXDXKMRESOURCE pKMResource,
                                        uint32 byteOffsetForArgs)
 {
@@ -1699 +1699 @@
     SET_CMD_FIELD(byteOffsetForArgs);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->argsBufferSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->argsBufferSid, pKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1708 +1708 @@
 
 int vgpu10DrawInstancedIndirect(PVBOXDX_DEVICE pDevice,
-                                D3DKMT_HANDLE hAllocation,
+                                PVBOXDXKMRESOURCE pKMResource,
                                 uint32 byteOffsetForArgs)
 {
@@ -1720 +1720 @@
     SET_CMD_FIELD(byteOffsetForArgs);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->argsBufferSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->argsBufferSid, pKMResource,
+                             0, false);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1730 +1730 @@
 int vgpu10CopyStructureCount(PVBOXDX_DEVICE pDevice,
                              SVGA3dUAViewId srcUAViewId,
-                             D3DKMT_HANDLE hDstBuffer,
+                             PVBOXDXKMRESOURCE pDstKMResource,
                              uint32 destByteOffset)
 {
@@ -1743 +1743 @@
     SET_CMD_FIELD(destByteOffset);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->destSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hDstBuffer, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->destSid, pDstKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1752 +1752 @@
 
 int vgpu10PresentBlt(PVBOXDX_DEVICE pDevice,
-                     D3DKMT_HANDLE hSrcAllocation,
+                     PVBOXDXKMRESOURCE pSrcKMResource,
                      uint32 srcSubResource,
-                     D3DKMT_HANDLE hDstAllocation,
+                     PVBOXDXKMRESOURCE pDstKMResource,
                      uint32 destSubResource,
                      SVGA3dBox const &boxSrc,
@@ -1774 +1774 @@
     SET_CMD_FIELD(mode);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hSrcAllocation, 0, false);
-    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hDstAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->srcSid, pSrcKMResource,
+                             0, false);
+    vboxDXStorePatchLocation(pDevice, &cmd->dstSid, pDstKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1804 +1804 @@
 int vgpu10DefineVideoDecoderOutputView(PVBOXDX_DEVICE pDevice,
                                        VBSVGA3dVideoDecoderOutputViewId videoDecoderOutputViewId,
-                                       D3DKMT_HANDLE hAllocation,
+                                       PVBOXDXKMRESOURCE pKMResource,
                                        VBSVGA3dVDOVDesc const &desc)
 {
@@ -1816 +1816 @@
     cmd->sid = SVGA3D_INVALID_ID;
     SET_CMD_FIELD(desc);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1865 +1865 @@
                                     VBSVGA3dVideoDecoderId videoDecoderId,
                                     uint32 bufferCount,
-                                    D3DKMT_HANDLE const *pahAllocation,
+                                    PVBOXDXKMRESOURCE const *papKMResources,
                                     VBSVGA3dVideoDecoderBufferDesc const *paBufferDesc)
 {
@@ -1883 +1883 @@
     for (uint32_t i = 0; i < bufferCount; ++i)
     {
-        vboxDXStorePatchLocation(pDevice, &paCmdBufferDesc[i].sidBuffer, VBOXDXALLOCATIONTYPE_SURFACE,
-                                 pahAllocation[i], 0, false);
+        vboxDXStorePatchLocation(pDevice, &paCmdBufferDesc[i].sidBuffer, papKMResources[i],
+                                 0, false);
     }
 
@@ -1910 +1910 @@
 int vgpu10DefineVideoProcessorInputView(PVBOXDX_DEVICE pDevice,
                                         VBSVGA3dVideoProcessorInputViewId videoProcessorInputViewId,
-                                        D3DKMT_HANDLE hAllocation,
+                                        PVBOXDXKMRESOURCE pKMResource,
                                         VBSVGA3dVideoProcessorDesc const &contentDesc,
                                         VBSVGA3dVPIVDesc const &desc)
@@ -1924 +1924 @@
     SET_CMD_FIELD(contentDesc);
     SET_CMD_FIELD(desc);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -1934 +1934 @@
 int vgpu10DefineVideoProcessorOutputView(PVBOXDX_DEVICE pDevice,
                                          VBSVGA3dVideoProcessorOutputViewId videoProcessorOutputViewId,
-                                         D3DKMT_HANDLE hAllocation,
+                                         PVBOXDXKMRESOURCE pKMResource,
                                          VBSVGA3dVideoProcessorDesc const &contentDesc,
                                          VBSVGA3dVPOVDesc const &desc)
@@ -1948 +1948 @@
     SET_CMD_FIELD(contentDesc);
     SET_CMD_FIELD(desc);
-    vboxDXStorePatchLocation(pDevice, &cmd->sid, VBOXDXALLOCATIONTYPE_SURFACE,
-                             hAllocation, 0, true);
+    vboxDXStorePatchLocation(pDevice, &cmd->sid, pKMResource,
+                             0, true);
 
     vboxDXCommandBufferCommit(pDevice);
@@ -2490 +2490 @@
 int vgpu10GetVideoCapability(PVBOXDX_DEVICE pDevice,
                              VBSVGA3dVideoCapability capability,
-                             D3DKMT_HANDLE hAllocation,
+                             PVBOXDXKMRESOURCE pKMResource,
                              uint32 offsetInBytes,
                              uint32 sizeInBytes,
@@ -2507 +2507 @@
     SET_CMD_FIELD(fenceValue);
 
-    vboxDXStorePatchLocation(pDevice, &cmd->mobid, VBOXDXALLOCATIONTYPE_CO,
-                             hAllocation, offsetInBytes, true);
-
-    vboxDXCommandBufferCommit(pDevice);
-    return VINF_SUCCESS;
-}
+    vboxDXStorePatchLocation(pDevice, &cmd->mobid, pKMResource,
+                             offsetInBytes, true);
+
+    vboxDXCommandBufferCommit(pDevice);
+    return VINF_SUCCESS;
+}

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXCmd.h

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2022-2024 Oracle and/or its affiliates.
+ * Copyright (C) 2022-2025 Oracle and/or its affiliates.
  *
  * This file is part of VirtualBox base platform packages, as
@@ -171 +171 @@
 int vgpu10BindStreamOutput(PVBOXDX_DEVICE pDevice,
                            SVGA3dStreamOutputId soid,
-                           D3DKMT_HANDLE hAllocation,
+                           PVBOXDXKMRESOURCE pKMResource,
                            uint32 offsetInBytes,
                            uint32 sizeInBytes);
@@ -180 +180 @@
 int vgpu10BindShader(PVBOXDX_DEVICE pDevice,
                      uint32_t shid,
-                     D3DKMT_HANDLE hAllocation,
+                     PVBOXDXKMRESOURCE pKMResource,
                      uint32_t offsetInBytes);
 int vgpu10SetShader(PVBOXDX_DEVICE pDevice,
@@ -188 +188 @@
                            uint32_t startBuffer,
                            uint32_t numBuffers,
-                           D3DKMT_HANDLE *paAllocations,
+                           PVBOXDXKMRESOURCE *papKMResources,
                            const UINT *paStrides,
                            const UINT *paOffsets);
 int vgpu10SetIndexBuffer(PVBOXDX_DEVICE pDevice,
-                         D3DKMT_HANDLE hAllocation,
+                         PVBOXDXKMRESOURCE pKMResource,
                          SVGA3dSurfaceFormat format,
                          uint32_t offset);
 int vgpu10SoSetTargets(PVBOXDX_DEVICE pDevice,
                        uint32_t numTargets,
-                       D3DKMT_HANDLE *paAllocations,
+                       PVBOXDXKMRESOURCE *papKMResources,
                        uint32_t *paOffsets,
                        uint32_t *paSizes);
 int vgpu10DefineShaderResourceView(PVBOXDX_DEVICE pDevice,
                                    SVGA3dShaderResourceViewId shaderResourceViewId,
-                                   D3DKMT_HANDLE hAllocation,
+                                   PVBOXDXKMRESOURCE pKMResource,
                                    SVGA3dSurfaceFormat format,
                                    SVGA3dResourceType resourceDimension,
@@ -212 +212 @@
 int vgpu10DefineRenderTargetView(PVBOXDX_DEVICE pDevice,
                                  SVGA3dRenderTargetViewId renderTargetViewId,
-                                 D3DKMT_HANDLE hAllocation,
+                                 PVBOXDXKMRESOURCE pKMResource,
                                  SVGA3dSurfaceFormat format,
                                  SVGA3dResourceType resourceDimension,
@@ -223 +223 @@
 int vgpu10DefineDepthStencilView(PVBOXDX_DEVICE pDevice,
                                  SVGA3dDepthStencilViewId depthStencilViewId,
-                                 D3DKMT_HANDLE hAllocation,
+                                 PVBOXDXKMRESOURCE pKMResource,
                                  SVGA3dSurfaceFormat format,
                                  SVGA3dResourceType resourceDimension,
@@ -250 +250 @@
                                   uint32 slot,
                                   SVGA3dShaderType type,
-                                  D3DKMT_HANDLE hAllocation,
+                                  PVBOXDXKMRESOURCE pKMResource,
                                   uint32 offsetInBytes,
                                   uint32 sizeInBytes);
 int vgpu10UpdateSubResource(PVBOXDX_DEVICE pDevice,
-                            D3DKMT_HANDLE hAllocation,
+                            PVBOXDXKMRESOURCE pKMResource,
                             uint32 subResource,
                             const SVGA3dBox *pBox);
 int vgpu10ReadbackSubResource(PVBOXDX_DEVICE pDevice,
-                            D3DKMT_HANDLE hAllocation,
+                            PVBOXDXKMRESOURCE pKMResource,
                             uint32 subResource);
 int vgpu10TransferFromBuffer(PVBOXDX_DEVICE pDevice,
-                             D3DKMT_HANDLE hSrcAllocation,
+                             PVBOXDXKMRESOURCE pSrcKMResource,
                              uint32 srcOffset,
                              uint32 srcPitch,
                              uint32 srcSlicePitch,
-                             D3DKMT_HANDLE hDstAllocation,
+                             PVBOXDXKMRESOURCE pDstKMResource,
                              uint32 destSubResource,
                              SVGA3dBox const &destBox);
 int vgpu10ResourceCopyRegion(PVBOXDX_DEVICE pDevice,
-                             D3DKMT_HANDLE hDstAllocation,
+                             PVBOXDXKMRESOURCE pDstKMResource,
                              uint32 dstSubResource,
                              uint32 dstX,
                              uint32 dstY,
                              uint32 dstZ,
-                             D3DKMT_HANDLE hSrcAllocation,
+                             PVBOXDXKMRESOURCE pSrcKMResource,
                              uint32 srcSubResource,
                              SVGA3dBox const &srcBox);
 int vgpu10ResourceCopy(PVBOXDX_DEVICE pDevice,
-                       D3DKMT_HANDLE hDstAllocation,
-                       D3DKMT_HANDLE hSrcAllocation);
+                       PVBOXDXKMRESOURCE pDstKMResource,
+                       PVBOXDXKMRESOURCE pSrcKMResource);
 int vgpu10ResolveCopy(PVBOXDX_DEVICE pDevice,
-                      D3DKMT_HANDLE hDstAllocation,
+                      PVBOXDXKMRESOURCE pDstKMResource,
                       uint32 dstSubResource,
-                      D3DKMT_HANDLE hSrcAllocation,
+                      PVBOXDXKMRESOURCE pSrcKMResource,
                       uint32 srcSubResource,
                       SVGA3dSurfaceFormat copyFormat);
 int vgpu10MobFence64(PVBOXDX_DEVICE pDevice,
                      uint64 value,
-                     D3DKMT_HANDLE hAllocation,
+                     PVBOXDXKMRESOURCE pKMResource,
                      uint32 mobOffset);
 int vgpu10DefineQuery(PVBOXDX_DEVICE pDevice,
@@ -298 +298 @@
 int vgpu10BindQuery(PVBOXDX_DEVICE pDevice,
                     SVGA3dQueryId queryId,
-                    D3DKMT_HANDLE hAllocation);
+                    PVBOXDXKMRESOURCE pKMResource);
 int vgpu10SetQueryOffset(PVBOXDX_DEVICE pDevice,
                          SVGA3dQueryId queryId,
@@ -313 +313 @@
 int vgpu10DefineUAView(PVBOXDX_DEVICE pDevice,
                        SVGA3dUAViewId uaViewId,
-                       D3DKMT_HANDLE hAllocation,
+                       PVBOXDXKMRESOURCE pKMResource,
                        SVGA3dSurfaceFormat format,
                        SVGA3dResourceType resourceDimension,
@@ -341 +341 @@
                    uint32 threadGroupCountZ);
 int vgpu10DispatchIndirect(PVBOXDX_DEVICE pDevice,
-                           D3DKMT_HANDLE hAllocation,
+                           PVBOXDXKMRESOURCE pKMResource,
                            uint32 byteOffsetForArgs);
 int vgpu10DrawIndexedInstancedIndirect(PVBOXDX_DEVICE pDevice,
-                                       D3DKMT_HANDLE hAllocation,
+                                       PVBOXDXKMRESOURCE pKMResource,
                                        uint32 byteOffsetForArgs);
 int vgpu10DrawInstancedIndirect(PVBOXDX_DEVICE pDevice,
-                                D3DKMT_HANDLE hAllocation,
+                                PVBOXDXKMRESOURCE pKMResource,
                                 uint32 byteOffsetForArgs);
 int vgpu10CopyStructureCount(PVBOXDX_DEVICE pDevice,
                              SVGA3dUAViewId srcUAViewId,
-                             D3DKMT_HANDLE hDstBuffer,
+                             PVBOXDXKMRESOURCE pDstKMResource,
                              uint32 destByteOffset);
 int vgpu10ClearRenderTargetViewRegion(PVBOXDX_DEVICE pDevice,
@@ -359 +359 @@
                                       uint32_t cRects);
 int vgpu10PresentBlt(PVBOXDX_DEVICE pDevice,
-                     D3DKMT_HANDLE hSrcAllocation,
+                     PVBOXDXKMRESOURCE pSrcKMResource,
                      uint32 srcSubResource,
-                     D3DKMT_HANDLE hDstAllocation,
+                     PVBOXDXKMRESOURCE pDstKMResource,
                      uint32 destSubResource,
                      SVGA3dBox const &boxSrc,
@@ -372 +372 @@
 int vgpu10DefineVideoDecoderOutputView(PVBOXDX_DEVICE pDevice,
                                        VBSVGA3dVideoDecoderOutputViewId videoDecoderOutputViewId,
-                                       D3DKMT_HANDLE hAllocation,
+                                       PVBOXDXKMRESOURCE pKMResource,
                                        VBSVGA3dVDOVDesc const &desc);
 int vgpu10DefineVideoDecoder(PVBOXDX_DEVICE pDevice,
@@ -384 +384 @@
                                     VBSVGA3dVideoDecoderId videoDecoderId,
                                     uint32 bufferCount,
-                                    D3DKMT_HANDLE const *pahAllocation,
+                                    PVBOXDXKMRESOURCE const *papKMResources,
                                     VBSVGA3dVideoDecoderBufferDesc const *paBufferDesc);
 int vgpu10VideoDecoderEndFrame(PVBOXDX_DEVICE pDevice,
@@ -390 +390 @@
 int vgpu10DefineVideoProcessorInputView(PVBOXDX_DEVICE pDevice,
                                         VBSVGA3dVideoProcessorInputViewId videoProcessorInputViewId,
-                                        D3DKMT_HANDLE hAllocation,
+                                        PVBOXDXKMRESOURCE pKMResource,
                                         VBSVGA3dVideoProcessorDesc const &contentDesc,
                                         VBSVGA3dVPIVDesc const &desc);
 int vgpu10DefineVideoProcessorOutputView(PVBOXDX_DEVICE pDevice,
                                          VBSVGA3dVideoProcessorOutputViewId videoProcessorOutputViewId,
-                                         D3DKMT_HANDLE hAllocation,
+                                         PVBOXDXKMRESOURCE pKMResource,
                                          VBSVGA3dVideoProcessorDesc const &contentDesc,
                                          VBSVGA3dVPOVDesc const &desc);
@@ -509 +509 @@
 int vgpu10GetVideoCapability(PVBOXDX_DEVICE pDevice,
                              VBSVGA3dVideoCapability capability,
-                             D3DKMT_HANDLE hAllocation,
+                             PVBOXDXKMRESOURCE pKMResource,
                              uint32 offsetInBytes,
                              uint32 sizeInBytes,

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXDDI.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2020-2024 Oracle and/or its affiliates.
+ * Copyright (C) 2020-2025 Oracle and/or its affiliates.
  *
  * This file is part of VirtualBox base platform packages, as
@@ -973 +973 @@
 
     /* Fetch allocation handles. */
-    D3DKMT_HANDLE aAllocations[SVGA3D_DX_MAX_SOTARGETS];
+    PVBOXDXKMRESOURCE apKMResources[SVGA3D_DX_MAX_SOTARGETS];
     uint32_t aOffsets[SVGA3D_DX_MAX_SOTARGETS];
     uint32_t aSizes[SVGA3D_DX_MAX_SOTARGETS];
@@ -981 +981 @@
         {
             VBOXDX_RESOURCE *pResource = (PVBOXDX_RESOURCE)phResource[i].pDrvPrivate;
-            aAllocations[i] = vboxDXGetAllocation(pResource);
+            apKMResources[i] = vboxDXGetKMResource(pResource);
             aOffsets[i] = pOffsets[i];
-            aSizes[i] = pResource ? pResource->AllocationDesc.cbAllocation : 0;
+            aSizes[i] = apKMResources[i] ? apKMResources[i]->AllocationDesc.cbAllocation : 0;
         }
         else
         {
-            aAllocations[i] = 0;
+            apKMResources[i] = 0;
             aOffsets[i] = 0;
             aSizes[i] = 0;
@@ -993 +993 @@
     }
 
-    vboxDXSoSetTargets(pDevice, NumTargets, aAllocations, aOffsets, aSizes);
+    vboxDXSoSetTargets(pDevice, NumTargets, apKMResources, aOffsets, aSizes);
 }
 
@@ -1358 +1358 @@
 
     pResource->hRTResource = hRTResource;
-    int rc = vboxDXInitResourceData(pResource, pCreateResource);
-    if (RT_SUCCESS(rc))
-        vboxDXCreateResource(pDevice, pResource, pCreateResource);
+    vboxDXCreateResource(pDevice, pResource, pCreateResource);
 }
 
@@ -1388 +1386 @@
         pCreateResource->ArraySize));
 
-        D3D11DDIARG_CREATERESOURCE CreateResource;
-        CreateResource.pMipInfoList      = pCreateResource->pMipInfoList;
-        CreateResource.pInitialDataUP    = pCreateResource->pInitialDataUP;
-        CreateResource.ResourceDimension = pCreateResource->ResourceDimension;
-        CreateResource.Usage             = pCreateResource->Usage;
-        CreateResource.BindFlags         = pCreateResource->BindFlags;
-        CreateResource.MapFlags          = pCreateResource->MapFlags;
-        CreateResource.MiscFlags         = pCreateResource->MiscFlags;
-        CreateResource.Format            = pCreateResource->Format;
-        CreateResource.SampleDesc        = pCreateResource->SampleDesc;
-        CreateResource.MipLevels         = pCreateResource->MipLevels;
-        CreateResource.ArraySize         = pCreateResource->ArraySize;
-        CreateResource.pPrimaryDesc      = pCreateResource->pPrimaryDesc;
-        CreateResource.ByteStride        = 0;
-        CreateResource.DecoderBufferType = D3D11_1DDI_VIDEO_DECODER_BUFFER_UNKNOWN;
-        CreateResource.TextureLayout     = D3DWDDM2_0DDI_TL_UNDEFINED;
+    D3D11DDIARG_CREATERESOURCE CreateResource;
+    CreateResource.pMipInfoList      = pCreateResource->pMipInfoList;
+    CreateResource.pInitialDataUP    = pCreateResource->pInitialDataUP;
+    CreateResource.ResourceDimension = pCreateResource->ResourceDimension;
+    CreateResource.Usage             = pCreateResource->Usage;
+    CreateResource.BindFlags         = pCreateResource->BindFlags;
+    CreateResource.MapFlags          = pCreateResource->MapFlags;
+    CreateResource.MiscFlags         = pCreateResource->MiscFlags;
+    CreateResource.Format            = pCreateResource->Format;
+    CreateResource.SampleDesc        = pCreateResource->SampleDesc;
+    CreateResource.MipLevels         = pCreateResource->MipLevels;
+    CreateResource.ArraySize         = pCreateResource->ArraySize;
+    CreateResource.pPrimaryDesc      = pCreateResource->pPrimaryDesc;
+    CreateResource.ByteStride        = 0;
+    CreateResource.DecoderBufferType = D3D11_1DDI_VIDEO_DECODER_BUFFER_UNKNOWN;
+    CreateResource.TextureLayout     = D3DWDDM2_0DDI_TL_UNDEFINED;
 
     pResource->hRTResource = hRTResource;
-    int rc = vboxDXInitResourceData(pResource, &CreateResource);
-    if (RT_SUCCESS(rc))
-        vboxDXCreateResource(pDevice, pResource, &CreateResource);
+    vboxDXCreateResource(pDevice, pResource, &CreateResource);
 }
 
@@ -3867 +3863 @@
     LogFlowFunc(("pDevice 0x%p, pResource 0x%p, subres %d", pDevice, pResource, pDisplayModeData->SubResourceIndex));
 
-    AssertReturn(pResource->AllocationDesc.fPrimary && pDisplayModeData->SubResourceIndex == 0, E_INVALIDARG);
+    AssertReturn(pResource->pKMResource
+              && pResource->pKMResource->AllocationDesc.fPrimary
+              && pDisplayModeData->SubResourceIndex == 0, E_INVALIDARG);
 
     D3DDDICB_SETDISPLAYMODE ddiSetDisplayMode;

trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/dx/VBoxDXVideo.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2023-2024 Oracle and/or its affiliates.
+ * Copyright (C) 2023-2025 Oracle and/or its affiliates.
  *
  * This file is part of VirtualBox base platform packages, as
@@ -42 +42 @@
 static void vboxDXDestroyVideoDeviceAllocation(PVBOXDX_DEVICE pDevice)
 {
-    if (pDevice->VideoDevice.hAllocation)
-    {
-        D3DDDICB_DEALLOCATE ddiDeallocate;
-        RT_ZERO(ddiDeallocate);
-        ddiDeallocate.NumAllocations = 1;
-        ddiDeallocate.HandleList     = &pDevice->VideoDevice.hAllocation;
-
-        HRESULT hr = pDevice->pRTCallbacks->pfnDeallocateCb(pDevice->hRTDevice.handle, &ddiDeallocate);
-        LogFlowFunc(("pfnDeallocateCb returned %d", hr));
-        AssertStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr));
-
-        pDevice->VideoDevice.hAllocation = 0;
-        pDevice->VideoDevice.cbAllocation = 0;
-    }
+    if (pDevice->VideoDevice.pKMResource)
+    {
+        RTListNodeRemove(&pDevice->VideoDevice.pKMResource->nodeResource);
+        vboxDXDeallocateKMResource(pDevice, pDevice->VideoDevice.pKMResource);
+        pDevice->VideoDevice.pKMResource = 0;
+    }
+}
+
+
+static void videoDeviceAllocationDesc(VBOXDXALLOCATIONDESC *pDesc, void const *pvInitData)
+{
+    pDesc->enmAllocationType = VBOXDXALLOCATIONTYPE_CO; /* Context Object allocation. */
+    pDesc->cbAllocation      = *(uint32_t *)pvInitData;
 }
 
@@ -61 +60 @@
 static bool vboxDXCreateVideoDeviceAllocation(PVBOXDX_DEVICE pDevice, uint32_t cbAllocation)
 {
-    VBOXDXALLOCATIONDESC desc;
-    RT_ZERO(desc);
-    desc.enmAllocationType = VBOXDXALLOCATIONTYPE_CO; /* Context Object allocation. */
-    desc.cbAllocation      = cbAllocation;
-
-    D3DDDI_ALLOCATIONINFO2 ddiAllocationInfo;
-    RT_ZERO(ddiAllocationInfo);
-    ddiAllocationInfo.pPrivateDriverData    = &desc;
-    ddiAllocationInfo.PrivateDriverDataSize = sizeof(desc);
-
-    D3DDDICB_ALLOCATE ddiAllocate;
-    RT_ZERO(ddiAllocate);
-    ddiAllocate.NumAllocations   = 1;
-    ddiAllocate.pAllocationInfo2 = &ddiAllocationInfo;
-
-    HRESULT hr = pDevice->pRTCallbacks->pfnAllocateCb(pDevice->hRTDevice.handle, &ddiAllocate);
-    LogFlowFunc(("pfnAllocateCb returned %d, hKMResource 0x%X, hAllocation 0x%X", hr, ddiAllocate.hKMResource, ddiAllocationInfo.hAllocation));
-    AssertReturnStmt(SUCCEEDED(hr), vboxDXDeviceSetError(pDevice, hr), false);
-
-    pDevice->VideoDevice.hAllocation = ddiAllocationInfo.hAllocation;
-    pDevice->VideoDevice.cbAllocation = cbAllocation;
-
-    D3DDDICB_LOCK ddiLock;
-    RT_ZERO(ddiLock);
-    ddiLock.hAllocation = ddiAllocationInfo.hAllocation;
-    ddiLock.Flags.WriteOnly = 1;
-    hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
-    if (SUCCEEDED(hr))
-    {
-        memset(ddiLock.pData, 0, cbAllocation);
-
-        D3DDDICB_UNLOCK ddiUnlock;
-        ddiUnlock.NumAllocations = 1;
-        ddiUnlock.phAllocations = &ddiAllocationInfo.hAllocation;
-        hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
-    }
-    AssertReturnStmt(SUCCEEDED(hr),
-                     vboxDXDestroyVideoDeviceAllocation(pDevice); vboxDXDeviceSetError(pDevice, hr), false);
+    pDevice->VideoDevice.pKMResource = vboxDXAllocateKMResource(pDevice, 0, videoDeviceAllocationDesc,
+                                                                &cbAllocation, true);
+    if (!pDevice->VideoDevice.pKMResource)
+        return false;
+
+    RTListAppend(&pDevice->listResources, &pDevice->VideoDevice.pKMResource->nodeResource);
     return true;
 }
@@ -105 +72 @@
 static bool vboxDXEnsureVideoDeviceAllocation(PVBOXDX_DEVICE pDevice)
 {
-    if (!pDevice->VideoDevice.hAllocation)
+    if (!pDevice->VideoDevice.pKMResource)
         return vboxDXCreateVideoDeviceAllocation(pDevice, _64K);
     return true;
@@ -120 +87 @@
 
     uint32 const offsetInBytes = 0;
-    uint32 const sizeInBytes = pDevice->VideoDevice.cbAllocation - offsetInBytes;
+    uint32 const sizeInBytes = pDevice->VideoDevice.pKMResource->AllocationDesc.cbAllocation - offsetInBytes;
     AssertReturnVoid(cbDataIn <= sizeInBytes - RT_UOFFSETOF(VBSVGA3dVideoCapabilityMobLayout, data));
 
@@ -127 +94 @@
         D3DDDICB_LOCK ddiLock;
         RT_ZERO(ddiLock);
-        ddiLock.hAllocation = pDevice->VideoDevice.hAllocation;
+        ddiLock.hAllocation = vboxDXGetAllocation(pDevice->VideoDevice.pKMResource);
         ddiLock.Flags.ReadOnly = 1;
         HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -137 +104 @@
             D3DDDICB_UNLOCK ddiUnlock;
             ddiUnlock.NumAllocations = 1;
-            ddiUnlock.phAllocations = &pDevice->VideoDevice.hAllocation;
+            ddiUnlock.phAllocations = &ddiLock.hAllocation;
             hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
         }
@@ -144 +111 @@
 
     uint64_t const fenceValue = ASMAtomicIncU64(&pDevice->VideoDevice.u64MobFenceValue);
-    vgpu10GetVideoCapability(pDevice, cap, pDevice->VideoDevice.hAllocation, offsetInBytes, sizeInBytes, fenceValue);
+    vgpu10GetVideoCapability(pDevice, cap, pDevice->VideoDevice.pKMResource, offsetInBytes, sizeInBytes, fenceValue);
     vboxDXDeviceFlushCommands(pDevice);
 
@@ -155 +122 @@
         D3DDDICB_LOCK ddiLock;
         RT_ZERO(ddiLock);
-        ddiLock.hAllocation = pDevice->VideoDevice.hAllocation;
+        ddiLock.hAllocation = vboxDXGetAllocation(pDevice->VideoDevice.pKMResource);
         ddiLock.Flags.ReadOnly = 1;
         HRESULT hr = pDevice->pRTCallbacks->pfnLockCb(pDevice->hRTDevice.handle, &ddiLock);
@@ -181 +148 @@
             D3DDDICB_UNLOCK ddiUnlock;
             ddiUnlock.NumAllocations = 1;
-            ddiUnlock.phAllocations = &pDevice->VideoDevice.hAllocation;
+            ddiUnlock.phAllocations = &ddiLock.hAllocation;
             hr = pDevice->pRTCallbacks->pfnUnlockCb(pDevice->hRTDevice.handle, &ddiUnlock);
         }
@@ -498 +465 @@
 
     vgpu10DefineVideoDecoderOutputView(pDevice, pVideoDecoderOutputView->uVideoDecoderOutputViewId,
-                                       vboxDXGetAllocation(pVideoDecoderOutputView->pResource),
+                                       vboxDXGetKMResource(pVideoDecoderOutputView->pResource),
                                        pVideoDecoderOutputView->svga.desc);
 
@@ -555 +522 @@
                                         UINT BufferCount, D3D11_1DDI_VIDEO_DECODER_BUFFER_DESC const *pBufferDesc)
 {
-    void *pvTmpBuffer = RTMemTmpAlloc(BufferCount * (sizeof(D3DKMT_HANDLE) + sizeof(VBSVGA3dVideoDecoderBufferDesc)));
+    void *pvTmpBuffer = RTMemTmpAlloc(BufferCount * (sizeof(PVBOXDXKMRESOURCE) + sizeof(VBSVGA3dVideoDecoderBufferDesc)));
     if (!pvTmpBuffer)
         return E_OUTOFMEMORY;
 
-    D3DKMT_HANDLE *pahAllocation = (D3DKMT_HANDLE *)pvTmpBuffer;
-    VBSVGA3dVideoDecoderBufferDesc *paBD = (VBSVGA3dVideoDecoderBufferDesc *)((uint8_t *)pvTmpBuffer + BufferCount * sizeof(D3DKMT_HANDLE));
+    PVBOXDXKMRESOURCE *papKMResource = (PVBOXDXKMRESOURCE *)pvTmpBuffer;
+    VBSVGA3dVideoDecoderBufferDesc *paBD = (VBSVGA3dVideoDecoderBufferDesc *)((uint8_t *)pvTmpBuffer + BufferCount * sizeof(PVBOXDXKMRESOURCE));
 
     for (UINT i = 0; i < BufferCount; ++i)
@@ -567 +534 @@
 
         PVBOXDX_RESOURCE pBuffer = (PVBOXDX_RESOURCE)s->hResource.pDrvPrivate;
-        pahAllocation[i] = vboxDXGetAllocation(pBuffer);
+        papKMResource[i] = vboxDXGetKMResource(pBuffer);
 
         VBSVGA3dVideoDecoderBufferDesc *d = &paBD[i];
@@ -601 +568 @@
     }
 
-    vgpu10VideoDecoderSubmitBuffers(pDevice, pVideoDecoder->uVideoDecoderId, BufferCount, pahAllocation, paBD);
+    vgpu10VideoDecoderSubmitBuffers(pDevice, pVideoDecoder->uVideoDecoderId, BufferCount, papKMResource, paBD);
     RTMemTmpFree(pvTmpBuffer);
     return S_OK;
@@ -635 +602 @@
 
     vgpu10DefineVideoProcessorInputView(pDevice, pVideoProcessorInputView->uVideoProcessorInputViewId,
-                                        vboxDXGetAllocation(pVideoProcessorInputView->pResource),
+                                        vboxDXGetKMResource(pVideoProcessorInputView->pResource),
                                         pVideoProcessorInputView->svga.ContentDesc, *pDesc);
 
@@ -670 +637 @@
 
     vgpu10DefineVideoProcessorOutputView(pDevice, pVideoProcessorOutputView->uVideoProcessorOutputViewId,
-                                         vboxDXGetAllocation(pVideoProcessorOutputView->pResource),
+                                         vboxDXGetKMResource(pVideoProcessorOutputView->pResource),
                                          pVideoProcessorOutputView->svga.ContentDesc, *pDesc);