Changeset 94205 in vbox for trunk

Timestamp:

Mar 12, 2022 8:12:21 PM (3 years ago)

Author:

vboxsync

Message:

Devices/Graphics: saved state: bugref:9830

Location:

trunk/src/VBox/Devices

Files:

• Graphics/DevVGA-SVGA-cmd.cpp (modified) (3 diffs)
• Graphics/DevVGA-SVGA.cpp (modified) (9 diffs)
• Graphics/DevVGA-SVGA.h (modified) (2 diffs)
• Graphics/DevVGA-SVGA3d-dx-savedstate.cpp (modified) (4 diffs)
• Graphics/DevVGA-SVGA3d-dx.cpp (modified) (2 diffs)
• Graphics/DevVGA-SVGA3d-win-dx.cpp (modified) (16 diffs)
• Graphics/DevVGA-SVGA3d.h (modified) (2 diffs)
• Graphics/DevVGASavedState.h (modified) (1 diff)
• Makefile.kmk (modified) (1 diff)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA-cmd.cpp

@@ -815 +815 @@
 
 
+int vmsvgaR3OTableReadSurface(PVMSVGAR3STATE pSvgaR3State, uint32_t sid, SVGAOTableSurfaceEntry *pEntrySurface)
+{
+    return vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                              sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, pEntrySurface, sizeof(SVGAOTableSurfaceEntry));
+}
+
+
 /*
  *
@@ -877 +884 @@
 
 
-static PVMSVGAMOB vmsvgaR3MobGet(PVMSVGAR3STATE pSvgaR3State, SVGAMobId RT_UNTRUSTED_GUEST mobid)
+PVMSVGAMOB vmsvgaR3MobGet(PVMSVGAR3STATE pSvgaR3State, SVGAMobId RT_UNTRUSTED_GUEST mobid)
 {
     if (mobid == SVGA_ID_INVALID)
@@ -1511 +1518 @@
                 offMob += dims.cbPitch;
             }
+            /** @todo Take into account map.cbDepthPitch */
         }
 

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.cpp

@@ -409 +409 @@
     SSMFIELD_ENTRY_IGNORE(          VMSVGAState, fFifoExtCommandWakeup),
     SSMFIELD_ENTRY_IGNORE(          VMSVGAState, cGMR),
+    SSMFIELD_ENTRY_VER(             VMSVGAState, au32DevCaps, VGA_SAVEDSTATE_VERSION_VMSVGA_DX),
+    SSMFIELD_ENTRY_VER(             VMSVGAState, u32DevCapIndex, VGA_SAVEDSTATE_VERSION_VMSVGA_DX),
+    SSMFIELD_ENTRY_VER(             VMSVGAState, u32RegCommandLow, VGA_SAVEDSTATE_VERSION_VMSVGA_DX),
+    SSMFIELD_ENTRY_VER(             VMSVGAState, u32RegCommandHigh, VGA_SAVEDSTATE_VERSION_VMSVGA_DX),
+
     SSMFIELD_ENTRY_TERM()
 };
@@ -3955 +3960 @@
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
-                vmsvga3dSaveExec(pDevIns, pThisCC, pSSM);
+            {
+                if (vmsvga3dIsLegacyBackend(pThisCC))
+                    vmsvga3dSaveExec(pDevIns, pThisCC, pSSM);
+                else
+                    vmsvga3dDXSaveExec(pDevIns, pThisCC, pSSM);
+            }
 # endif
             break;
@@ -3976 +3986 @@
 #  endif
 
-                vmsvga3dLoadExec(pDevIns, pThis, pThisCC, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
+                if (vmsvga3dIsLegacyBackend(pThisCC))
+                    vmsvga3dLoadExec(pDevIns, pThis, pThisCC, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
+                else
+                    vmsvga3dDXLoadExec(pDevIns, pThis, pThisCC, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
             }
 # endif
@@ -5441 +5454 @@
 }
 
+static int vmsvgaR3LoadBufCtx(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PVMSVGACMDBUFCTX pBufCtx)
+{
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
+
+    int rc = pHlp->pfnSSMGetU32(pSSM, &pBufCtx->cSubmitted);
+    AssertLogRelRCReturn(rc, rc);
+
+    for (uint32_t i = 0; i < pBufCtx->cSubmitted; ++i)
+    {
+        PVMSVGACMDBUF pCmdBuf = vmsvgaR3CmdBufAlloc(pBufCtx);
+        AssertPtrReturn(pCmdBuf, VERR_NO_MEMORY);
+
+        pHlp->pfnSSMGetGCPhys(pSSM, &pCmdBuf->GCPhysCB);
+
+        uint32_t u32;
+        rc = pHlp->pfnSSMGetU32(pSSM, &u32);
+        AssertRCReturn(rc, rc);
+        AssertReturn(u32 == sizeof(SVGACBHeader), VERR_INVALID_STATE);
+        pHlp->pfnSSMGetMem(pSSM, &pCmdBuf->hdr, sizeof(SVGACBHeader));
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &u32);
+        AssertRCReturn(rc, rc);
+        AssertReturn(u32 == pCmdBuf->hdr.length, VERR_INVALID_STATE);
+
+        pCmdBuf->pvCommands = RTMemAlloc(pCmdBuf->hdr.length);
+        AssertPtrReturn(pCmdBuf->pvCommands, VERR_NO_MEMORY);
+
+        rc = pHlp->pfnSSMGetMem(pSSM, pCmdBuf->pvCommands, pCmdBuf->hdr.length);
+        AssertRCReturn(rc, rc);
+    }
+    return rc;
+}
+
+static int vmsvgaR3LoadGbo(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, VMSVGAGBO *pGbo)
+{
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
+
+    int rc;
+    pHlp->pfnSSMGetU32(pSSM, &pGbo->fGboFlags);
+    pHlp->pfnSSMGetU32(pSSM, &pGbo->cTotalPages);
+    pHlp->pfnSSMGetU32(pSSM, &pGbo->cbTotal);
+    rc = pHlp->pfnSSMGetU32(pSSM, &pGbo->cDescriptors);
+    AssertRCReturn(rc, rc);
+
+    if (pGbo->cDescriptors)
+    {
+        pGbo->paDescriptors = (PVMSVGAGBODESCRIPTOR)RTMemAllocZ(pGbo->cDescriptors * sizeof(VMSVGAGBODESCRIPTOR));
+        AssertPtrReturn(pGbo->paDescriptors, VERR_NO_MEMORY);
+    }
+
+    for (uint32_t iDesc = 0; iDesc < pGbo->cDescriptors; ++iDesc)
+    {
+        PVMSVGAGBODESCRIPTOR pDesc = &pGbo->paDescriptors[iDesc];
+        pHlp->pfnSSMGetGCPhys(pSSM, &pDesc->GCPhys);
+        rc = pHlp->pfnSSMGetU64(pSSM, &pDesc->cPages);
+    }
+
+    if (pGbo->fGboFlags & VMSVGAGBO_F_HOST_BACKED)
+    {
+        pGbo->pvHost = RTMemAlloc(pGbo->cbTotal);
+        AssertPtrReturn(pGbo->pvHost, VERR_NO_MEMORY);
+        rc = pHlp->pfnSSMGetMem(pSSM, pGbo->pvHost, pGbo->cbTotal);
+    }
+
+    return rc;
+}
+
 /**
  * Portion of VMSVGA state which must be loaded oin the FIFO thread.
@@ -5474 +5554 @@
                 *pScreen = screen;
                 pScreen->fModified = true;
+
+                if (uVersion >= VGA_SAVEDSTATE_VERSION_VMSVGA_DX)
+                {
+                    uint32_t u32;
+                    pHlp->pfnSSMGetU32(pSSM, &u32); /* Size of screen bitmap. */
+                    AssertLogRelRCReturn(rc, rc);
+                    if (u32)
+                    {
+                        pScreen->pvScreenBitmap = RTMemAlloc(u32);
+                        AssertPtrReturn(pScreen->pvScreenBitmap, VERR_NO_MEMORY);
+
+                        pHlp->pfnSSMGetMem(pSSM, pScreen->pvScreenBitmap, u32);
+                    }
+                }
             }
             else
@@ -5594 +5688 @@
     }
 
+    if (uVersion >= VGA_SAVEDSTATE_VERSION_VMSVGA_DX)
+    {
+        bool f;
+        uint32_t u32;
+
+        rc = pHlp->pfnSSMGetBool(pSSM, &f);
+        AssertLogRelRCReturn(rc, rc);
+        AssertReturn(f == pThis->fVMSVGA10, VERR_INVALID_STATE);
+
+        if (pThis->fVMSVGA10)
+        {
+            /* Device context command buffers. */
+            rc = vmsvgaR3LoadBufCtx(pDevIns, pSSM, &pSVGAState->CmdBufCtxDC);
+            AssertLogRelRCReturn(rc, rc);
+
+            /* DX contexts command buffers. */
+            uint32_t cBufCtx;
+            rc = pHlp->pfnSSMGetU32(pSSM, &cBufCtx);
+            AssertLogRelRCReturn(rc, rc);
+            AssertReturn(cBufCtx == RT_ELEMENTS(pSVGAState->apCmdBufCtxs), VERR_INVALID_STATE);
+            for (uint32_t j = 0; j < cBufCtx; ++j)
+            {
+                rc = pHlp->pfnSSMGetBool(pSSM, &f);
+                AssertLogRelRCReturn(rc, rc);
+                if (f)
+                {
+                    pSVGAState->apCmdBufCtxs[j] = (PVMSVGACMDBUFCTX)RTMemAlloc(sizeof(VMSVGACMDBUFCTX));
+                    AssertPtrReturn(pSVGAState->apCmdBufCtxs[j], VERR_NO_MEMORY);
+                    vmsvgaR3CmdBufCtxInit(pSVGAState->apCmdBufCtxs[j]);
+
+                    rc = vmsvgaR3LoadBufCtx(pDevIns, pSSM, pSVGAState->apCmdBufCtxs[j]);
+                    AssertLogRelRCReturn(rc, rc);
+                }
+            }
+
+            rc = pHlp->pfnSSMGetU32(pSSM, &u32);
+            pSVGAState->fCmdBuf = u32;
+
+            /*
+             * OTables GBOs.
+             */
+            rc = pHlp->pfnSSMGetU32(pSSM, &u32);
+            AssertLogRelRCReturn(rc, rc);
+            AssertReturn(u32 == SVGA_OTABLE_MAX, VERR_INVALID_STATE);
+            for (int i = 0; i < SVGA_OTABLE_MAX; ++i)
+            {
+                VMSVGAGBO *pGbo = &pSVGAState->aGboOTables[i];
+                rc = vmsvgaR3LoadGbo(pDevIns, pSSM, pGbo);
+                AssertRCReturn(rc, rc);
+            }
+
+            /*
+             * MOBs.
+             */
+            for (;;)
+            {
+                rc = pHlp->pfnSSMGetU32(pSSM, &u32); /* MOB id. */
+                AssertRCReturn(rc, rc);
+                if (u32 == SVGA_ID_INVALID)
+                    break;
+
+                PVMSVGAMOB pMob = (PVMSVGAMOB)RTMemAllocZ(sizeof(*pMob));
+                AssertPtrReturn(pMob, VERR_NO_MEMORY);
+
+                rc = vmsvgaR3LoadGbo(pDevIns, pSSM, &pMob->Gbo);
+                AssertRCReturn(rc, rc);
+
+                pMob->Core.Key = u32;
+                if (RTAvlU32Insert(&pSVGAState->MOBTree, &pMob->Core))
+                    RTListPrepend(&pSVGAState->MOBLRUList, &pMob->nodeLRU);
+                else
+                    AssertFailedReturn(VERR_NO_MEMORY);
+            }
+
+# ifdef VMSVGA3D_DX
+            if (pThis->svga.f3DEnabled)
+            {
+                pHlp->pfnSSMGetU32(pSSM, &pSVGAState->idDXContextCurrent);
+            }
+# endif
+        }
+    }
+
 #  ifdef RT_OS_DARWIN  /** @todo r=bird: this is normally done on the EMT, so for DARWIN we do that when loading saved state too now. See DevVGA-SVGA3d-shared.h. */
     if (pThis->svga.f3DEnabled)
@@ -5662 +5839 @@
 }
 
+static int vmsvgaR3SaveBufCtx(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, PVMSVGACMDBUFCTX pBufCtx)
+{
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
+
+    int rc = pHlp->pfnSSMPutU32(pSSM, pBufCtx->cSubmitted);
+    AssertLogRelRCReturn(rc, rc);
+    if (pBufCtx->cSubmitted)
+    {
+        PVMSVGACMDBUF pIter;
+        RTListForEach(&pBufCtx->listSubmitted, pIter, VMSVGACMDBUF, nodeBuffer)
+        {
+            pHlp->pfnSSMPutGCPhys(pSSM, pIter->GCPhysCB);
+            pHlp->pfnSSMPutU32(pSSM, sizeof(SVGACBHeader));
+            pHlp->pfnSSMPutMem(pSSM, &pIter->hdr, sizeof(SVGACBHeader));
+            pHlp->pfnSSMPutU32(pSSM, pIter->hdr.length);
+            rc = pHlp->pfnSSMPutMem(pSSM, pIter->pvCommands, pIter->hdr.length);
+            AssertLogRelRCReturn(rc, rc);
+        }
+    }
+    return rc;
+}
+
+static int vmsvgaR3SaveGbo(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, VMSVGAGBO *pGbo)
+{
+    PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
+
+    int rc;
+    pHlp->pfnSSMPutU32(pSSM, pGbo->fGboFlags);
+    pHlp->pfnSSMPutU32(pSSM, pGbo->cTotalPages);
+    pHlp->pfnSSMPutU32(pSSM, pGbo->cbTotal);
+    rc =  pHlp->pfnSSMPutU32(pSSM, pGbo->cDescriptors);
+    for (uint32_t iDesc = 0; iDesc < pGbo->cDescriptors; ++iDesc)
+    {
+        PVMSVGAGBODESCRIPTOR pDesc = &pGbo->paDescriptors[iDesc];
+        pHlp->pfnSSMPutGCPhys(pSSM, pDesc->GCPhys);
+        rc = pHlp->pfnSSMPutU64(pSSM, pDesc->cPages);
+    }
+    if (pGbo->fGboFlags & VMSVGAGBO_F_HOST_BACKED)
+        rc = pHlp->pfnSSMPutMem(pSSM, pGbo->pvHost, pGbo->cbTotal);
+    return rc;
+}
+
 /**
  * Portion of SVGA state which must be saved in the FIFO thread.
@@ -5682 +5901 @@
     AssertLogRelRCReturn(rc, rc);
 
-    for (uint32_t i = 0; i < cScreens; ++i)
+    for (uint32_t i = 0; i < RT_ELEMENTS(pSVGAState->aScreens); ++i)
     {
         VMSVGASCREENOBJECT *pScreen = &pSVGAState->aScreens[i];
+        if (!pScreen->fDefined)
+            continue;
 
         rc = pHlp->pfnSSMPutStructEx(pSSM, pScreen, sizeof(*pScreen), 0, g_aVMSVGASCREENOBJECTFields, NULL);
         AssertLogRelRCReturn(rc, rc);
+
+        /*
+         * VGA_SAVEDSTATE_VERSION_VMSVGA_DX
+         */
+        if (pScreen->pvScreenBitmap)
+        {
+            uint32_t const cbScreenBitmap = pScreen->cHeight * pScreen->cbPitch;
+            pHlp->pfnSSMPutU32(pSSM, cbScreenBitmap);
+            pHlp->pfnSSMPutMem(pSSM, pScreen->pvScreenBitmap, cbScreenBitmap);
+        }
+        else
+            pHlp->pfnSSMPutU32(pSSM, 0);
     }
     return VINF_SUCCESS;
@@ -5738 +5971 @@
             AssertLogRelRCReturn(rc, rc);
         }
+    }
+
+    /*
+     * VGA_SAVEDSTATE_VERSION_VMSVGA_DX
+     */
+
+    rc = pHlp->pfnSSMPutBool(pSSM, pThis->fVMSVGA10);
+    AssertLogRelRCReturn(rc, rc);
+
+    if (pThis->fVMSVGA10)
+    {
+        /* Device context command buffers. */
+        rc = vmsvgaR3SaveBufCtx(pDevIns, pSSM, &pSVGAState->CmdBufCtxDC);
+        AssertRCReturn(rc, rc);
+
+        /* DX contexts command buffers. */
+        rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pSVGAState->apCmdBufCtxs));
+        AssertLogRelRCReturn(rc, rc);
+        for (unsigned i = 0; i < RT_ELEMENTS(pSVGAState->apCmdBufCtxs); ++i)
+        {
+            if (pSVGAState->apCmdBufCtxs[i])
+            {
+                pHlp->pfnSSMPutBool(pSSM, true);
+                rc = vmsvgaR3SaveBufCtx(pDevIns, pSSM, pSVGAState->apCmdBufCtxs[i]);
+                AssertRCReturn(rc, rc);
+            }
+            else
+                pHlp->pfnSSMPutBool(pSSM, false);
+        }
+
+        rc = pHlp->pfnSSMPutU32(pSSM, pSVGAState->fCmdBuf);
+        AssertRCReturn(rc, rc);
+
+        /*
+         * OTables GBOs.
+         */
+        pHlp->pfnSSMPutU32(pSSM, SVGA_OTABLE_MAX);
+        for (int i = 0; i < SVGA_OTABLE_MAX; ++i)
+        {
+            VMSVGAGBO *pGbo = &pSVGAState->aGboOTables[i];
+            rc = vmsvgaR3SaveGbo(pDevIns, pSSM, pGbo);
+            AssertRCReturn(rc, rc);
+        }
+
+        /*
+         * MOBs.
+         */
+        PVMSVGAMOB pIter;
+        RTListForEach(&pSVGAState->MOBLRUList, pIter, VMSVGAMOB, nodeLRU)
+        {
+            pHlp->pfnSSMPutU32(pSSM, pIter->Core.Key); /* MOB id. */
+            rc = vmsvgaR3SaveGbo(pDevIns, pSSM, &pIter->Gbo);
+            AssertRCReturn(rc, rc);
+        }
+
+        pHlp->pfnSSMPutU32(pSSM, SVGA_ID_INVALID); /* End marker. */
+
+# ifdef VMSVGA3D_DX
+        if (pThis->svga.f3DEnabled)
+        {
+            pHlp->pfnSSMPutU32(pSSM, pSVGAState->idDXContextCurrent);
+        }
+# endif
     }
 

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.h

@@ -616 +616 @@
 #define VMSVGA_IS_GBO_CREATED(a_Gbo) ((a_Gbo)->paDescriptors != NULL)
 
+int vmsvgaR3OTableReadSurface(PVMSVGAR3STATE pSvgaR3State, uint32_t sid, SVGAOTableSurfaceEntry *pEntrySurface);
+
 /* MOB is also a GBO.
  */
@@ -626 +628 @@
 typedef VMSVGAMOB const *PCVMSVGAMOB;
 
+PVMSVGAMOB vmsvgaR3MobGet(PVMSVGAR3STATE pSvgaR3State, SVGAMobId RT_UNTRUSTED_GUEST mobid);
 int vmsvgaR3MobBackingStoreCreate(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob, uint32_t cbValid);
 void vmsvgaR3MobBackingStoreDelete(PVMSVGAR3STATE pSvgaR3State, PVMSVGAMOB pMob);

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx-savedstate.cpp

@@ -134 +134 @@
     AssertReturn(u32 == RT_ELEMENTS(pDXContext->aCOTMobs), VERR_INVALID_STATE);
 
-    for (int i = 0; i < RT_ELEMENTS(pDXContext->aCOTMobs); ++i)
+    for (unsigned i = 0; i < RT_ELEMENTS(pDXContext->aCOTMobs); ++i)
     {
         rc = pHlp->pfnSSMGetU32(pSSM, &u32);
@@ -165 +165 @@
 
     AssertCompile(RT_ELEMENTS(cot) == RT_ELEMENTS(pDXContext->aCOTMobs));
-    for (int i = 0; i < RT_ELEMENTS(cot); ++i)
+    for (unsigned i = 0; i < RT_ELEMENTS(cot); ++i)
     {
         uint32_t cEntries;
@@ -367 +367 @@
     rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pDXContext->aCOTMobs));
     AssertLogRelRCReturn(rc, rc);
-    for (int i = 0; i < RT_ELEMENTS(pDXContext->aCOTMobs); ++i)
+    for (unsigned i = 0; i < RT_ELEMENTS(pDXContext->aCOTMobs); ++i)
     {
         uint32_t const mobId = vmsvgaR3MobId(pDXContext->aCOTMobs[i]);
@@ -396 +396 @@
 
     AssertCompile(RT_ELEMENTS(cot) == RT_ELEMENTS(pDXContext->aCOTMobs));
-    for (int i = 0; i < RT_ELEMENTS(cot); ++i)
+    for (unsigned i = 0; i < RT_ELEMENTS(cot); ++i)
     {
         pHlp->pfnSSMPutU32(pSSM, cot[i].cEntries);

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-dx.cpp

@@ -121 +121 @@
         ;
 
+    LogFunc(("cid = %d, state = 0x%08X\n", cid, u32TrackedState));
 
     if (u32TrackedState & DX_STATE_VS)
@@ -438 +439 @@
 
     rc = pSvgaR3State->pFuncsDX->pfnDXDestroyContext(pThisCC, pDXContext);
+
+    RT_ZERO(*pDXContext);
+    pDXContext->cid = SVGA3D_INVALID_ID;
+
     return rc;
 }

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win-dx.cpp

@@ -1837 +1837 @@
         pSurface->pBackendSurface = pBackendSurface;
         pSurface->idAssociatedContext = DX_CID_BACKEND;
-        pSurface->fDirty = true;
         return VINF_SUCCESS;
     }
@@ -1927 +1926 @@
          * Create the texture in backend device and open for the specified context.
          */
+        D3D11_SUBRESOURCE_DATA *paInitialData = NULL;
+        D3D11_SUBRESOURCE_DATA aInitialData[SVGA3D_MAX_MIP_LEVELS];
+        if (pSurface->paMipmapLevels[0].pSurfaceData)
+        {
+            /** @todo Can happen for a non GBO surface or if GBO texture was updated prior to creation if the hardware resource. Test this. */
+            for (uint32_t i = 0; i < numMipLevels; ++i)
+            {
+                PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
+                D3D11_SUBRESOURCE_DATA *p = &aInitialData[i];
+                p->pSysMem          = pMipmapLevel->pSurfaceData;
+                p->SysMemPitch      = pMipmapLevel->cbSurfacePitch;
+                p->SysMemSlicePitch = pMipmapLevel->cbSurfacePlane;
+            }
+            paInitialData = &aInitialData[0];
+        }
+
         D3D11_TEXTURE2D_DESC td;
         RT_ZERO(td);
@@ -1942 +1957 @@
         td.MiscFlags          = MiscFlags;
 
-        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.pTexture2D);
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.pTexture2D);
         Assert(SUCCEEDED(hr));
         if (SUCCEEDED(hr))
@@ -1951 +1966 @@
             td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
             td.MiscFlags      = 0;
-            hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->pDynamicTexture);
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pDynamicTexture);
             Assert(SUCCEEDED(hr));
         }
@@ -1961 +1976 @@
             td.BindFlags      = 0; /* No flags allowed. */
             td.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
-            hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->pStagingTexture);
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pStagingTexture);
             Assert(SUCCEEDED(hr));
         }
@@ -2525 +2540 @@
 
         pInitialData = &initialData;
-
-        pMipLevel->fDirty = false;
-        pSurface->fDirty = false;
     }
 
@@ -2594 +2606 @@
         pSurface->pBackendSurface = pBackendSurface;
         pSurface->idAssociatedContext = pDXContext->cid;
-        pSurface->fDirty = true;
         return VINF_SUCCESS;
     }
@@ -2638 +2649 @@
 
         pInitialData = &initialData;
-
-        pMipLevel->fDirty = false;
-        pSurface->fDirty = false;
     }
 
@@ -5112 +5120 @@
                 if (pSurface->idAssociatedContext == pDXContext->cid)
                 {
-                    Assert(pSurface->pBackendSurface);
-                    vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
+                    if (pSurface->pBackendSurface)
+                        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
                 }
                 else if (pSurface->idAssociatedContext == DX_CID_BACKEND)
                 {
                     /* May have shared resources in this context. */
-                    Assert(pSurface->pBackendSurface);
-                    DXSHAREDTEXTURE *pSharedTexture = (DXSHAREDTEXTURE *)RTAvlU32Get(&pSurface->pBackendSurface->SharedTextureTree, pDXContext->cid);
-                    if (pSharedTexture)
+                    if (pSurface->pBackendSurface)
                     {
-                        Assert(pSharedTexture->sid == sid);
-                        RTAvlU32Remove(&pSurface->pBackendSurface->SharedTextureTree, pDXContext->cid);
-                        D3D_RELEASE(pSharedTexture->pTexture);
-                        RTMemFreeZ(pSharedTexture, sizeof(*pSharedTexture));
+                        DXSHAREDTEXTURE *pSharedTexture = (DXSHAREDTEXTURE *)RTAvlU32Get(&pSurface->pBackendSurface->SharedTextureTree, pDXContext->cid);
+                        if (pSharedTexture)
+                        {
+                            Assert(pSharedTexture->sid == sid);
+                            RTAvlU32Remove(&pSurface->pBackendSurface->SharedTextureTree, pDXContext->cid);
+                            D3D_RELEASE(pSharedTexture->pTexture);
+                            RTMemFreeZ(pSharedTexture, sizeof(*pSharedTexture));
+                        }
                     }
                 }
@@ -5937 +5947 @@
                 AssertRCReturn(rc, rc);
             }
-#if 0
-            if (pSurface->fDirty)
-            {
-                /* Get mobid for the surface and read from the MOB. */
-                SVGA3dSurfaceImageId imageId;
-                imageId.sid = paVertexBuffer[i].sid;
-                imageId.face = 0;
-                imageId.mipmap = 0;
-
-                SVGA3dBox box;
-                box.x = 0;
-                box.y = 0;
-                box.z = 0;
-                box.w = pSurface->paMipmapLevels[0].mipmapSize.width;
-                box.h = 1;
-                box.d = 1;
-
-                rc = vmsvgaR3UpdateGBSurface(pThisCC, &imageId, &box);
-                AssertRCReturn(rc, rc);
-            }
-#endif
 
             Assert(pSurface->pBackendSurface->u.pBuffer);
@@ -6003 +5992 @@
             AssertRCReturn(rc, rc);
         }
-#if 0
-        if (pSurface->fDirty)
-        {
-            /* Get mobid for the surface and read from the MOB. */
-            SVGA3dSurfaceImageId imageId;
-            imageId.sid = sid;
-            imageId.face = 0;
-            imageId.mipmap = 0;
-
-            SVGA3dBox box;
-            box.x = 0;
-            box.y = 0;
-            box.z = 0;
-            box.w = pSurface->paMipmapLevels[0].mipmapSize.width;
-            box.h = 1;
-            box.d = 1;
-
-            rc = vmsvgaR3UpdateGBSurface(pThisCC, &imageId, &box);
-            AssertRCReturn(rc, rc);
-        }
-#endif
+
         pResource = pSurface->pBackendSurface->u.pBuffer;
         enmDxgiFormat = vmsvgaDXSurfaceFormat2Dxgi(format);
@@ -7058 +7027 @@
                     continue; /* Skip uninitialized entry. */
 
+                /* Define views which were not defined yet in backend. */
                 DXVIEW *pDXView = &pBackendDXContext->paRenderTargetView[i];
                 /** @todo Verify that the pEntry content still corresponds to the view. */
                 if (pDXView->u.pView)
                     dxViewAddToList(pThisCC, pDXView);
+                else if (pDXView->enmViewType == VMSVGA3D_VIEWTYPE_NONE)
+                    dxDefineRenderTargetView(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -7087 +7059 @@
                     continue; /* Skip uninitialized entry. */
 
+                /* Define views which were not defined yet in backend. */
                 DXVIEW *pDXView = &pBackendDXContext->paDepthStencilView[i];
                 /** @todo Verify that the pEntry content still corresponds to the view. */
                 if (pDXView->u.pView)
                     dxViewAddToList(pThisCC, pDXView);
+                else if (pDXView->enmViewType == VMSVGA3D_VIEWTYPE_NONE)
+                    dxDefineDepthStencilView(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -7116 +7091 @@
                     continue; /* Skip uninitialized entry. */
 
+                /* Define views which were not defined yet in backend. */
                 DXVIEW *pDXView = &pBackendDXContext->paShaderResourceView[i];
                 /** @todo Verify that the pEntry content still corresponds to the view. */
                 if (pDXView->u.pView)
                     dxViewAddToList(pThisCC, pDXView);
+                else if (pDXView->enmViewType == VMSVGA3D_VIEWTYPE_NONE)
+                    dxDefineShaderResourceView(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -7841 +7819 @@
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXLoadState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM)
+{
+    RT_NOREF(pThisCC);
+    uint32_t u32;
+    int rc;
+
+    rc = pHlp->pfnSSMGetU32(pSSM, &u32);
+    AssertLogRelRCReturn(rc, rc);
+    AssertLogRelRCReturn(u32 == pDXContext->pBackendDXContext->cShader, VERR_INVALID_STATE);
+
+    for (uint32_t i = 0; i < pDXContext->pBackendDXContext->cShader; ++i)
+    {
+        DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[i];
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &u32);
+        AssertLogRelRCReturn(rc, rc);
+        AssertLogRelReturn((SVGA3dShaderType)u32 == pDXShader->enmShaderType, VERR_INVALID_STATE);
+
+        if (pDXShader->enmShaderType == SVGA3D_SHADERTYPE_INVALID)
+            continue;
+
+        pHlp->pfnSSMGetU32(pSSM, &pDXShader->soid);
+
+        pHlp->pfnSSMGetU32(pSSM, &u32);
+        pDXShader->shaderInfo.enmProgramType = (VGPU10_PROGRAM_TYPE)u32;
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &pDXShader->shaderInfo.cbBytecode);
+        AssertLogRelRCReturn(rc, rc);
+        AssertLogRelReturn(pDXShader->shaderInfo.cbBytecode <= 2 * SVGA3D_MAX_SHADER_MEMORY_BYTES, VERR_INVALID_STATE);
+
+        pDXShader->shaderInfo.pvBytecode = RTMemAlloc(pDXShader->shaderInfo.cbBytecode);
+        AssertPtrReturn(pDXShader->shaderInfo.pvBytecode, VERR_NO_MEMORY);
+        pHlp->pfnSSMGetMem(pSSM, pDXShader->shaderInfo.pvBytecode, pDXShader->shaderInfo.cbBytecode);
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &pDXShader->shaderInfo.cInputSignature);
+        AssertLogRelRCReturn(rc, rc);
+        AssertLogRelReturn(pDXShader->shaderInfo.cInputSignature <= 32, VERR_INVALID_STATE);
+        pHlp->pfnSSMGetMem(pSSM, pDXShader->shaderInfo.aInputSignature, pDXShader->shaderInfo.cInputSignature * sizeof(SVGA3dDXSignatureEntry));
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &pDXShader->shaderInfo.cOutputSignature);
+        AssertLogRelRCReturn(rc, rc);
+        AssertLogRelReturn(pDXShader->shaderInfo.cOutputSignature <= 32, VERR_INVALID_STATE);
+        pHlp->pfnSSMGetMem(pSSM, pDXShader->shaderInfo.aOutputSignature, pDXShader->shaderInfo.cOutputSignature * sizeof(SVGA3dDXSignatureEntry));
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &pDXShader->shaderInfo.cPatchConstantSignature);
+        AssertLogRelRCReturn(rc, rc);
+        AssertLogRelReturn(pDXShader->shaderInfo.cPatchConstantSignature <= 32, VERR_INVALID_STATE);
+        pHlp->pfnSSMGetMem(pSSM, pDXShader->shaderInfo.aPatchConstantSignature, pDXShader->shaderInfo.cPatchConstantSignature * sizeof(SVGA3dDXSignatureEntry));
+
+        rc = pHlp->pfnSSMGetU32(pSSM, &pDXShader->shaderInfo.cDclResource);
+        AssertLogRelRCReturn(rc, rc);
+        AssertLogRelReturn(pDXShader->shaderInfo.cDclResource <= SVGA3D_DX_MAX_SRVIEWS, VERR_INVALID_STATE);
+        pHlp->pfnSSMGetMem(pSSM, pDXShader->shaderInfo.aOffDclResource, pDXShader->shaderInfo.cDclResource * sizeof(uint32_t));
+    }
+
+    rc = pHlp->pfnSSMGetU32(pSSM, &pDXContext->pBackendDXContext->cSOTarget);
+    AssertLogRelRCReturn(rc, rc);
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXSaveState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM)
+{
+    RT_NOREF(pThisCC);
+    int rc;
+
+    pHlp->pfnSSMPutU32(pSSM, pDXContext->pBackendDXContext->cShader);
+    for (uint32_t i = 0; i < pDXContext->pBackendDXContext->cShader; ++i)
+    {
+        DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[i];
+
+        pHlp->pfnSSMPutU32(pSSM, (uint32_t)pDXShader->enmShaderType);
+        if (pDXShader->enmShaderType == SVGA3D_SHADERTYPE_INVALID)
+            continue;
+
+        pHlp->pfnSSMPutU32(pSSM, pDXShader->soid);
+
+        pHlp->pfnSSMPutU32(pSSM, (uint32_t)pDXShader->shaderInfo.enmProgramType);
+        pHlp->pfnSSMPutU32(pSSM, pDXShader->shaderInfo.cbBytecode);
+        pHlp->pfnSSMPutMem(pSSM, pDXShader->shaderInfo.pvBytecode, pDXShader->shaderInfo.cbBytecode);
+        pHlp->pfnSSMPutU32(pSSM, pDXShader->shaderInfo.cInputSignature);
+        pHlp->pfnSSMPutMem(pSSM, pDXShader->shaderInfo.aInputSignature, pDXShader->shaderInfo.cInputSignature * sizeof(SVGA3dDXSignatureEntry));
+        pHlp->pfnSSMPutU32(pSSM, pDXShader->shaderInfo.cOutputSignature);
+        pHlp->pfnSSMPutMem(pSSM, pDXShader->shaderInfo.aOutputSignature, pDXShader->shaderInfo.cOutputSignature * sizeof(SVGA3dDXSignatureEntry));
+        pHlp->pfnSSMPutU32(pSSM, pDXShader->shaderInfo.cPatchConstantSignature);
+        pHlp->pfnSSMPutMem(pSSM, pDXShader->shaderInfo.aPatchConstantSignature, pDXShader->shaderInfo.cPatchConstantSignature * sizeof(SVGA3dDXSignatureEntry));
+        pHlp->pfnSSMPutU32(pSSM, pDXShader->shaderInfo.cDclResource);
+        pHlp->pfnSSMPutMem(pSSM, pDXShader->shaderInfo.aOffDclResource, pDXShader->shaderInfo.cDclResource * sizeof(uint32_t));
+    }
+    rc = pHlp->pfnSSMPutU32(pSSM, pDXContext->pBackendDXContext->cSOTarget);
+    AssertLogRelRCReturn(rc, rc);
+
+    return VINF_SUCCESS;
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackQueryInterface(PVGASTATECC pThisCC, char const *pszInterfaceName, void *pvInterfaceFuncs, size_t cbInterfaceFuncs)
 {
@@ -7853 +7928 @@
             {
                 VMSVGA3DBACKENDFUNCSDX *p = (VMSVGA3DBACKENDFUNCSDX *)pvInterfaceFuncs;
+                p->pfnDXSaveState                 = vmsvga3dBackDXSaveState;
+                p->pfnDXLoadState                 = vmsvga3dBackDXLoadState;
                 p->pfnDXDefineContext             = vmsvga3dBackDXDefineContext;
                 p->pfnDXDestroyContext            = vmsvga3dBackDXDestroyContext;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.h

@@ -394 +394 @@
 typedef struct
 {
+    DECLCALLBACKMEMBER(int, pfnDXSaveState,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM));
+    DECLCALLBACKMEMBER(int, pfnDXLoadState,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PCPDMDEVHLPR3 pHlp, PSSMHANDLE pSSM));
     DECLCALLBACKMEMBER(int, pfnDXDefineContext,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXDestroyContext,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -642 +644 @@
 int vmsvga3dSurfaceStretchBltNonMSToMS(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXBindShaderIface(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+int vmsvga3dDXSaveExec(PPDMDEVINS pDevIns, PVGASTATECC pThisCC, PSSMHANDLE pSSM);
 #endif /* VMSVGA3D_DX */
 

trunk/src/VBox/Devices/Graphics/DevVGASavedState.h

@@ -47 +47 @@
     } while (0)
 
-#define VGA_SAVEDSTATE_VERSION                   23
+#define VGA_SAVEDSTATE_VERSION                   24
+#define VGA_SAVEDSTATE_VERSION_VMSVGA_DX         24 /* VGPU10. */
 #define VGA_SAVEDSTATE_VERSION_VMSVGA_MIPLEVELS  23 /* Surface struct with number of miplevels. */
 #define VGA_SAVEDSTATE_VERSION_VMSVGA_CURSOR     22 /* Legacy cursor registers. */

trunk/src/VBox/Devices/Makefile.kmk

@@ -337 +337 @@
    VBoxDD_SOURCES       += \
        Graphics/DevVGA-SVGA3d-dx.cpp \
+       Graphics/DevVGA-SVGA3d-dx-savedstate.cpp \
        Graphics/DevVGA-SVGA3d-dx-shader.cpp
    if "$(KBUILD_TARGET)" == "win" || defined(VBOX_WITH_DXVK)