Changeset 82114 in vbox for trunk/src

Timestamp:

Nov 22, 2019 11:05:31 PM (5 years ago)

Author:

vboxsync

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

134924

Message:

DevVGA: Splitting up the VMSVGASTATE structure. bugref:9218

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA.cpp (modified) (120 diffs)
• DevVGA-SVGA.h (modified) (4 diffs)
• DevVGA-SVGA3d-info.cpp (modified) (5 diffs)
• DevVGA-SVGA3d-internal.h (modified) (1 diff)
• DevVGA-SVGA3d-ogl.cpp (modified) (70 diffs)
• DevVGA-SVGA3d-savedstate.cpp (modified) (24 diffs)
• DevVGA-SVGA3d-win.cpp (modified) (46 diffs)
• DevVGA-SVGA3d.cpp (modified) (14 diffs)
• DevVGA-SVGA3d.h (modified) (3 diffs)
• DevVGA.cpp (modified) (9 diffs)
• DevVGA.h (modified) (4 diffs)

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

@@ -497 +497 @@
 static SSMFIELD const g_aVGAStateSVGAFields[] =
 {
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOR3),
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOR0),
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pSvgaR3State),
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, p3dState),
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pbVgaFrameBufferR3),
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pvFIFOExtCmdParam),
     SSMFIELD_ENTRY_IGN_GCPHYS(      VMSVGAState, GCPhysFIFO),
     SSMFIELD_ENTRY_IGNORE(          VMSVGAState, cbFIFO),
@@ -521 +515 @@
     SSMFIELD_ENTRY(                 VMSVGAState, u32IndexReg),
     SSMFIELD_ENTRY_IGNORE(          VMSVGAState, hFIFORequestSem),
-    SSMFIELD_ENTRY_IGNORE(          VMSVGAState, hFIFOExtCmdSem),
-    SSMFIELD_ENTRY_IGN_HCPTR(       VMSVGAState, pFIFOIOThread),
     SSMFIELD_ENTRY_IGNORE(          VMSVGAState, uLastCursorUpdateCount),
     SSMFIELD_ENTRY_IGNORE(          VMSVGAState, fFIFOThreadSleeping),
@@ -549 +541 @@
 #ifdef IN_RING3
 static void vmsvgaR3SetTraces(PPDMDEVINS pDevIns, PVGASTATE pThis, bool fTraces);
-static int vmsvgaR3LoadExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
-static int vmsvgaR3SaveExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM);
+static int vmsvgaR3LoadExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM,
+                                uint32_t uVersion, uint32_t uPass);
+static int vmsvgaR3SaveExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATECC pThisCC, PSSMHANDLE pSSM);
+static void vmsvgaR3GmrFree(PVGASTATECC pThisCC, uint32_t idGMR);
 #endif /* IN_RING3 */
 
@@ -556 +550 @@
 
 #ifdef IN_RING3
-VMSVGASCREENOBJECT *vmsvgaR3GetScreenObject(PVGASTATE pThis, uint32_t idScreen)
+VMSVGASCREENOBJECT *vmsvgaR3GetScreenObject(PVGASTATECC pThisCC, uint32_t idScreen)
 {
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     if (   idScreen < (uint32_t)RT_ELEMENTS(pSVGAState->aScreens)
         && pSVGAState
@@ -725 +719 @@
 
     /** @todo Test how it interacts with multiple screen objects. */
-    VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, idScreen);
+    VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThisCC, idScreen);
     uint32_t const uWidth = pScreen ? pScreen->cWidth : 0;
     uint32_t const uHeight = pScreen ? pScreen->cHeight : 0;
@@ -761 +755 @@
      */
     if (pThis->svga.f3DEnabled)
-        vmsvga3dUpdateHostScreenViewport(pThis, idScreen, &OldViewport);
+        vmsvga3dUpdateHostScreenViewport(pThisCC, idScreen, &OldViewport);
 # else
     RT_NOREF(OldViewport);
@@ -1078 +1072 @@
                 /* The guest is basically doing a HLT via the device here, but with
                    a special wake up condition on FIFO completion. */
-                PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+                PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
                 STAM_REL_PROFILE_START(&pSVGAState->StatBusyDelayEmts, EmtDelay);
                 PVM         pVM   = PDMDevHlpGetVM(pDevIns);
@@ -1097 +1091 @@
                    This used to be a crude 50 ms sleep. The current code tries to be
                    more efficient, but the consept is still very crude. */
-                PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+                PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
                 STAM_REL_PROFILE_START(&pSVGAState->StatBusyDelayEmts, EmtDelay);
                 RTThreadYield();
@@ -1300 +1294 @@
 
     /* Always do changemode on FIFO thread. */
-    Assert(RTThreadSelf() == pThis->svga.pFIFOIOThread->Thread);
-
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+    Assert(RTThreadSelf() == pThisCC->svga.pFIFOIOThread->Thread);
+
+    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
 
     pThisCC->pDrv->pfnLFBModeChange(pThisCC->pDrv, true);
@@ -1444 +1438 @@
  * Safely updates the SVGA_FIFO_BUSY register (in shared memory).
  *
- * @param   pThis               The VMSVGA state.
- * @param   fState              The busy state.
+ * @param   pThis       The shared VGA/VMSVGA instance data.
+ * @param   pThisCC     The VGA/VMSVGA state for the current context.
+ * @param   fState      The busy state.
  */
-DECLINLINE(void) vmsvgaHCSafeFifoBusyRegUpdate(PVGASTATE pThis, bool fState)
+DECLINLINE(void) vmsvgaHCSafeFifoBusyRegUpdate(PVGASTATE pThis, PVGASTATECC pThisCC, bool fState)
 {
-    ASMAtomicWriteU32(&pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_BUSY], fState);
+    ASMAtomicWriteU32(&pThisCC->svga.pau32FIFO[SVGA_FIFO_BUSY], fState);
 
     if (RT_UNLIKELY(fState != (pThis->svga.fBusy != 0)))
@@ -1459 +1454 @@
             ASMNopPause();
             fState = (pThis->svga.fBusy != 0);
-            ASMAtomicWriteU32(&pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_BUSY], fState != 0);
+            ASMAtomicWriteU32(&pThisCC->svga.pau32FIFO[SVGA_FIFO_BUSY], fState != 0);
         } while (cLoops-- > 0 && fState != (pThis->svga.fBusy != 0));
     }
@@ -1470 +1465 @@
  *
  * @param   pThis       The shared VGA/VMSVGA state.
+ * @param   pThisCC     The VGA/VMSVGA state for the current context.
  */
-DECLINLINE(void) vmsvgaHCUpdatePitch(PVGASTATE pThis)
+DECLINLINE(void) vmsvgaHCUpdatePitch(PVGASTATE pThis, PVGASTATECC pThisCC)
 {
-    uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO = pThis->svga.CTX_SUFF(pFIFO);
+    uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO = pThisCC->svga.pau32FIFO;
     uint32_t uFifoPitchLock = pFIFO[SVGA_FIFO_PITCHLOCK];
     uint32_t uRegPitchLock  = pThis->svga.u32PitchLock;
@@ -1518 +1514 @@
 {
 #ifdef IN_RING3
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
 #endif
     VBOXSTRICTRC rc = VINF_SUCCESS;
@@ -1576 +1572 @@
                 /* Make a backup copy of the first 512kb in order to save font data etc. */
                 /** @todo should probably swap here, rather than copy + zero */
-                memcpy(pThis->svga.pbVgaFrameBufferR3, pThisCC->pbVRam, VMSVGA_VGA_FB_BACKUP_SIZE);
+                memcpy(pThisCC->svga.pbVgaFrameBufferR3, pThisCC->pbVRam, VMSVGA_VGA_FB_BACKUP_SIZE);
                 memset(pThisCC->pbVRam, 0, VMSVGA_VGA_FB_BACKUP_SIZE);
             }
@@ -1598 +1594 @@
                     ASMAtomicOrU32(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE);
 # ifdef LOG_ENABLED
-                uint32_t *pFIFO = pThis->svga.pFIFOR3;
+                uint32_t *pFIFO = pThisCC->svga.pau32FIFO;
                 Log(("configured=%d busy=%d\n", pThis->svga.fConfigured, pFIFO[SVGA_FIFO_BUSY]));
                 Log(("next %x stop %x\n", pFIFO[SVGA_FIFO_NEXT_CMD], pFIFO[SVGA_FIFO_STOP]));
@@ -1613 +1609 @@
             {
                 /* Restore the text mode backup. */
-                memcpy(pThisCC->pbVRam, pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
+                memcpy(pThisCC->pbVRam, pThisCC->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
 
                 pThisCC->pDrv->pfnLFBModeChange(pThisCC->pDrv, false);
@@ -1638 +1634 @@
 #if defined(IN_RING3) || defined(IN_RING0)
                 pThis->svga.uWidth = u32;
-                vmsvgaHCUpdatePitch(pThis);
+                vmsvgaHCUpdatePitch(pThis, pThisCC);
                 if (pThis->svga.fEnabled)
                     ASMAtomicOrU32(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE);
@@ -1670 +1666 @@
 #if defined(IN_RING3) || defined(IN_RING0)
                 pThis->svga.uBpp = u32;
-                vmsvgaHCUpdatePitch(pThis);
+                vmsvgaHCUpdatePitch(pThis, pThisCC);
                 if (pThis->svga.fEnabled)
                     ASMAtomicOrU32(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE);
@@ -1703 +1699 @@
             {
 #if defined(IN_RING3) || defined(IN_RING0)
-                Log(("SVGA_REG_SYNC: SVGA_FIFO_BUSY=%d\n", pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_BUSY]));
+                Log(("SVGA_REG_SYNC: SVGA_FIFO_BUSY=%d\n", pThisCC->svga.pau32FIFO[SVGA_FIFO_BUSY]));
                 ASMAtomicWriteU32(&pThis->svga.fBusy, VMSVGA_BUSY_F_EMT_FORCE | VMSVGA_BUSY_F_FIFO);
-                if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_BUSY, pThis->svga.CTX_SUFF(pFIFO)[SVGA_FIFO_MIN]))
-                    vmsvgaHCSafeFifoBusyRegUpdate(pThis, true);
+                if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_BUSY, pThisCC->svga.pau32FIFO[SVGA_FIFO_MIN]))
+                    vmsvgaHCSafeFifoBusyRegUpdate(pThis, pThisCC, true);
 
                 /* Kick the FIFO thread to start processing commands again. */
@@ -1800 +1796 @@
 
             /* Free the old GMR if present. */
-            vmsvgaR3GmrFree(pThis, idGMR);
+            vmsvgaR3GmrFree(pThisCC, idGMR);
 
             /* Just undefine the GMR? */
@@ -2065 +2061 @@
     RT_NOREF(pVM);
     RTGCPHYS GCPhysOffset = GCPhys - pThis->svga.GCPhysFIFO;
-    uint32_t *pFIFO = pThis->svga.pFIFOR3;
+    uint32_t *pFIFO = pThisCC->svga.pau32FIFO;
 
     switch (GCPhysOffset >> 2)
@@ -2436 +2432 @@
      * Temporarily disable the access handler now that we've kicked the FIFO thread.
      */
-    STAM_REL_COUNTER_INC(&pThis->svga.pSvgaR3State->StatFifoAccessHandler);
+    STAM_REL_COUNTER_INC(&pThisCC->svga.pSvgaR3State->StatFifoAccessHandler);
     rc = PGMHandlerPhysicalPageTempOff(pVM, pThis->svga.GCPhysFIFO, pThis->svga.GCPhysFIFO);
 # endif
@@ -2472 +2468 @@
     PVGASTATE   pThis = (PVGASTATE)pvUser;
     Assert(pThis);
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
     NOREF(pVCpu); NOREF(pvPhys); NOREF(pvBuf); NOREF(cbBuf); NOREF(enmAccessType); NOREF(enmOrigin);
 
@@ -2507 +2503 @@
 {
     PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     PGMR pGMR = &pSVGAState->paGMR[gmrId];
     int rc;
@@ -2525 +2521 @@
 {
     PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     PGMR pGMR = &pSVGAState->paGMR[gmrId];
 
@@ -2539 +2535 @@
 static DECLCALLBACK(int) vmsvgaR3ResetGmrHandlers(PVGASTATE pThis)
 {
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
 
     for (uint32_t i = 0; i < pThis->svga.cGMR; ++i)
@@ -2903 +2899 @@
         case VMSVGA_FIFO_EXTCMD_RESET:
             Log(("vmsvgaR3FifoLoop: reset the fifo thread.\n"));
-            Assert(pThis->svga.pvFIFOExtCmdParam == NULL);
+            Assert(pThisCC->svga.pvFIFOExtCmdParam == NULL);
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
             {
                 /* The 3d subsystem must be reset from the fifo thread. */
-                vmsvga3dReset(pThis);
+                vmsvga3dReset(pThisCC);
             }
 # endif
@@ -2915 +2911 @@
         case VMSVGA_FIFO_EXTCMD_TERMINATE:
             Log(("vmsvgaR3FifoLoop: terminate the fifo thread.\n"));
-            Assert(pThis->svga.pvFIFOExtCmdParam == NULL);
+            Assert(pThisCC->svga.pvFIFOExtCmdParam == NULL);
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
             {
                 /* The 3d subsystem must be shut down from the fifo thread. */
-                vmsvga3dTerminate(pThis);
+                vmsvga3dTerminate(pThisCC);
             }
 # endif
@@ -2928 +2924 @@
         {
             Log(("vmsvgaR3FifoLoop: VMSVGA_FIFO_EXTCMD_SAVESTATE.\n"));
-            PSSMHANDLE pSSM = (PSSMHANDLE)pThis->svga.pvFIFOExtCmdParam;
+            PSSMHANDLE pSSM = (PSSMHANDLE)pThisCC->svga.pvFIFOExtCmdParam;
             AssertLogRelMsgBreak(RT_VALID_PTR(pSSM), ("pSSM=%p\n", pSSM));
-            vmsvgaR3SaveExecFifo(pDevIns->pHlpR3, pThis, pSSM);
+            vmsvgaR3SaveExecFifo(pDevIns->pHlpR3, pThisCC, pSSM);
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
-                vmsvga3dSaveExec(pDevIns, pThis, pSSM);
+                vmsvga3dSaveExec(pDevIns, pThisCC, pSSM);
 # endif
             break;
@@ -2941 +2937 @@
         {
             Log(("vmsvgaR3FifoLoop: VMSVGA_FIFO_EXTCMD_LOADSTATE.\n"));
-            PVMSVGA_STATE_LOAD pLoadState = (PVMSVGA_STATE_LOAD)pThis->svga.pvFIFOExtCmdParam;
+            PVMSVGA_STATE_LOAD pLoadState = (PVMSVGA_STATE_LOAD)pThisCC->svga.pvFIFOExtCmdParam;
             AssertLogRelMsgBreak(RT_VALID_PTR(pLoadState), ("pLoadState=%p\n", pLoadState));
-            vmsvgaR3LoadExecFifo(pDevIns->pHlpR3, pThis, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
+            vmsvgaR3LoadExecFifo(pDevIns->pHlpR3, pThis, pThisCC, pLoadState->pSSM, pLoadState->uVersion, pLoadState->uPass);
 # ifdef VBOX_WITH_VMSVGA3D
             if (pThis->svga.f3DEnabled)
@@ -2954 +2950 @@
         {
 # ifdef VBOX_WITH_VMSVGA3D
-            uint32_t sid = (uint32_t)(uintptr_t)pThis->svga.pvFIFOExtCmdParam;
+            uint32_t sid = (uint32_t)(uintptr_t)pThisCC->svga.pvFIFOExtCmdParam;
             Log(("vmsvgaR3FifoLoop: VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS sid=%#x\n", sid));
-            vmsvga3dUpdateHeapBuffersForSurfaces(pThis, sid);
+            vmsvga3dUpdateHeapBuffersForSurfaces(pThisCC, sid);
 # endif
             break;
@@ -2963 +2959 @@
 
         default:
-            AssertLogRelMsgFailed(("uExtCmd=%#x pvFIFOExtCmdParam=%p\n", uExtCmd, pThis->svga.pvFIFOExtCmdParam));
+            AssertLogRelMsgFailed(("uExtCmd=%#x pvFIFOExtCmdParam=%p\n", uExtCmd, pThisCC->svga.pvFIFOExtCmdParam));
             break;
     }
@@ -2970 +2966 @@
      * Signal the end of the external command.
      */
-    pThis->svga.pvFIFOExtCmdParam = NULL;
+    pThisCC->svga.pvFIFOExtCmdParam = NULL;
     pThis->svga.u8FIFOExtCommand  = VMSVGA_FIFO_EXTCMD_NONE;
     ASMMemoryFence(); /* paranoia^2 */
-    int rc = RTSemEventSignal(pThis->svga.hFIFOExtCmdSem);
+    int rc = RTSemEventSignal(pThisCC->svga.hFIFOExtCmdSem);
     AssertLogRelRC(rc);
 }
@@ -2984 +2980 @@
  * @param   pDevIns         The device instance.
  * @param   pThis           The shared VGA/VMSVGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   uExtCmd         The command to execute on the FIFO thread.
  * @param   pvParam         Pointer to command parameters.
@@ -2989 +2986 @@
  *                          milliseconds.
  */
-static int vmsvgaR3RunExtCmdOnFifoThread(PPDMDEVINS pDevIns, PVGASTATE pThis,
+static int vmsvgaR3RunExtCmdOnFifoThread(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC,
                                          uint8_t uExtCmd, void *pvParam, RTMSINTERVAL cMsWait)
 {
@@ -2997 +2994 @@
 
     int rc;
-    PPDMTHREAD      pThread  = pThis->svga.pFIFOIOThread;
+    PPDMTHREAD      pThread  = pThisCC->svga.pFIFOIOThread;
     PDMTHREADSTATE  enmState = pThread->enmState;
     if (enmState == PDMTHREADSTATE_SUSPENDED)
@@ -3009 +3006 @@
         /* Post the request. */
         pThis->svga.fFifoExtCommandWakeup = true;
-        pThis->svga.pvFIFOExtCmdParam     = pvParam;
+        pThisCC->svga.pvFIFOExtCmdParam     = pvParam;
         pThis->svga.u8FIFOExtCommand      = uExtCmd;
         ASMMemoryFence(); /* paranoia^3 */
@@ -3019 +3016 @@
         {
             /* Wait. Take care in case the semaphore was already posted (same as below). */
-            rc = RTSemEventWait(pThis->svga.hFIFOExtCmdSem, cMsWait);
+            rc = RTSemEventWait(pThisCC->svga.hFIFOExtCmdSem, cMsWait);
             if (   rc == VINF_SUCCESS
                 && pThis->svga.u8FIFOExtCommand == uExtCmd)
-                rc = RTSemEventWait(pThis->svga.hFIFOExtCmdSem, cMsWait);
+                rc = RTSemEventWait(pThisCC->svga.hFIFOExtCmdSem, cMsWait);
             AssertLogRelMsg(pThis->svga.u8FIFOExtCommand != uExtCmd || RT_FAILURE_NP(rc),
                             ("%#x %Rrc\n", pThis->svga.u8FIFOExtCommand, rc));
@@ -3034 +3031 @@
         }
         pThis->svga.fFifoExtCommandWakeup = false;
-        pThis->svga.pvFIFOExtCmdParam     = NULL;
+        pThisCC->svga.pvFIFOExtCmdParam     = NULL;
     }
     else if (enmState == PDMTHREADSTATE_RUNNING)
@@ -3046 +3043 @@
 
         /* Post the request. */
-        pThis->svga.pvFIFOExtCmdParam = pvParam;
+        pThisCC->svga.pvFIFOExtCmdParam = pvParam;
         pThis->svga.u8FIFOExtCommand  = uExtCmd;
         ASMMemoryFence(); /* paranoia^2 */
@@ -3053 +3050 @@
 
         /* Wait. Take care in case the semaphore was already posted (same as above). */
-        rc = RTSemEventWait(pThis->svga.hFIFOExtCmdSem, cMsWait);
+        rc = RTSemEventWait(pThisCC->svga.hFIFOExtCmdSem, cMsWait);
         if (   rc == VINF_SUCCESS
             && pThis->svga.u8FIFOExtCommand == uExtCmd)
-            rc = RTSemEventWait(pThis->svga.hFIFOExtCmdSem, cMsWait); /* it was already posted, retry the wait. */
+            rc = RTSemEventWait(pThisCC->svga.hFIFOExtCmdSem, cMsWait); /* it was already posted, retry the wait. */
         AssertLogRelMsg(pThis->svga.u8FIFOExtCommand != uExtCmd || RT_FAILURE_NP(rc),
                         ("%#x %Rrc\n", pThis->svga.u8FIFOExtCommand, rc));
 
-        pThis->svga.pvFIFOExtCmdParam = NULL;
+        pThisCC->svga.pvFIFOExtCmdParam = NULL;
     }
     else
@@ -3079 +3076 @@
  * @param   pDevIns         The device instance.
  * @param   pThis           The shared VGA/VMSVGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   pSVGAState      Pointer to the ring-3 only SVGA state data.
  * @param   offFifoMin      The start byte offset of the command FIFO.
  */
-static void vmsvgaR3FifoSetNotBusy(PPDMDEVINS pDevIns, PVGASTATE pThis, PVMSVGAR3STATE pSVGAState, uint32_t offFifoMin)
+static void vmsvgaR3FifoSetNotBusy(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGAR3STATE pSVGAState, uint32_t offFifoMin)
 {
     ASMAtomicAndU32(&pThis->svga.fBusy, ~VMSVGA_BUSY_F_FIFO);
     if (VMSVGA_IS_VALID_FIFO_REG(SVGA_FIFO_BUSY, offFifoMin))
-        vmsvgaHCSafeFifoBusyRegUpdate(pThis, pThis->svga.fBusy != 0);
+        vmsvgaHCSafeFifoBusyRegUpdate(pThis, pThisCC, pThis->svga.fBusy != 0);
 
     /* Wake up any waiting EMTs. */
@@ -3361 +3359 @@
  * Called by the VGA refresh timer to wake up the FIFO thread when needed.
  *
- * @param   pThis   The shared VGA/VMSVGA instance data.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The shared VGA/VMSVGA instance data.
+ * @param   pThisCC     The VGA/VMSVGA state for ring-3.
  */
-void vmsvgaR3FifoWatchdogTimer(PPDMDEVINS pDevIns, PVGASTATE pThis)
+void vmsvgaR3FifoWatchdogTimer(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     /* Caller already checked pThis->svga.fFIFOThreadSleeping, so we only have
        to recheck it before doing the signalling. */
-    uint32_t RT_UNTRUSTED_VOLATILE_GUEST * const pFIFO = pThis->svga.pFIFOR3;
+    uint32_t RT_UNTRUSTED_VOLATILE_GUEST * const pFIFO = pThisCC->svga.pau32FIFO;
     AssertReturnVoid(pFIFO);
     if (   vmsvgaR3FifoHasWork(pFIFO, ASMAtomicReadU32(&pThis->svga.uLastCursorUpdateCount))
@@ -3374 +3374 @@
         int rc = PDMDevHlpSUPSemEventSignal(pDevIns, pThis->svga.hFIFORequestSem);
         AssertRC(rc);
-        STAM_REL_COUNTER_INC(&pThis->svga.pSvgaR3State->StatFifoWatchdogWakeUps);
+        STAM_REL_COUNTER_INC(&pThisCC->svga.pSvgaR3State->StatFifoWatchdogWakeUps);
     }
 }
@@ -3386 +3386 @@
     PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVGASTATER3     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     int             rc;
 
@@ -3447 +3447 @@
      * xLastCursor, yLastCursor and fLastCursorVisible are set to report the first update.
      */
-    uint32_t RT_UNTRUSTED_VOLATILE_GUEST * const pFIFO = pThis->svga.pFIFOR3;
+    uint32_t RT_UNTRUSTED_VOLATILE_GUEST * const pFIFO = pThisCC->svga.pau32FIFO;
     pThis->svga.uLastCursorUpdateCount = pFIFO[SVGA_FIFO_CURSOR_COUNT];
     uint32_t xLastCursor        = ~pFIFO[SVGA_FIFO_CURSOR_X];
@@ -3540 +3540 @@
             || !pThis->svga.fConfigured)
         {
-            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pSVGAState, pFIFO[SVGA_FIFO_MIN]);
+            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pThisCC, pSVGAState, pFIFO[SVGA_FIFO_MIN]);
             fBadOrDisabledFifo = true;
             cMsSleep           = cMsMaxSleep; /* cheat */
@@ -3566 +3566 @@
             STAM_REL_COUNTER_INC(&pSVGAState->StatFifoErrors);
             LogRelMax(8, ("vmsvgaR3FifoLoop: Bad fifo: min=%#x stop=%#x max=%#x\n", offFifoMin, offCurrentCmd, offFifoMax));
-            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pSVGAState, offFifoMin);
+            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pThisCC, pSVGAState, offFifoMin);
             fBadOrDisabledFifo = true;
             continue;
@@ -3654 +3654 @@
                 vmsvgaR3ChangeMode(pThis, pThisCC);
 # ifdef VBOX_WITH_VMSVGA3D
-                if (pThis->svga.p3dState != NULL)
-                    vmsvga3dChangeMode(pThis);
+                if (pThisCC->svga.p3dState != NULL)
+                    vmsvga3dChangeMode(pThisCC);
 # endif
             }
@@ -3716 +3716 @@
                 Log(("vmsvgaR3FifoLoop: UPDATE (%d,%d)(%d,%d)\n", pUpdate->x, pUpdate->y, pUpdate->width, pUpdate->height));
                 /** @todo Multiple screens? */
-                VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, 0);
+                VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThisCC, 0);
                 AssertBreak(pScreen);
                 vmsvgaR3UpdateScreen(pThisCC, pScreen, pUpdate->x, pUpdate->y, pUpdate->width, pUpdate->height);
@@ -3860 +3860 @@
                 {
                     STAM_REL_COUNTER_INC(&pSVGAState->StatR3CmdDefineGmr2Free);
-                    vmsvgaR3GmrFree(pThis, pCmd->gmrId);
+                    vmsvgaR3GmrFree(pThisCC, pCmd->gmrId);
                 }
                 else
@@ -3872 +3872 @@
                     /** @todo always free the descriptor in SVGA_CMD_DEFINE_GMR2? */
                     if (pGMR->cbTotal / X86_PAGE_SIZE > pGMR->cMaxPages)
-                        vmsvgaR3GmrFree(pThis, pCmd->gmrId);
+                        vmsvgaR3GmrFree(pThisCC, pCmd->gmrId);
 
                     pGMR->cMaxPages = pCmd->numPages;
@@ -4056 +4056 @@
 
                 uint32_t const idScreen = pCmd->screen.id;
-                AssertBreak(idScreen < RT_ELEMENTS(pThis->svga.pSvgaR3State->aScreens));
+                AssertBreak(idScreen < RT_ELEMENTS(pThisCC->svga.pSvgaR3State->aScreens));
 
                 uint32_t const uWidth = pCmd->screen.size.width;
@@ -4077 +4077 @@
                 RT_UNTRUSTED_VALIDATED_FENCE();
 
-                VMSVGASCREENOBJECT *pScreen = &pThis->svga.pSvgaR3State->aScreens[idScreen];
+                VMSVGASCREENOBJECT *pScreen = &pThisCC->svga.pSvgaR3State->aScreens[idScreen];
 
                 bool const fBlank = RT_BOOL(pCmd->screen.flags & (SVGA_SCREEN_DEACTIVATE | SVGA_SCREEN_BLANKING));
@@ -4116 +4116 @@
 
                 uint32_t const idScreen = pCmd->screenId;
-                AssertBreak(idScreen < RT_ELEMENTS(pThis->svga.pSvgaR3State->aScreens));
+                AssertBreak(idScreen < RT_ELEMENTS(pThisCC->svga.pSvgaR3State->aScreens));
                 RT_UNTRUSTED_VALIDATED_FENCE();
 
-                VMSVGASCREENOBJECT *pScreen = &pThis->svga.pSvgaR3State->aScreens[idScreen];
+                VMSVGASCREENOBJECT *pScreen = &pThisCC->svga.pSvgaR3State->aScreens[idScreen];
                 pScreen->fModified = true;
                 pScreen->fDefined  = false;
@@ -4150 +4150 @@
                          pCmd->srcOrigin.x, pCmd->srcOrigin.y, pCmd->destScreenId, pCmd->destRect.left, pCmd->destRect.top, pCmd->destRect.right, pCmd->destRect.bottom));
 
-                AssertBreak(pCmd->destScreenId < RT_ELEMENTS(pThis->svga.pSvgaR3State->aScreens));
+                AssertBreak(pCmd->destScreenId < RT_ELEMENTS(pThisCC->svga.pSvgaR3State->aScreens));
                 RT_UNTRUSTED_VALIDATED_FENCE();
 
-                VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, pCmd->destScreenId);
+                VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThisCC, pCmd->destScreenId);
                 AssertBreak(pScreen);
 
@@ -4222 +4222 @@
                          pCmd->destOrigin.x, pCmd->destOrigin.y, pCmd->srcScreenId, pCmd->srcRect.left, pCmd->srcRect.top, pCmd->srcRect.right, pCmd->srcRect.bottom));
 
-                AssertBreak(pCmd->srcScreenId < RT_ELEMENTS(pThis->svga.pSvgaR3State->aScreens));
+                AssertBreak(pCmd->srcScreenId < RT_ELEMENTS(pThisCC->svga.pSvgaR3State->aScreens));
                 RT_UNTRUSTED_VALIDATED_FENCE();
 
-                VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, pCmd->srcScreenId);
+                VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThisCC, pCmd->srcScreenId);
                 AssertBreak(pScreen);
 
@@ -4348 +4348 @@
 
                         cMipLevels = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dSize);
-                        rc = vmsvga3dSurfaceDefine(pThis, pCmd->sid, (uint32_t)pCmd->surfaceFlags, pCmd->format, pCmd->face, 0,
+                        rc = vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, (uint32_t)pCmd->surfaceFlags, pCmd->format, pCmd->face, 0,
                                                    SVGA3D_TEX_FILTER_NONE, cMipLevels, (SVGA3dSize *)(pCmd + 1));
 #  ifdef DEBUG_GMR_ACCESS
@@ -4364 +4364 @@
 
                         cMipLevels = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dSize);
-                        rc = vmsvga3dSurfaceDefine(pThis, pCmd->sid, pCmd->surfaceFlags, pCmd->format, pCmd->face,
+                        rc = vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, pCmd->surfaceFlags, pCmd->format, pCmd->face,
                                                    pCmd->multisampleCount, pCmd->autogenFilter,
                                                    cMipLevels, (SVGA3dSize *)(pCmd + 1));
@@ -4375 +4375 @@
                         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSurfaceDestroy);
-                        rc = vmsvga3dSurfaceDestroy(pThis, pCmd->sid);
+                        rc = vmsvga3dSurfaceDestroy(pThisCC, pCmd->sid);
                         break;
                     }
@@ -4387 +4387 @@
 
                         cCopyBoxes = (pHdr->size - sizeof(pCmd)) / sizeof(SVGA3dCopyBox);
-                        rc = vmsvga3dSurfaceCopy(pThis, pCmd->dest, pCmd->src, cCopyBoxes, (SVGA3dCopyBox *)(pCmd + 1));
+                        rc = vmsvga3dSurfaceCopy(pThisCC, pCmd->dest, pCmd->src, cCopyBoxes, (SVGA3dCopyBox *)(pCmd + 1));
                         break;
                     }
@@ -4397 +4397 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSurfaceStretchBlt);
 
-                        rc = vmsvga3dSurfaceStretchBlt(pThis, &pCmd->dest, &pCmd->boxDest, &pCmd->src, &pCmd->boxSrc, pCmd->mode);
+                        rc = vmsvga3dSurfaceStretchBlt(pThis, pThisCC, &pCmd->dest, &pCmd->boxDest,
+                                                       &pCmd->src, &pCmd->boxSrc, pCmd->mode);
                         break;
                     }
@@ -4435 +4436 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dContextDefine);
 
-                        rc = vmsvga3dContextDefine(pThis, pCmd->cid);
+                        rc = vmsvga3dContextDefine(pThisCC, pCmd->cid);
                         break;
                     }
@@ -4445 +4446 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dContextDestroy);
 
-                        rc = vmsvga3dContextDestroy(pThis, pCmd->cid);
+                        rc = vmsvga3dContextDestroy(pThisCC, pCmd->cid);
                         break;
                     }
@@ -4455 +4456 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetTransform);
 
-                        rc = vmsvga3dSetTransform(pThis, pCmd->cid, pCmd->type, pCmd->matrix);
+                        rc = vmsvga3dSetTransform(pThisCC, pCmd->cid, pCmd->type, pCmd->matrix);
                         break;
                     }
@@ -4465 +4466 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetZRange);
 
-                        rc = vmsvga3dSetZRange(pThis, pCmd->cid, pCmd->zRange);
+                        rc = vmsvga3dSetZRange(pThisCC, pCmd->cid, pCmd->zRange);
                         break;
                     }
@@ -4477 +4478 @@
 
                         cRenderStates = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dRenderState);
-                        rc = vmsvga3dSetRenderState(pThis, pCmd->cid, cRenderStates, (SVGA3dRenderState *)(pCmd + 1));
+                        rc = vmsvga3dSetRenderState(pThisCC, pCmd->cid, cRenderStates, (SVGA3dRenderState *)(pCmd + 1));
                         break;
                     }
@@ -4487 +4488 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetRenderTarget);
 
-                        rc = vmsvga3dSetRenderTarget(pThis, pCmd->cid, pCmd->type, pCmd->target);
+                        rc = vmsvga3dSetRenderTarget(pThisCC, pCmd->cid, pCmd->type, pCmd->target);
                         break;
                     }
@@ -4499 +4500 @@
 
                         cTextureStates = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dTextureState);
-                        rc = vmsvga3dSetTextureState(pThis, pCmd->cid, cTextureStates, (SVGA3dTextureState *)(pCmd + 1));
+                        rc = vmsvga3dSetTextureState(pThisCC, pCmd->cid, cTextureStates, (SVGA3dTextureState *)(pCmd + 1));
                         break;
                     }
@@ -4509 +4510 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetMaterial);
 
-                        rc = vmsvga3dSetMaterial(pThis, pCmd->cid, pCmd->face, &pCmd->material);
+                        rc = vmsvga3dSetMaterial(pThisCC, pCmd->cid, pCmd->face, &pCmd->material);
                         break;
                     }
@@ -4519 +4520 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetLightData);
 
-                        rc = vmsvga3dSetLightData(pThis, pCmd->cid, pCmd->index, &pCmd->data);
+                        rc = vmsvga3dSetLightData(pThisCC, pCmd->cid, pCmd->index, &pCmd->data);
                         break;
                     }
@@ -4529 +4530 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetLightEnable);
 
-                        rc = vmsvga3dSetLightEnabled(pThis, pCmd->cid, pCmd->index, pCmd->enabled);
+                        rc = vmsvga3dSetLightEnabled(pThisCC, pCmd->cid, pCmd->index, pCmd->enabled);
                         break;
                     }
@@ -4539 +4540 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetViewPort);
 
-                        rc = vmsvga3dSetViewPort(pThis, pCmd->cid, &pCmd->rect);
+                        rc = vmsvga3dSetViewPort(pThisCC, pCmd->cid, &pCmd->rect);
                         break;
                     }
@@ -4549 +4550 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetClipPlane);
 
-                        rc = vmsvga3dSetClipPlane(pThis, pCmd->cid, pCmd->index, pCmd->plane);
+                        rc = vmsvga3dSetClipPlane(pThisCC, pCmd->cid, pCmd->index, pCmd->plane);
                         break;
                     }
@@ -4560 +4561 @@
 
                         uint32_t cRects = (pHdr->size - sizeof(*pCmd)) / sizeof(SVGA3dRect);
-                        rc = vmsvga3dCommandClear(pThis, pCmd->cid, pCmd->clearFlag, pCmd->color, pCmd->depth, pCmd->stencil, cRects, (SVGA3dRect *)(pCmd + 1));
+                        rc = vmsvga3dCommandClear(pThisCC, pCmd->cid, pCmd->clearFlag, pCmd->color, pCmd->depth, pCmd->stencil, cRects, (SVGA3dRect *)(pCmd + 1));
                         break;
                     }
@@ -4589 +4590 @@
 
                         uint32_t cbData = (pHdr->size - sizeof(*pCmd));
-                        rc = vmsvga3dShaderDefine(pThis, pCmd->cid, pCmd->shid, pCmd->type, cbData, (uint32_t *)(pCmd + 1));
+                        rc = vmsvga3dShaderDefine(pThisCC, pCmd->cid, pCmd->shid, pCmd->type, cbData, (uint32_t *)(pCmd + 1));
                         break;
                     }
@@ -4599 +4600 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dShaderDestroy);
 
-                        rc = vmsvga3dShaderDestroy(pThis, pCmd->cid, pCmd->shid, pCmd->type);
+                        rc = vmsvga3dShaderDestroy(pThisCC, pCmd->cid, pCmd->shid, pCmd->type);
                         break;
                     }
@@ -4609 +4610 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetShader);
 
-                        rc = vmsvga3dShaderSet(pThis, NULL, pCmd->cid, pCmd->type, pCmd->shid);
+                        rc = vmsvga3dShaderSet(pThisCC, NULL, pCmd->cid, pCmd->type, pCmd->shid);
                         break;
                     }
@@ -4620 +4621 @@
 
                         uint32_t cRegisters = (pHdr->size - sizeof(*pCmd)) / sizeof(pCmd->values) + 1;
-                        rc = vmsvga3dShaderSetConst(pThis, pCmd->cid, pCmd->reg, pCmd->type, pCmd->ctype, cRegisters, pCmd->values);
+                        rc = vmsvga3dShaderSetConst(pThisCC, pCmd->cid, pCmd->reg, pCmd->type, pCmd->ctype, cRegisters, pCmd->values);
                         break;
                     }
@@ -4646 +4647 @@
 
                         STAM_PROFILE_START(&pSVGAState->StatR3Cmd3dDrawPrimitivesProf, a);
-                        rc = vmsvga3dDrawPrimitives(pThis, pCmd->cid, pCmd->numVertexDecls, pVertexDecl, pCmd->numRanges,
+                        rc = vmsvga3dDrawPrimitives(pThisCC, pCmd->cid, pCmd->numVertexDecls, pVertexDecl, pCmd->numRanges,
                                                     pNumRange, cVertexDivisor, pVertexDivisor);
                         STAM_PROFILE_STOP(&pSVGAState->StatR3Cmd3dDrawPrimitivesProf, a);
@@ -4658 +4659 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dSetScissorRect);
 
-                        rc = vmsvga3dSetScissorRect(pThis, pCmd->cid, &pCmd->rect);
+                        rc = vmsvga3dSetScissorRect(pThisCC, pCmd->cid, &pCmd->rect);
                         break;
                     }
@@ -4668 +4669 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dBeginQuery);
 
-                        rc = vmsvga3dQueryBegin(pThis, pCmd->cid, pCmd->type);
+                        rc = vmsvga3dQueryBegin(pThisCC, pCmd->cid, pCmd->type);
                         break;
                     }
@@ -4678 +4679 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dEndQuery);
 
-                        rc = vmsvga3dQueryEnd(pThis, pCmd->cid, pCmd->type, pCmd->guestResult);
+                        rc = vmsvga3dQueryEnd(pThisCC, pCmd->cid, pCmd->type, pCmd->guestResult);
                         break;
                     }
@@ -4698 +4699 @@
                         STAM_REL_COUNTER_INC(&pSVGAState->StatR3Cmd3dGenerateMipmaps);
 
-                        rc = vmsvga3dGenerateMipmaps(pThis, pCmd->sid, pCmd->filter);
+                        rc = vmsvga3dGenerateMipmaps(pThisCC, pCmd->sid, pCmd->filter);
                         break;
                     }
@@ -4771 +4772 @@
         {
             Log(("vmsvgaR3FifoLoop: emptied the FIFO next=%x stop=%x\n", pFIFO[SVGA_FIFO_NEXT_CMD], offCurrentCmd));
-            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pSVGAState, offFifoMin);
+            vmsvgaR3FifoSetNotBusy(pDevIns, pThis, pThisCC, pSVGAState, offFifoMin);
         }
     }
@@ -4786 +4787 @@
  * Free the specified GMR
  *
- * @param   pThis           The shared VGA/VMSVGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   idGMR           GMR id
  */
-void vmsvgaR3GmrFree(PVGASTATE pThis, uint32_t idGMR)
+static void vmsvgaR3GmrFree(PVGASTATECC pThisCC, uint32_t idGMR)
 {
-    PVMSVGAR3STATE pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE pSVGAState = pThisCC->svga.pSvgaR3State;
 
     /* Free the old descriptor if present. */
@@ -4799 +4800 @@
     {
 # ifdef DEBUG_GMR_ACCESS
-        VMR3ReqCallWaitU(PDMDevHlpGetUVM(pDevIns), VMCPUID_ANY, (PFNRT)vmsvgaR3DeregisterGmr, 2, pDevIns, idGMR);
+        VMR3ReqCallWaitU(PDMDevHlpGetUVM(pThisCC->pDevIns), VMCPUID_ANY, (PFNRT)vmsvgaR3DeregisterGmr, 2, pDevIns, idGMR);
 # endif
 
@@ -4835 +4836 @@
                         uint32_t cbWidth, uint32_t cHeight)
 {
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     PPDMDEVINS      pDevIns = pThisCC->pDevIns; /* simpler */
     int             rc;
@@ -5328 +5329 @@
  * surfaces to VMSVGA3DMIPMAPLEVEL::pSurfaceData heap buffers.
  *
- * @param   pDevIns             The device instance.
- * @param   pThis               The The shared VGA/VMSVGA instance data.
- * @param   sid                 Either UINT32_MAX or the ID of a specific
- *                              surface.  If UINT32_MAX is used, all surfaces
- *                              are processed.
+ * @param   pDevIns     The device instance.
+ * @param   pThis       The The shared VGA/VMSVGA instance data.
+ * @param   pThisCC     The VGA/VMSVGA state for ring-3.
+ * @param   sid         Either UINT32_MAX or the ID of a specific surface.  If
+ *                      UINT32_MAX is used, all surfaces are processed.
  */
-void vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t sid)
+void vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t sid)
 {
-    vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS, (void *)(uintptr_t)sid,
+    vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, pThisCC, VMSVGA_FIFO_EXTCMD_UPDATE_SURFACE_HEAP_BUFFERS, (void *)(uintptr_t)sid,
                                   sid == UINT32_MAX ? 10 * RT_MS_1SEC : RT_MS_1MIN);
 }
@@ -5381 +5382 @@
         fInvY = true;
 
-    vmsvga3dInfoSurfaceWorker(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose, cxAscii, fInvY, NULL);
+    vmsvga3dInfoSurfaceWorker(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC),
+                              pHlp, sid, fVerbose, cxAscii, fInvY, NULL);
 }
 
@@ -5406 +5408 @@
     const uint32_t cxAscii = 0; /* No ASCII */
     const bool fInvY = false;   /* Do not invert. */
-    vmsvga3dInfoSurfaceWorker(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose, cxAscii, fInvY, pszBitmapPath);
+    vmsvga3dInfoSurfaceWorker(pDevIns, PDMDEVINS_2_DATA(pDevIns, PVGASTATE), PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC),
+                              pHlp, sid, fVerbose, cxAscii, fInvY, pszBitmapPath);
 }
 
@@ -5428 +5431 @@
         fVerbose = false;
 
-    vmsvga3dInfoContextWorker(PDMDEVINS_2_DATA(pDevIns, PVGASTATE), pHlp, sid, fVerbose);
+    vmsvga3dInfoContextWorker(PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC), pHlp, sid, fVerbose);
 }
 
@@ -5440 +5443 @@
     PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
-    uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO = pThis->svga.pFIFOR3;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
+    uint32_t RT_UNTRUSTED_VOLATILE_GUEST *pFIFO = pThisCC->svga.pau32FIFO;
     RT_NOREF(pszArgs);
 
@@ -5488 +5491 @@
  * Portion of VMSVGA state which must be loaded oin the FIFO thread.
  */
-static int vmsvgaR3LoadExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+static int vmsvgaR3LoadExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PVGASTATECC pThisCC,
+                                PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
 {
     RT_NOREF(uPass);
 
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     int rc;
 
@@ -5551 +5555 @@
     RT_NOREF(uPass);
     PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     PCPDMDEVHLPR3   pHlp       = pDevIns->pHlpR3;
     int             rc;
@@ -5572 +5577 @@
         AssertCompile(RT_IS_POWER_OF_TWO(VMSVGA_VGA_FB_BACKUP_SIZE));
     }
-    rc = pHlp->pfnSSMGetMem(pSSM, pThis->svga.pbVgaFrameBufferR3, RT_MIN(cbVgaFramebuffer, VMSVGA_VGA_FB_BACKUP_SIZE));
+    rc = pHlp->pfnSSMGetMem(pSSM, pThisCC->svga.pbVgaFrameBufferR3, RT_MIN(cbVgaFramebuffer, VMSVGA_VGA_FB_BACKUP_SIZE));
     AssertRCReturn(rc, rc);
     if (cbVgaFramebuffer > VMSVGA_VGA_FB_BACKUP_SIZE)
         pHlp->pfnSSMSkip(pSSM, cbVgaFramebuffer - VMSVGA_VGA_FB_BACKUP_SIZE);
     else if (cbVgaFramebuffer < VMSVGA_VGA_FB_BACKUP_SIZE)
-        RT_BZERO(&pThis->svga.pbVgaFrameBufferR3[cbVgaFramebuffer], VMSVGA_VGA_FB_BACKUP_SIZE - cbVgaFramebuffer);
+        RT_BZERO(&pThisCC->svga.pbVgaFrameBufferR3[cbVgaFramebuffer], VMSVGA_VGA_FB_BACKUP_SIZE - cbVgaFramebuffer);
 
     /* Load the VMSVGA state. */
@@ -5644 +5649 @@
     LoadState.uVersion = uVersion;
     LoadState.uPass    = uPass;
-    rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, VMSVGA_FIFO_EXTCMD_LOADSTATE, &LoadState, RT_INDEFINITE_WAIT);
+    rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, pThisCC, VMSVGA_FIFO_EXTCMD_LOADSTATE, &LoadState, RT_INDEFINITE_WAIT);
     AssertLogRelRCReturn(rc, rc);
 
@@ -5657 +5662 @@
     PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
     PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
 
     ASMAtomicOrU32(&pThis->svga.u32ActionFlags, VMSVGA_ACTION_CHANGEMODE);
@@ -5680 +5685 @@
  * Portion of SVGA state which must be saved in the FIFO thread.
  */
-static int vmsvgaR3SaveExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM)
+static int vmsvgaR3SaveExecFifo(PCPDMDEVHLPR3 pHlp, PVGASTATECC pThisCC, PSSMHANDLE pSSM)
 {
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     int             rc;
 
@@ -5713 +5718 @@
 {
     PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
     PCPDMDEVHLPR3   pHlp       = pDevIns->pHlpR3;
     int             rc;
@@ -5723 +5729 @@
     /* Save the framebuffer backup. */
     rc = pHlp->pfnSSMPutU32(pSSM, VMSVGA_VGA_FB_BACKUP_SIZE);
-    rc = pHlp->pfnSSMPutMem(pSSM, pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
+    rc = pHlp->pfnSSMPutMem(pSSM, pThisCC->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
     AssertLogRelRCReturn(rc, rc);
 
@@ -5757 +5763 @@
      * Must save some state (3D in particular) in the FIFO thread.
      */
-    rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, VMSVGA_FIFO_EXTCMD_SAVESTATE, pSSM, RT_INDEFINITE_WAIT);
+    rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, pThisCC, VMSVGA_FIFO_EXTCMD_SAVESTATE, pSSM, RT_INDEFINITE_WAIT);
     AssertLogRelRCReturn(rc, rc);
 
@@ -5766 +5772 @@
  * Destructor for PVMSVGAR3STATE structure.
  *
- * @param   pThis          The VGA instance.
+ * @param   pThis          The shared VGA/VMSVGA instance data.
  * @param   pSVGAState     Pointer to the structure. It is not deallocated.
  */
@@ -5801 +5807 @@
  *
  * @returns VBox status code.
- * @param   pThis          The VGA instance.
+ * @param   pThis          The shared VGA/VMSVGA instance data.
  * @param   pSVGAState     Pointer to the structure. It is already allocated.
  */
@@ -5825 +5831 @@
  *
  * @returns VBox status code.
- * @param   pThis     The VGA instance.
+ * @param   pThis     The shared VGA/VMSVGA instance data.
  */
-static void vmsvgaR3InitCaps(PVGASTATE pThis)
+static void vmsvgaR3InitCaps(PVGASTATE pThis, PVGASTATECC pThisCC)
 {
     /* Register caps. */
@@ -5845 +5851 @@
 
     /* Clear the FIFO. */
-    RT_BZERO(pThis->svga.pFIFOR3, pThis->svga.cbFIFO);
+    RT_BZERO(pThisCC->svga.pau32FIFO, pThis->svga.cbFIFO);
 
     /* Setup FIFO capabilities. */
-    pThis->svga.pFIFOR3[SVGA_FIFO_CAPABILITIES] = SVGA_FIFO_CAP_FENCE
+    pThisCC->svga.pau32FIFO[SVGA_FIFO_CAPABILITIES] = SVGA_FIFO_CAP_FENCE
                                                 | SVGA_FIFO_CAP_CURSOR_BYPASS_3
                                                 | SVGA_FIFO_CAP_GMR2
@@ -5857 +5863 @@
 
     /* Valid with SVGA_FIFO_CAP_SCREEN_OBJECT_2 */
-    pThis->svga.pFIFOR3[SVGA_FIFO_CURSOR_SCREEN_ID] = SVGA_ID_INVALID;
+    pThisCC->svga.pau32FIFO[SVGA_FIFO_CURSOR_SCREEN_ID] = SVGA_ID_INVALID;
 }
 
@@ -5954 +5960 @@
  *
  * @returns VBox status code.
- * @param   pThis     The VGA instance.
+ * @param   pThis     The shared VGA/VMSVGA instance data.
+ * @param   pThisCC   The VGA/VMSVGA state for ring-3.
  */
-static void vmsvgaR3InitFifo3DCaps(PVGASTATE pThis)
+static void vmsvgaR3InitFifo3DCaps(PVGASTATECC pThisCC)
 {
     /** @todo Probably query the capabilities once and cache in a memory buffer. */
@@ -5965 +5972 @@
 
     /* 3d hardware version; latest and greatest */
-    pThis->svga.pFIFOR3[SVGA_FIFO_3D_HWVERSION_REVISED] = SVGA3D_HWVERSION_CURRENT;
-    pThis->svga.pFIFOR3[SVGA_FIFO_3D_HWVERSION]         = SVGA3D_HWVERSION_CURRENT;
-
-    pCaps = (SVGA3dCapsRecord *)&pThis->svga.pFIFOR3[SVGA_FIFO_3D_CAPS];
+    pThisCC->svga.pau32FIFO[SVGA_FIFO_3D_HWVERSION_REVISED] = SVGA3D_HWVERSION_CURRENT;
+    pThisCC->svga.pau32FIFO[SVGA_FIFO_3D_HWVERSION]         = SVGA3D_HWVERSION_CURRENT;
+
+    pCaps = (SVGA3dCapsRecord *)&pThisCC->svga.pau32FIFO[SVGA_FIFO_3D_CAPS];
     pCaps->header.type   = SVGA3DCAPS_RECORD_DEVCAPS;
     pData = (SVGA3dCapPair *)&pCaps->data;
@@ -5977 +5984 @@
         uint32_t val = 0;
 
-        int rc = vmsvga3dQueryCaps(pThis, i, &val);
+        int rc = vmsvga3dQueryCaps(pThisCC, i, &val);
         if (RT_SUCCESS(rc))
         {
@@ -6011 +6018 @@
 int vmsvgaR3Reset(PPDMDEVINS pDevIns)
 {
-    PVGASTATE       pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
-    PVMSVGAR3STATE  pSVGAState = pThis->svga.pSvgaR3State;
+    PVGASTATE       pThis      = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC     pThisCC    = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
+    PVMSVGAR3STATE  pSVGAState = pThisCC->svga.pSvgaR3State;
 
     /* Reset before init? */
@@ -6021 +6029 @@
 
     /* Reset the FIFO processing as well as the 3d state (if we have one). */
-    pThis->svga.pFIFOR3[SVGA_FIFO_NEXT_CMD] = pThis->svga.pFIFOR3[SVGA_FIFO_STOP] = 0; /** @todo should probably let the FIFO thread do this ... */
-    int rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, VMSVGA_FIFO_EXTCMD_RESET, NULL /*pvParam*/, 10000 /*ms*/);
+    pThisCC->svga.pau32FIFO[SVGA_FIFO_NEXT_CMD] = pThisCC->svga.pau32FIFO[SVGA_FIFO_STOP] = 0; /** @todo should probably let the FIFO thread do this ... */
+    int rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, pThisCC, VMSVGA_FIFO_EXTCMD_RESET, NULL /*pvParam*/, 10000 /*ms*/);
 
     /* Reset other stuff. */
@@ -6028 +6036 @@
     RT_ZERO(pThis->svga.au32ScratchRegion);
 
-    vmsvgaR3StateTerm(pThis, pThis->svga.pSvgaR3State);
-    vmsvgaR3StateInit(pThis, pThis->svga.pSvgaR3State);
-
-    RT_BZERO(pThis->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
+    vmsvgaR3StateTerm(pThis, pThisCC->svga.pSvgaR3State);
+    vmsvgaR3StateInit(pThis, pThisCC->svga.pSvgaR3State);
+
+    RT_BZERO(pThisCC->svga.pbVgaFrameBufferR3, VMSVGA_VGA_FB_BACKUP_SIZE);
 
     /* Initialize FIFO and register capabilities. */
-    vmsvgaR3InitCaps(pThis);
+    vmsvgaR3InitCaps(pThis, pThisCC);
 
 # ifdef VBOX_WITH_VMSVGA3D
     if (pThis->svga.f3DEnabled)
-        vmsvgaR3InitFifo3DCaps(pThis);
+        vmsvgaR3InitFifo3DCaps(pThisCC);
 # endif
 
@@ -6063 +6071 @@
 int vmsvgaR3Destruct(PPDMDEVINS pDevIns)
 {
-    PVGASTATE pThis = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATE   pThis   = PDMDEVINS_2_DATA(pDevIns, PVGASTATE);
+    PVGASTATECC pThisCC = PDMDEVINS_2_DATA_CC(pDevIns, PVGASTATECC);
 
     /*
      * Ask the FIFO thread to terminate the 3d state and then terminate it.
      */
-    if (pThis->svga.pFIFOIOThread)
-    {
-        int rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, VMSVGA_FIFO_EXTCMD_TERMINATE, NULL /*pvParam*/, 30000 /*ms*/);
+    if (pThisCC->svga.pFIFOIOThread)
+    {
+        int rc = vmsvgaR3RunExtCmdOnFifoThread(pDevIns, pThis, pThisCC,  VMSVGA_FIFO_EXTCMD_TERMINATE,
+                                               NULL /*pvParam*/, 30000 /*ms*/);
         AssertLogRelRC(rc);
 
-        rc = PDMDevHlpThreadDestroy(pDevIns, pThis->svga.pFIFOIOThread, NULL);
+        rc = PDMDevHlpThreadDestroy(pDevIns, pThisCC->svga.pFIFOIOThread, NULL);
         AssertLogRelRC(rc);
-        pThis->svga.pFIFOIOThread = NULL;
+        pThisCC->svga.pFIFOIOThread = NULL;
     }
 
@@ -6081 +6091 @@
      * Destroy the special SVGA state.
      */
-    if (pThis->svga.pSvgaR3State)
-    {
-        vmsvgaR3StateTerm(pThis, pThis->svga.pSvgaR3State);
-
-        RTMemFree(pThis->svga.pSvgaR3State);
-        pThis->svga.pSvgaR3State = NULL;
+    if (pThisCC->svga.pSvgaR3State)
+    {
+        vmsvgaR3StateTerm(pThis, pThisCC->svga.pSvgaR3State);
+
+        RTMemFree(pThisCC->svga.pSvgaR3State);
+        pThisCC->svga.pSvgaR3State = NULL;
     }
 
@@ -6092 +6102 @@
      * Free our resources residing in the VGA state.
      */
-    if (pThis->svga.pbVgaFrameBufferR3)
-    {
-        RTMemFree(pThis->svga.pbVgaFrameBufferR3);
-        pThis->svga.pbVgaFrameBufferR3 = NULL;
-    }
-    if (pThis->svga.hFIFOExtCmdSem != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy(pThis->svga.hFIFOExtCmdSem);
-        pThis->svga.hFIFOExtCmdSem = NIL_RTSEMEVENT;
+    if (pThisCC->svga.pbVgaFrameBufferR3)
+    {
+        RTMemFree(pThisCC->svga.pbVgaFrameBufferR3);
+        pThisCC->svga.pbVgaFrameBufferR3 = NULL;
+    }
+    if (pThisCC->svga.hFIFOExtCmdSem != NIL_RTSEMEVENT)
+    {
+        RTSemEventDestroy(pThisCC->svga.hFIFOExtCmdSem);
+        pThisCC->svga.hFIFOExtCmdSem = NIL_RTSEMEVENT;
     }
     if (pThis->svga.hFIFORequestSem != NIL_SUPSEMEVENT)
@@ -6130 +6140 @@
 
     /* Necessary for creating a backup of the text mode frame buffer when switching into svga mode. */
-    pThis->svga.pbVgaFrameBufferR3 = (uint8_t *)RTMemAllocZ(VMSVGA_VGA_FB_BACKUP_SIZE);
-    AssertReturn(pThis->svga.pbVgaFrameBufferR3, VERR_NO_MEMORY);
+    pThisCC->svga.pbVgaFrameBufferR3 = (uint8_t *)RTMemAllocZ(VMSVGA_VGA_FB_BACKUP_SIZE);
+    AssertReturn(pThisCC->svga.pbVgaFrameBufferR3, VERR_NO_MEMORY);
 
     /* Create event semaphore. */
@@ -6138 +6148 @@
 
     /* Create event semaphore. */
-    rc = RTSemEventCreate(&pThis->svga.hFIFOExtCmdSem);
+    rc = RTSemEventCreate(&pThisCC->svga.hFIFOExtCmdSem);
     AssertRCReturn(rc, rc);
 
-    pThis->svga.pSvgaR3State = (PVMSVGAR3STATE)RTMemAlloc(sizeof(VMSVGAR3STATE));
-    AssertReturn(pThis->svga.pSvgaR3State, VERR_NO_MEMORY);
-
-    rc = vmsvgaR3StateInit(pThis, pThis->svga.pSvgaR3State);
+    pThisCC->svga.pSvgaR3State = (PVMSVGAR3STATE)RTMemAlloc(sizeof(VMSVGAR3STATE));
+    AssertReturn(pThisCC->svga.pSvgaR3State, VERR_NO_MEMORY);
+
+    rc = vmsvgaR3StateInit(pThis, pThisCC->svga.pSvgaR3State);
     AssertMsgRCReturn(rc, ("Failed to create pSvgaR3State.\n"), rc);
 
-    pSVGAState = pThis->svga.pSvgaR3State;
+    pSVGAState = pThisCC->svga.pSvgaR3State;
 
     /* Initialize FIFO and register capabilities. */
-    vmsvgaR3InitCaps(pThis);
+    vmsvgaR3InitCaps(pThis, pThisCC);
 
 # ifdef VBOX_WITH_VMSVGA3D
@@ -6209 +6219 @@
 
     /* Create the async IO thread. */
-    rc = PDMDevHlpThreadCreate(pDevIns, &pThis->svga.pFIFOIOThread, pThis, vmsvgaR3FifoLoop, vmsvgaR3FifoLoopWakeUp, 0,
+    rc = PDMDevHlpThreadCreate(pDevIns, &pThisCC->svga.pFIFOIOThread, pThis, vmsvgaR3FifoLoop, vmsvgaR3FifoLoopWakeUp, 0,
                                RTTHREADTYPE_IO, "VMSVGA FIFO");
     if (RT_FAILURE(rc))
@@ -6425 +6435 @@
         {
             /* Initialize FIFO 3D capabilities. */
-            vmsvgaR3InitFifo3DCaps(pThis);
+            vmsvgaR3InitFifo3DCaps(pThisCC);
         }
     }

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

@@ -166 +166 @@
 typedef struct VMSVGAState
 {
-    /** The R3 FIFO pointer. */
-    R3PTRTYPE(uint32_t *)       pFIFOR3;
-    /** The R0 FIFO pointer.
-     * @note This only points to the _first_ _page_ of the FIFO!  */
-    R0PTRTYPE(uint32_t *)       pFIFOR0;
-    /** R3 Opaque pointer to svga state. */
-    R3PTRTYPE(PVMSVGAR3STATE)   pSvgaR3State;
-    /** R3 Opaque pointer to 3d state. */
-    R3PTRTYPE(PVMSVGA3DSTATE)   p3dState;
-    /** The separate VGA frame buffer in svga mode.
-     * Unlike the the boch-based VGA device implementation, VMSVGA seems to have a
-     * separate frame buffer for VGA and allows concurrent use of both.  The SVGA
-     * SDK is making use of this to do VGA text output while testing other things in
-     * SVGA mode, displaying the result by switching back to VGA text mode.  So,
-     * when entering SVGA mode we copy the first part of the frame buffer here and
-     * direct VGA accesses here instead.  It is copied back when leaving SVGA mode. */
-    R3PTRTYPE(uint8_t *)        pbVgaFrameBufferR3;
-    /** R3 Opaque pointer to an external fifo cmd parameter. */
-    R3PTRTYPE(void * volatile)  pvFIFOExtCmdParam;
-
     /** Guest physical address of the FIFO memory range. */
     RTGCPHYS                    GCPhysFIFO;
@@ -225 +205 @@
     /** FIFO request semaphore. */
     SUPSEMEVENT                 hFIFORequestSem;
-    /** FIFO external command semaphore. */
-    R3PTRTYPE(RTSEMEVENT)       hFIFOExtCmdSem;
-    /** FIFO IO Thread. */
-    R3PTRTYPE(PPDMTHREAD)       pFIFOIOThread;
     /** The last seen SVGA_FIFO_CURSOR_COUNT value.
      * Used by the FIFO thread and its watchdog. */
@@ -357 +333 @@
     STAMCOUNTER                 StatRegWidthRd;
     STAMCOUNTER                 StatRegWriteOnlyRd;
-} VMSVGAState;
+} VMSVGAState, VMSVGASTATE;
+
+
+/**
+ * The VMSVGA device state for ring-3
+ *
+ * This instantatiated as VGASTATER3::svga.
+ */
+typedef struct VMSVGASTATER3
+{
+    /** The R3 FIFO pointer. */
+    R3PTRTYPE(uint32_t *)       pau32FIFO;
+    /** R3 Opaque pointer to svga state. */
+    R3PTRTYPE(PVMSVGAR3STATE)   pSvgaR3State;
+    /** R3 Opaque pointer to 3d state. */
+    R3PTRTYPE(PVMSVGA3DSTATE)   p3dState;
+    /** The separate VGA frame buffer in svga mode.
+     * Unlike the the boch-based VGA device implementation, VMSVGA seems to have a
+     * separate frame buffer for VGA and allows concurrent use of both.  The SVGA
+     * SDK is making use of this to do VGA text output while testing other things in
+     * SVGA mode, displaying the result by switching back to VGA text mode.  So,
+     * when entering SVGA mode we copy the first part of the frame buffer here and
+     * direct VGA accesses here instead.  It is copied back when leaving SVGA mode. */
+    R3PTRTYPE(uint8_t *)        pbVgaFrameBufferR3;
+    /** R3 Opaque pointer to an external fifo cmd parameter. */
+    R3PTRTYPE(void * volatile)  pvFIFOExtCmdParam;
+
+    /** FIFO external command semaphore. */
+    R3PTRTYPE(RTSEMEVENT)       hFIFOExtCmdSem;
+    /** FIFO IO Thread. */
+    R3PTRTYPE(PPDMTHREAD)       pFIFOIOThread;
+} VMSVGASTATER3;
+
+
+/**
+ * The VMSVGA device state for ring-0
+ *
+ * This instantatiated as VGASTATER0::svga.
+ */
+typedef struct VMSVGASTATER0
+{
+    /** The R0 FIFO pointer.
+     * @note This only points to the _first_ _page_ of the FIFO!  */
+    R0PTRTYPE(uint32_t *)       pau32FIFO;
+} VMSVGASTATER0;
+
 
 typedef struct VGAState   *PVGASTATE;
@@ -381 +402 @@
 DECLCALLBACK(void) vmsvgaR3PowerOn(PPDMDEVINS pDevIns);
 DECLCALLBACK(void) vmsvgaR3PowerOff(PPDMDEVINS pDevIns);
-void vmsvgaR3FifoWatchdogTimer(PPDMDEVINS pDevIns, PVGASTATE pThis);
+void vmsvgaR3FifoWatchdogTimer(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
 
 #ifdef IN_RING3
-VMSVGASCREENOBJECT *vmsvgaR3GetScreenObject(PVGASTATE pThis, uint32_t idScreen);
+VMSVGASCREENOBJECT *vmsvgaR3GetScreenObject(PVGASTATECC pThisCC, uint32_t idScreen);
 int vmsvgaR3UpdateScreen(PVGASTATECC pThisCC, VMSVGASCREENOBJECT *pScreen, int x, int y, int w, int h);
 #endif
 
-void vmsvgaR3GmrFree(PVGASTATE pThis, uint32_t idGMR);
 int vmsvgaR3GmrTransfer(PVGASTATE pThis, PVGASTATECC pThisCC, const SVGA3dTransferType enmTransferType,
                         uint8_t *pbHstBuf, uint32_t cbHstBuf, uint32_t offHst, int32_t cbHstPitch,

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

@@ -512 +512 @@
  * Updates the heap buffers for all surfaces or one specific one.
  *
- * @param   pThis               The shared VGA instance data.
- * @param   sid                 The surface ID, UINT32_MAX if all.
+ * @param   pThisCC     The VGA/VMSVGA state for ring-3.
+ * @param   sid         The surface ID, UINT32_MAX if all.
  * @thread  VMSVGAFIFO
  */
-void vmsvga3dUpdateHeapBuffersForSurfaces(PVGASTATE pThis, uint32_t sid)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+void vmsvga3dUpdateHeapBuffersForSurfaces(PVGASTATECC pThisCC, uint32_t sid)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturnVoid(pState);
 
@@ -1715 +1715 @@
 
 
-void vmsvga3dInfoContextWorker(PVGASTATE pThis, PCDBGFINFOHLP pHlp, uint32_t cid, bool fVerbose)
+void vmsvga3dInfoContextWorker(PVGASTATECC pThisCC, PCDBGFINFOHLP pHlp, uint32_t cid, bool fVerbose)
 {
     /* Warning! This code is currently racing papContexts reallocation! */
     /* Warning! This code is currently racing papContexts reallocation! */
     /* Warning! This code is currently racing papContexts reallocation! */
-    VMSVGA3DSTATE volatile *pState = pThis->svga.p3dState;
+    VMSVGA3DSTATE volatile *pState = pThisCC->svga.p3dState;
     if (pState)
     {
@@ -2104 +2104 @@
 
 
-void vmsvga3dInfoSurfaceWorker(PPDMDEVINS pDevIns, PVGASTATE pThis, PCDBGFINFOHLP pHlp, uint32_t sid, bool fVerbose,
-                               uint32_t cxAscii, bool fInvY, const char *pszBitmapPath)
+void vmsvga3dInfoSurfaceWorker(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PCDBGFINFOHLP pHlp, uint32_t sid,
+                               bool fVerbose, uint32_t cxAscii, bool fInvY, const char *pszBitmapPath)
 {
     /* Warning! This code is currently racing papSurfaces reallocation! */
     /* Warning! This code is currently racing papSurfaces reallocation! */
     /* Warning! This code is currently racing papSurfaces reallocation! */
-    VMSVGA3DSTATE volatile *pState = pThis->svga.p3dState;
+    VMSVGA3DSTATE volatile *pState = pThisCC->svga.p3dState;
     if (pState)
     {
@@ -2124 +2124 @@
                 {
                     if (fVerbose)
-                        vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(pDevIns, pThis, sid);
+                        vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(pDevIns, pThis, pThisCC, sid);
                     vmsvga3dInfoSurfaceWorkerOne(pHlp, pSurface, fVerbose, cxAscii, fInvY);
                     if (pszBitmapPath && *pszBitmapPath)
@@ -2139 +2139 @@
              */
             if (fVerbose)
-                vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(pDevIns, pThis, UINT32_MAX);
+                vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(pDevIns, pThis, pThisCC, UINT32_MAX);
             uint32_t cSurfaces = pState->cSurfaces;
             pHlp->pfnPrintf(pHlp, "cSurfaces=%d\n", cSurfaces);

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

@@ -1210 +1210 @@
 # define VMSVGA3D_DEF_CTX_F_INIT            RT_BIT_32(2)
 /** @} */
-int  vmsvga3dContextDefineOgl(PVGASTATE pThis, uint32_t cid, uint32_t fFlags);
+int  vmsvga3dContextDefineOgl(PVGASTATECC pThisCC, uint32_t cid, uint32_t fFlags);
 void vmsvga3dSurfaceFormat2OGL(PVMSVGA3DSURFACE pSurface, SVGA3dSurfaceFormat format);
 

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

@@ -168 +168 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static int  vmsvga3dContextDestroyOgl(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t cid);
+static int  vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid);
 static void vmsvgaColor2GLFloatArray(uint32_t color, GLfloat *pRed, GLfloat *pGreen, GLfloat *pBlue, GLfloat *pAlpha);
 
@@ -591 +591 @@
 {
     int rc;
-    RT_NOREF(pDevIns, pThisCC);
+    RT_NOREF(pDevIns, pThis);
 
     AssertCompile(GL_TRUE == 1);
@@ -627 +627 @@
      * Allocate the state.
      */
-    pThis->svga.p3dState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
+    pThisCC->svga.p3dState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
 
 #ifdef RT_OS_WINDOWS
     /* Create event semaphore and async IO thread. */
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     rc = RTSemEventCreate(&pState->WndRequestSem);
     if (RT_SUCCESS(rc))
@@ -647 +647 @@
     else
         LogRel(("VMSVGA3d: RTSemEventCreate failed: %Rrc\n", rc));
-    RTMemFree(pThis->svga.p3dState);
-    pThis->svga.p3dState = NULL;
+    RTMemFree(pThisCC->svga.p3dState);
+    pThisCC->svga.p3dState = NULL;
     return rc;
 #else
@@ -815 +815 @@
 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
     PVMSVGA3DCONTEXT pContext;
 #ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
@@ -822 +822 @@
 #endif
     int              rc;
-    RT_NOREF(pDevIns, pThisCC);
+    RT_NOREF(pDevIns, pThis);
 
     if (pState->rsGLVersion != 0.0)
@@ -830 +830 @@
      * OpenGL function calls aren't possible without a valid current context, so create a fake one here.
      */
-    rc = vmsvga3dContextDefineOgl(pThis, 1, VMSVGA3D_DEF_CTX_F_INIT);
+    rc = vmsvga3dContextDefineOgl(pThisCC, 1, VMSVGA3D_DEF_CTX_F_INIT);
     AssertRCReturn(rc, rc);
 
@@ -865 +865 @@
      * figure out the shader model and stuff.
      */
-    rc = vmsvga3dContextDefineOgl(pThis, 2, VMSVGA3D_DEF_CTX_F_INIT | VMSVGA3D_DEF_CTX_F_OTHER_PROFILE);
+    rc = vmsvga3dContextDefineOgl(pThisCC, 2, VMSVGA3D_DEF_CTX_F_INIT | VMSVGA3D_DEF_CTX_F_OTHER_PROFILE);
     AssertLogRelRCReturn(rc, rc);
     pContext = pState->papContexts[1]; /* Array may have been reallocated. */
@@ -1118 +1118 @@
 
     /* Cleanup */
-    rc = vmsvga3dContextDestroy(pThis, 1);
+    rc = vmsvga3dContextDestroy(pThisCC, 1);
     AssertRC(rc);
 #ifdef VBOX_VMSVGA3D_DUAL_OPENGL_PROFILE
-    rc = vmsvga3dContextDestroy(pThis, 2);
+    rc = vmsvga3dContextDestroy(pThisCC, 2);
     AssertRC(rc);
 #endif
@@ -1135 +1135 @@
 }
 
-int vmsvga3dReset(PVGASTATE pThis)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
+int vmsvga3dReset(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
 
     /* Destroy all leftover surfaces. */
@@ -1144 +1144 @@
     {
         if (pState->papSurfaces[i]->id != SVGA3D_INVALID_ID)
-            vmsvga3dSurfaceDestroy(pThis, pState->papSurfaces[i]->id);
+            vmsvga3dSurfaceDestroy(pThisCC, pState->papSurfaces[i]->id);
     }
 
@@ -1151 +1151 @@
     {
         if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
-            vmsvga3dContextDestroy(pThis, pState->papContexts[i]->id);
+            vmsvga3dContextDestroy(pThisCC, pState->papContexts[i]->id);
     }
 
     if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
-        vmsvga3dContextDestroyOgl(pThis, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID);
+        vmsvga3dContextDestroyOgl(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID);
 
     return VINF_SUCCESS;
 }
 
-int vmsvga3dTerminate(PVGASTATE pThis)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dTerminate(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_WRONG_ORDER);
     int            rc;
 
-    rc = vmsvga3dReset(pThis);
+    rc = vmsvga3dReset(pThisCC);
     AssertRCReturn(rc, rc);
 
@@ -1201 +1201 @@
 
 
-void vmsvga3dUpdateHostScreenViewport(PVGASTATE pThis, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
+void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
 {
     /** @todo Move the visible framebuffer content here, don't wait for the guest to
@@ -1208 +1208 @@
 #ifdef RT_OS_DARWIN
     RT_NOREF(pOldViewport);
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     if (   pState
         && idScreen == 0
@@ -1216 +1216 @@
     }
 #else
-    RT_NOREF(pThis, idScreen, pOldViewport);
+    RT_NOREF(pThisCC, idScreen, pOldViewport);
 #endif
 }
@@ -1366 +1366 @@
 
 
-int vmsvga3dQueryCaps(PVGASTATE pThis, uint32_t idx3dCaps, uint32_t *pu32Val)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dQueryCaps(PVGASTATECC pThisCC, uint32_t idx3dCaps, uint32_t *pu32Val)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     int       rc = VINF_SUCCESS;
@@ -2032 +2032 @@
 
 
-int vmsvga3dSurfaceCopy(PVGASTATE pThis, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
+int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
+                        uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
 {
     int rc;
@@ -2039 +2040 @@
              cCopyBoxes, src.sid, src.face, src.mipmap, dest.sid, dest.face, dest.mipmap));
 
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_INVALID_STATE);
 
@@ -2170 +2171 @@
     }
 
+    PVGASTATE pThis = PDMDEVINS_2_DATA(pThisCC->pDevIns, PVGASTATE);
     for (uint32_t i = 0; i < cCopyBoxes; i++)
     {
@@ -2189 +2191 @@
 
         /* No stretching is required, therefore use SVGA3D_STRETCH_BLT_POINT which translated to GL_NEAREST. */
-        rc = vmsvga3dSurfaceStretchBlt(pThis, &dest, &destBox, &src, &srcBox, SVGA3D_STRETCH_BLT_POINT);
+        rc = vmsvga3dSurfaceStretchBlt(pThis, pThisCC, &dest, &destBox, &src, &srcBox, SVGA3D_STRETCH_BLT_POINT);
         AssertRCReturn(rc, rc);
     }
@@ -2817 +2819 @@
  *
  * @returns Failure status code or @a rc.
- * @param   pThis               The shared VGA instance data.
+ * @param   pThis               The shared VGA/VMSVGA instance data.
  * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pState              The VMSVGA3d state.
@@ -3115 +3117 @@
 }
 
-int vmsvga3dGenerateMipmaps(PVGASTATE pThis, uint32_t sid, SVGA3dTextureFilter filter)
-{
-    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
+int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
+{
+    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
     PVMSVGA3DSURFACE    pSurface;
     int                 rc = VINF_SUCCESS;
@@ -3208 +3210 @@
  *
  * @returns VBox status code.
- * @param   pThis           The shared VGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   cid             Context id
  * @param   fFlags          VMSVGA3D_DEF_CTX_F_XXX.
  */
-int vmsvga3dContextDefineOgl(PVGASTATE pThis, uint32_t cid, uint32_t fFlags)
+int vmsvga3dContextDefineOgl(PVGASTATECC pThisCC, uint32_t cid, uint32_t fFlags)
 {
     int                     rc;
     PVMSVGA3DCONTEXT        pContext;
-    PVMSVGA3DSTATE          pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE          pState = pThisCC->svga.p3dState;
 
     AssertReturn(pState, VERR_NO_MEMORY);
@@ -3248 +3250 @@
         /* If one already exists with this id, then destroy it now. */
         if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
-            vmsvga3dContextDestroy(pThis, cid);
+            vmsvga3dContextDestroy(pThisCC, cid);
 
         pContext = pState->papContexts[cid];
@@ -3262 +3264 @@
         if (pSharedCtx->id != VMSVGA3D_SHARED_CTX_ID)
         {
-            rc = vmsvga3dContextDefineOgl(pThis, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
+            rc = vmsvga3dContextDefineOgl(pThisCC, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
             AssertLogRelRCReturn(rc, rc);
 
@@ -3443 +3445 @@
  *
  * @returns VBox status code.
- * @param   pThis           The shared VGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   cid             Context id
  */
-int vmsvga3dContextDefine(PVGASTATE pThis, uint32_t cid)
-{
-    return vmsvga3dContextDefineOgl(pThis, cid, 0/*fFlags*/);
+int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
+{
+    return vmsvga3dContextDefineOgl(pThisCC, cid, 0/*fFlags*/);
 }
 
@@ -3455 +3457 @@
  *
  * @returns VBox status code.
- * @param   pThis           The shared VGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   pContext        The context to destroy.
  * @param   cid             Context id
  */
-static int vmsvga3dContextDestroyOgl(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t cid)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+static int vmsvga3dContextDestroyOgl(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     AssertReturn(pContext, VERR_INVALID_PARAMETER);
@@ -3479 +3481 @@
     {
         if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
-            vmsvga3dShaderDestroy(pThis, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
+            vmsvga3dShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
     }
     if (pContext->paPixelShader)
@@ -3488 +3490 @@
     {
         if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
-            vmsvga3dShaderDestroy(pThis, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
+            vmsvga3dShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
     }
     if (pContext->paVertexShader)
@@ -3553 +3555 @@
  *
  * @returns VBox status code.
- * @param   pThis           The shared VGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   cid             Context id
  */
-int vmsvga3dContextDestroy(PVGASTATE pThis, uint32_t cid)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_WRONG_ORDER);
 
@@ -3566 +3568 @@
     if (   cid < pState->cContexts
         && pState->papContexts[cid]->id == cid)
-        return vmsvga3dContextDestroyOgl(pThis, pState->papContexts[cid], cid);
+        return vmsvga3dContextDestroyOgl(pThisCC, pState->papContexts[cid], cid);
 
     AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
@@ -3575 +3577 @@
  * Worker for vmsvga3dChangeMode that resizes a context.
  *
- * @param   pThis               The shared VGA instance data.
  * @param   pState              The VMSVGA3d state.
  * @param   pContext            The context.
  */
-static void vmsvga3dChangeModeOneContext(PVGASTATE pThis, PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
-{
-    RT_NOREF3(pThis, pState, pContext);
+static void vmsvga3dChangeModeOneContext(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
+{
+    RT_NOREF(pState, pContext);
     /* Do nothing. The window is not used for presenting. */
 }
 
 /* Handle resize */
-int vmsvga3dChangeMode(PVGASTATE pThis)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dChangeMode(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
     /* Resize the shared context too. */
     if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
-        vmsvga3dChangeModeOneContext(pThis, pState, &pState->SharedCtx);
+        vmsvga3dChangeModeOneContext(pState, &pState->SharedCtx);
 
     /* Resize all active contexts. */
@@ -3600 +3601 @@
         PVMSVGA3DCONTEXT pContext = pState->papContexts[i];
         if (pContext->id != SVGA3D_INVALID_ID)
-            vmsvga3dChangeModeOneContext(pThis, pState, pContext);
+            vmsvga3dChangeModeOneContext(pState, pContext);
     }
 
@@ -3607 +3608 @@
 
 
-int vmsvga3dSetTransform(PVGASTATE pThis, uint32_t cid, SVGA3dTransformType type, float matrix[16])
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     bool                  fModelViewChanged = false;
@@ -3699 +3700 @@
         {
             if (pContext->state.aClipPlane[j].fValid == true)
-                vmsvga3dSetClipPlane(pThis, cid, j, pContext->state.aClipPlane[j].plane);
+                vmsvga3dSetClipPlane(pThisCC, cid, j, pContext->state.aClipPlane[j].plane);
         }
 
@@ -3706 +3707 @@
         {
             if (pContext->state.aLightData[j].fValidData == true)
-                vmsvga3dSetLightData(pThis, cid, j, &pContext->state.aLightData[j].data);
+                vmsvga3dSetLightData(pThisCC, cid, j, &pContext->state.aLightData[j].data);
         }
     }
@@ -3713 +3714 @@
 }
 
-int vmsvga3dSetZRange(PVGASTATE pThis, uint32_t cid, SVGA3dZRange zRange)
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -3851 +3852 @@
 }
 
-int vmsvga3dSetRenderState(PVGASTATE pThis, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
+int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
 {
     uint32_t                    val = UINT32_MAX; /* Shut up MSC. */
-    PVMSVGA3DSTATE              pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE              pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4150 +4151 @@
             }
 
-            rc = vmsvga3dSetRenderState(pThis, cid, 2, renderstate);
+            rc = vmsvga3dSetRenderState(pThisCC, cid, 2, renderstate);
             AssertRCReturn(rc, rc);
 
@@ -4321 +4322 @@
             }
 
-            rc = vmsvga3dSetRenderState(pThis, cid, RT_ELEMENTS(renderstate), renderstate);
+            rc = vmsvga3dSetRenderState(pThisCC, cid, RT_ELEMENTS(renderstate), renderstate);
             AssertRCReturn(rc, rc);
 
@@ -4716 +4717 @@
 }
 
-int vmsvga3dSetRenderTarget(PVGASTATE pThis, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
 
     AssertReturn(pState, VERR_NO_MEMORY);
@@ -5048 +5049 @@
 }
 
-int vmsvga3dSetTextureState(PVGASTATE pThis, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
+int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
 {
     GLenum                      val = ~(GLenum)0; /* Shut up MSC. */
     GLenum                      currentStage = ~(GLenum)0;
-    PVMSVGA3DSTATE              pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE              pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5214 +5215 @@
                             if (    pTextureStateIter->name != SVGA3D_TS_INVALID
                                 &&  pTextureStateIter->name != SVGA3D_TS_BIND_TEXTURE)
-                                vmsvga3dSetTextureState(pThis, pContext->id, 1, pTextureStateIter);
+                                vmsvga3dSetTextureState(pThisCC, pContext->id, 1, pTextureStateIter);
                         }
                     }
@@ -5382 +5383 @@
 }
 
-int vmsvga3dSetMaterial(PVGASTATE pThis, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5431 +5432 @@
 
 /** @todo Move into separate library as we are using logic from Wine here. */
-int vmsvga3dSetLightData(PVGASTATE pThis, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5608 +5609 @@
 }
 
-int vmsvga3dSetLightEnabled(PVGASTATE pThis, uint32_t cid, uint32_t index, uint32_t enabled)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5633 +5634 @@
            /* Load the default settings if none have been set yet. */
            if (!pContext->state.aLightData[index].fValidData)
-               vmsvga3dSetLightData(pThis, cid, index, (SVGA3dLightData *)&vmsvga3d_default_light);
+               vmsvga3dSetLightData(pThisCC, cid, index, (SVGA3dLightData *)&vmsvga3d_default_light);
         }
         glEnable(GL_LIGHT0 + index);
@@ -5644 +5645 @@
 }
 
-int vmsvga3dSetViewPort(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5667 +5668 @@
     /* Reset the projection matrix as that relies on the viewport setting. */
     if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
-    {
-        vmsvga3dSetTransform(pThis, cid, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
-    }
+        vmsvga3dSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION,
+                             pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
     else
     {
@@ -5680 +5680 @@
         matrix[10] = 1.0;
         matrix[15] = 1.0;
-        vmsvga3dSetTransform(pThis, cid, SVGA3D_TRANSFORM_PROJECTION, matrix);
+        vmsvga3dSetTransform(pThisCC, cid, SVGA3D_TRANSFORM_PROJECTION, matrix);
     }
 
@@ -5686 +5686 @@
 }
 
-int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid,  uint32_t index, float plane[4])
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4])
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     double                oglPlane[4];
@@ -5717 +5717 @@
 }
 
-int vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5749 +5749 @@
 }
 
-int vmsvga3dCommandClear(PVGASTATE pThis, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil,
+int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil,
                          uint32_t cRects, SVGA3dRect *pRect)
 {
     GLbitfield            mask = 0;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     GLboolean             fDepthWriteEnabled = GL_FALSE;
@@ -5953 +5953 @@
 }
 
-int vmsvga3dResetTransformMatrices(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext)
+static int vmsvga3dResetTransformMatrices(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
 {
     int rc;
@@ -5959 +5959 @@
     /* Reset the view matrix (also takes the world matrix into account). */
     if (pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].fValid == true)
-    {
-        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_VIEW, pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
-    }
+        rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW,
+                                  pContext->state.aTransformState[SVGA3D_TRANSFORM_VIEW].matrix);
     else
     {
@@ -5972 +5971 @@
         matrix[10] = 1.0;
         matrix[15] = 1.0;
-        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_VIEW, matrix);
+        rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_VIEW, matrix);
     }
 
@@ -5978 +5977 @@
     if (pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].fValid == true)
     {
-        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
+        rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, pContext->state.aTransformState[SVGA3D_TRANSFORM_PROJECTION].matrix);
     }
     else
@@ -5990 +5989 @@
         matrix[10] = 1.0;
         matrix[15] = 1.0;
-        rc = vmsvga3dSetTransform(pThis, pContext->id, SVGA3D_TRANSFORM_PROJECTION, matrix);
+        rc = vmsvga3dSetTransform(pThisCC, pContext->id, SVGA3D_TRANSFORM_PROJECTION, matrix);
     }
     AssertRC(rc);
@@ -5996 +5995 @@
 }
 
-int vmsvga3dDrawPrimitivesProcessVertexDecls(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext,
-                                             uint32_t iVertexDeclBase, uint32_t numVertexDecls,
-                                             SVGA3dVertexDecl *pVertexDecl,
-                                             SVGA3dVertexDivisor const *paVertexDivisors, uint32_t cInstances)
-{
-    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
+static int vmsvga3dDrawPrimitivesProcessVertexDecls(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext,
+                                                    uint32_t iVertexDeclBase, uint32_t numVertexDecls,
+                                                    SVGA3dVertexDecl *pVertexDecl,
+                                                    SVGA3dVertexDivisor const *paVertexDivisors, uint32_t cInstances)
+{
+    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
     unsigned const      sidVertex = pVertexDecl[0].array.surfaceId;
 
@@ -6182 +6181 @@
 }
 
-int vmsvga3dDrawPrimitivesCleanupVertexDecls(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+static int vmsvga3dDrawPrimitivesCleanupVertexDecls(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t iVertexDeclBase,
+                                                    uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
 
     /* Clean up the vertex declarations. */
@@ -6193 +6193 @@
             /* Reset the transformation matrices in case of a switch back from pretransformed mode. */
             Log(("vmsvga3dDrawPrimitivesCleanupVertexDecls: reset world and projection matrices after transformation reset (pre-transformed -> transformed)\n"));
-            vmsvga3dResetTransformMatrices(pThis, pContext);
+            vmsvga3dResetTransformMatrices(pThisCC, pContext);
         }
 
@@ -6262 +6262 @@
 }
 
-int vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
+int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
                            uint32_t numRanges, SVGA3dPrimitiveRange *pRange, uint32_t cVertexDivisor,
                            SVGA3dVertexDivisor *pVertexDivisor)
 {
-    PVMSVGA3DSTATE               pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE               pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_INTERNAL_ERROR);
     uint32_t                     iCurrentVertex;
@@ -6403 +6403 @@
         }
 
-        rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pThis, pContext, iCurrentVertex, iVertex - iCurrentVertex,
+        rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pThisCC, pContext, iCurrentVertex, iVertex - iCurrentVertex,
                                                       &pVertexDecl[iCurrentVertex], pVertexDivisor, cInstances);
         AssertRCReturn(rc, rc);
@@ -6562 +6562 @@
         }
 
-        rc = vmsvga3dDrawPrimitivesCleanupVertexDecls(pThis, pContext, iCurrentVertex, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
+        rc = vmsvga3dDrawPrimitivesCleanupVertexDecls(pThisCC, pContext, iCurrentVertex,
+                                                      iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex]);
         AssertRCReturn(rc, rc);
 
@@ -6631 +6632 @@
 
 
-int vmsvga3dShaderDefine(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
+int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
 {
     PVMSVGA3DSHADER       pShader;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -6661 +6662 @@
         /* If one already exists with this id, then destroy it now. */
         if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
-            vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paVertexShader[shid].type);
+            vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
 
         pShader = &pContext->paVertexShader[shid];
@@ -6680 +6681 @@
         /* If one already exists with this id, then destroy it now. */
         if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
-            vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paPixelShader[shid].type);
+            vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
 
         pShader = &pContext->paPixelShader[shid];
@@ -6729 +6730 @@
 }
 
-int vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     PVMSVGA3DSHADER       pShader = NULL;
@@ -6778 +6779 @@
 }
 
-int vmsvga3dShaderSet(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
-{
-    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
+int vmsvga3dShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
+{
+    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     int                 rc;
@@ -6849 +6850 @@
 }
 
-int vmsvga3dShaderSetConst(PVGASTATE pThis, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 

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

@@ -45 +45 @@
  *
  * @returns VBox status code.
- * @param   pThis               The VMSVGA device state.
- * @param   pContext            The freshly loaded context to reinitialize.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
+ * @param   pContext        The freshly loaded context to reinitialize.
  */
-static int vmsvga3dLoadReinitContext(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext)
+static int vmsvga3dLoadReinitContext(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
 {
     int      rc;
@@ -65 +65 @@
             target.face     = 0;
             target.mipmap   = 0;
-            rc = vmsvga3dSetRenderTarget(pThis, cid, (SVGA3dRenderTargetType)j, target);
+            rc = vmsvga3dSetRenderTarget(pThisCC, cid, (SVGA3dRenderTargetType)j, target);
             AssertRCReturn(rc, rc);
         }
@@ -78 +78 @@
 
         if (pRenderState->state != SVGA3D_RS_INVALID)
-            vmsvga3dSetRenderState(pThis, pContext->id, 1, pRenderState);
+            vmsvga3dSetRenderState(pThisCC, pContext->id, 1, pRenderState);
     }
     Log(("vmsvga3dLoadReinitContext: Recreate render state END\n"));
@@ -91 +91 @@
 
             if (pTextureState->name != SVGA3D_TS_INVALID)
-                vmsvga3dSetTextureState(pThis, pContext->id, 1, pTextureState);
+                vmsvga3dSetTextureState(pThisCC, pContext->id, 1, pTextureState);
         }
     }
@@ -100 +100 @@
     {
         if (pContext->state.aClipPlane[j].fValid == true)
-            vmsvga3dSetClipPlane(pThis, cid, j, pContext->state.aClipPlane[j].plane);
+            vmsvga3dSetClipPlane(pThisCC, cid, j, pContext->state.aClipPlane[j].plane);
     }
 
@@ -107 +107 @@
     {
         if (pContext->state.aLightData[j].fValidData == true)
-            vmsvga3dSetLightData(pThis, cid, j, &pContext->state.aLightData[j].data);
+            vmsvga3dSetLightData(pThisCC, cid, j, &pContext->state.aLightData[j].data);
         if (pContext->state.aLightData[j].fEnabled)
-            vmsvga3dSetLightEnabled(pThis, cid, j, true);
+            vmsvga3dSetLightEnabled(pThisCC, cid, j, true);
     }
 
@@ -118 +118 @@
         {
             if (pContext->state.aTransformState[j].fValid == true)
-                vmsvga3dSetTransform(pThis, cid, (SVGA3dTransformType)j, pContext->state.aTransformState[j].matrix);
+                vmsvga3dSetTransform(pThisCC, cid, (SVGA3dTransformType)j, pContext->state.aTransformState[j].matrix);
         }
     }
@@ -128 +128 @@
         {
             if (pContext->state.aMaterial[j].fValid == true)
-                vmsvga3dSetMaterial(pThis, cid, (SVGA3dFace)j, &pContext->state.aMaterial[j].material);
+                vmsvga3dSetMaterial(pThisCC, cid, (SVGA3dFace)j, &pContext->state.aMaterial[j].material);
         }
     }
 
     if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
-        vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
+        vmsvga3dSetScissorRect(pThisCC, cid, &pContext->state.RectScissor);
     if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
-        vmsvga3dSetZRange(pThis, cid, pContext->state.zRange);
+        vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
     if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
-        vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
+        vmsvga3dSetViewPort(pThisCC, cid, &pContext->state.RectViewPort);
     if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VERTEXSHADER)
-        vmsvga3dShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
+        vmsvga3dShaderSet(pThisCC, pContext, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
     if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_PIXELSHADER)
-        vmsvga3dShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
+        vmsvga3dShaderSet(pThisCC, pContext, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
 
     Log(("vmsvga3dLoadReinitContext: returns [cid=%#x]\n", cid));
@@ -150 +150 @@
 {
     RT_NOREF(pDevIns, pThisCC, uPass);
-    PVMSVGA3DSTATE  pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE  pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     PCPDMDEVHLPR3   pHlp = pDevIns->pHlpR3;
@@ -193 +193 @@
                 if (pContext->id != VMSVGA3D_SHARED_CTX_ID)
                 {
-                    rc = vmsvga3dContextDefineOgl(pThis, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
+                    rc = vmsvga3dContextDefineOgl(pThisCC, VMSVGA3D_SHARED_CTX_ID, VMSVGA3D_DEF_CTX_F_SHARED_CTX);
                     AssertRCReturn(rc, rc);
                 }
@@ -200 +200 @@
 #endif
             {
-                rc = vmsvga3dContextDefine(pThis, cid);
+                rc = vmsvga3dContextDefine(pThisCC, cid);
                 AssertRCReturn(rc, rc);
 
@@ -243 +243 @@
                     AssertRCReturn(rc, rc);
 
-                    rc = vmsvga3dShaderDefine(pThis, cid, shid, shader.type, shader.cbData, pData);
+                    rc = vmsvga3dShaderDefine(pThisCC, cid, shid, shader.type, shader.cbData, pData);
                     AssertRCReturn(rc, rc);
 
@@ -274 +274 @@
                     AssertRCReturn(rc, rc);
 
-                    rc = vmsvga3dShaderDefine(pThis, cid, shid, shader.type, shader.cbData, pData);
+                    rc = vmsvga3dShaderDefine(pThisCC, cid, shid, shader.type, shader.cbData, pData);
                     AssertRCReturn(rc, rc);
 
@@ -291 +291 @@
                 if (ShaderConst.fValid)
                 {
-                    rc = vmsvga3dShaderSetConst(pThis, cid, j, SVGA3D_SHADERTYPE_PS, ShaderConst.ctype, 1, ShaderConst.value);
+                    rc = vmsvga3dShaderSetConst(pThisCC, cid, j, SVGA3D_SHADERTYPE_PS, ShaderConst.ctype, 1, ShaderConst.value);
                     AssertRCReturn(rc, rc);
                 }
@@ -306 +306 @@
                 if (ShaderConst.fValid)
                 {
-                    rc = vmsvga3dShaderSetConst(pThis, cid, j, SVGA3D_SHADERTYPE_VS, ShaderConst.ctype, 1, ShaderConst.value);
+                    rc = vmsvga3dShaderSetConst(pThisCC, cid, j, SVGA3D_SHADERTYPE_VS, ShaderConst.ctype, 1, ShaderConst.value);
                     AssertRCReturn(rc, rc);
                 }
@@ -358 +358 @@
                     case VMSVGA3DQUERYSTATE_BUILDING:
                         /* Start collecting data. */
-                        vmsvga3dQueryBegin(pThis, cid, SVGA3D_QUERYTYPE_OCCLUSION);
+                        vmsvga3dQueryBegin(pThisCC, cid, SVGA3D_QUERYTYPE_OCCLUSION);
                         /* Partial result. */
                         pContext->occlusion.u32QueryResult = query.u32QueryResult;
@@ -425 +425 @@
                         uint32_t idx = j + face * surface.faces[0].numMipLevels;
                         /* Load the mip map level struct. */
-                        rc = pHlp->pfnSSMGetStructEx(pSSM, &pMipmapLevel[idx], sizeof(pMipmapLevel[idx]), 0, g_aVMSVGA3DMIPMAPLEVELFields, NULL);
+                        rc = pHlp->pfnSSMGetStructEx(pSSM, &pMipmapLevel[idx], sizeof(pMipmapLevel[idx]), 0,
+                                                     g_aVMSVGA3DMIPMAPLEVELFields, NULL);
                         AssertRCReturn(rc, rc);
 
@@ -432 +433 @@
                 }
 
-                rc = vmsvga3dSurfaceDefine(pThis, sid, surface.surfaceFlags, surface.format, surface.faces, surface.multiSampleCount, surface.autogenFilter, cMipLevels, pMipmapLevelSize);
+                rc = vmsvga3dSurfaceDefine(pThisCC, sid, surface.surfaceFlags, surface.format, surface.faces,
+                                           surface.multiSampleCount, surface.autogenFilter, cMipLevels, pMipmapLevelSize);
                 AssertRCReturn(rc, rc);
 
@@ -480 +482 @@
     if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
     {
-        rc = vmsvga3dLoadReinitContext(pThis, &pState->SharedCtx);
+        rc = vmsvga3dLoadReinitContext(pThisCC, &pState->SharedCtx);
         AssertRCReturn(rc, rc);
     }
@@ -491 +493 @@
         if (pContext->id != SVGA3D_INVALID_ID)
         {
-            rc = vmsvga3dLoadReinitContext(pThis, pContext);
+            rc = vmsvga3dLoadReinitContext(pThisCC, pContext);
             AssertRCReturn(rc, rc);
         }
@@ -501 +503 @@
 
 
-static int vmsvga3dSaveContext(PCPDMDEVHLPR3 pHlp, PVGASTATE pThis, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
+static int vmsvga3dSaveContext(PCPDMDEVHLPR3 pHlp, PVGASTATECC pThisCC, PSSMHANDLE pSSM, PVMSVGA3DCONTEXT pContext)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     uint32_t cid = pContext->id;
 
@@ -637 +639 @@
 }
 
-int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM)
+int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATECC pThisCC, PSSMHANDLE pSSM)
 {
-    PVMSVGA3DSTATE  pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE  pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     PCPDMDEVHLPR3   pHlp   = pDevIns->pHlpR3;
@@ -652 +654 @@
     if (pState->SharedCtx.id == VMSVGA3D_SHARED_CTX_ID)
     {
-        rc = vmsvga3dSaveContext(pHlp, pThis, pSSM, &pState->SharedCtx);
+        rc = vmsvga3dSaveContext(pHlp, pThisCC, pSSM, &pState->SharedCtx);
         AssertRCReturn(rc, rc);
     }
@@ -660 +662 @@
     for (uint32_t i = 0; i < pState->cContexts; i++)
     {
-        rc = vmsvga3dSaveContext(pHlp, pThis, pSSM, pState->papContexts[i]);
+        rc = vmsvga3dSaveContext(pHlp, pThisCC, pSSM, pState->papContexts[i]);
         AssertRCReturn(rc, rc);
     }

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

@@ -163 +163 @@
 int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
-    RT_NOREF(pDevIns, pThisCC);
+    RT_NOREF(pDevIns, pThis);
 
     PVMSVGA3DSTATE pState;
-    pThis->svga.p3dState = pState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
+    pThisCC->svga.p3dState = pState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
 
     /* Create event semaphore. */
@@ -190 +190 @@
 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
     HRESULT hr;
-    RT_NOREF(pDevIns, pThisCC);
+    RT_NOREF(pDevIns, pThis);
 
     if (pState->pD3D9)
@@ -277 +277 @@
 }
 
-int vmsvga3dReset(PVGASTATE pThis)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
+int vmsvga3dReset(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
 
     /* Destroy all leftover surfaces. */
@@ -286 +286 @@
     {
         if (pState->papSurfaces[i]->id != SVGA3D_INVALID_ID)
-            vmsvga3dSurfaceDestroy(pThis, pState->papSurfaces[i]->id);
+            vmsvga3dSurfaceDestroy(pThisCC, pState->papSurfaces[i]->id);
     }
 
@@ -293 +293 @@
     {
         if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
-            vmsvga3dContextDestroy(pThis, pState->papContexts[i]->id);
+            vmsvga3dContextDestroy(pThisCC, pState->papContexts[i]->id);
     }
     return VINF_SUCCESS;
 }
 
-int vmsvga3dTerminate(PVGASTATE pThis)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
-    AssertReturn(pThis->svga.p3dState, VERR_NO_MEMORY);
-
-    int rc = vmsvga3dReset(pThis);
+int vmsvga3dTerminate(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
+
+    int rc = vmsvga3dReset(pThisCC);
     AssertRCReturn(rc, rc);
 
@@ -317 +317 @@
 }
 
-void vmsvga3dUpdateHostScreenViewport(PVGASTATE pThis, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
+void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
 {
     /** @todo Scroll the screen content without requiring the guest to redraw. */
-    NOREF(pThis); NOREF(idScreen); NOREF(pOldViewport);
+    RT_NOREF(pThisCC, idScreen, pOldViewport);
 }
 
@@ -424 +424 @@
 
 
-int vmsvga3dQueryCaps(PVGASTATE pThis, uint32_t idx3dCaps, uint32_t *pu32Val)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dQueryCaps(PVGASTATECC pThisCC, uint32_t idx3dCaps, uint32_t *pu32Val)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     D3DCAPS9 *pCaps = &pState->caps;
@@ -1474 +1474 @@
 }
 
-int vmsvga3dSurfaceCopy(PVGASTATE pThis, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
+int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
                         uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -2320 +2320 @@
  *
  * @returns Failure status code or @a rc.
- * @param   pThis               The shared VGA instance data.
+ * @param   pThis               The shared VGA/VMSVGA instance data.
  * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pState              The VMSVGA3d state.
@@ -2515 +2515 @@
 }
 
-int vmsvga3dGenerateMipmaps(PVGASTATE pThis, uint32_t sid, SVGA3dTextureFilter filter)
-{
-    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
+int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
+{
+    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
     HRESULT             hr;
 
@@ -2562 +2562 @@
  *
  * @returns VBox status code.
- * @param   pThis           The shared VGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   cid             Context id
  */
-int vmsvga3dContextDefine(PVGASTATE pThis, uint32_t cid)
+int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
 {
     int                     rc;
@@ -2571 +2571 @@
     HRESULT                 hr;
     D3DPRESENT_PARAMETERS   PresParam;
-    PVMSVGA3DSTATE          pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE          pState = pThisCC->svga.p3dState;
 
     Log(("vmsvga3dContextDefine id %x\n", cid));
@@ -2595 +2595 @@
     /* If one already exists with this id, then destroy it now. */
     if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
-        vmsvga3dContextDestroy(pThis, cid);
+        vmsvga3dContextDestroy(pThisCC, cid);
 
     pContext = pState->papContexts[cid];
@@ -2660 +2660 @@
  *
  * @returns VBox status code.
- * @param   pThis           The shared VGA instance data.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
  * @param   cid             Context id
  */
-int vmsvga3dContextDestroy(PVGASTATE pThis, uint32_t cid)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -2718 +2718 @@
 #endif
 
-                rc = vmsvga3dSurfaceDestroy(pThis, sid);
+                rc = vmsvga3dSurfaceDestroy(pThisCC, sid);
                 AssertRC(rc);
 
-                rc = vmsvga3dSurfaceDefine(pThis, sid, surfaceFlags, format, face, multisampleCount, autogenFilter, face[0].numMipLevels * cFaces, pMipLevelSize);
+                rc = vmsvga3dSurfaceDefine(pThisCC, sid, surfaceFlags, format, face, multisampleCount, autogenFilter,
+                                           face[0].numMipLevels * cFaces, pMipLevelSize);
                 AssertRC(rc);
 
@@ -2765 +2766 @@
         {
             if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
-                vmsvga3dShaderDestroy(pThis, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
+                vmsvga3dShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
         }
         if (pContext->paPixelShader)
@@ -2774 +2775 @@
         {
             if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
-                vmsvga3dShaderDestroy(pThis, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
+                vmsvga3dShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
         }
         if (pContext->paVertexShader)
@@ -2802 +2803 @@
 }
 
-static int vmsvga3dContextTrackUsage(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext)
+static int vmsvga3dContextTrackUsage(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
 {
 #ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -2822 +2823 @@
 
 /* Handle resize */
-int vmsvga3dChangeMode(PVGASTATE pThis)
-{
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+int vmsvga3dChangeMode(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -3016 +3017 @@
                     target.face     = 0;
                     target.mipmap   = 0;
-                    int rc = vmsvga3dSetRenderTarget(pThis, cid, (SVGA3dRenderTargetType)j, target);
+                    int rc = vmsvga3dSetRenderTarget(pThisCC, cid, (SVGA3dRenderTargetType)j, target);
                     AssertRCReturn(rc, rc);
                 }
@@ -3029 +3030 @@
 
                 if (pRenderState->state != SVGA3D_RS_INVALID)
-                    vmsvga3dSetRenderState(pThis, pContext->id, 1, pRenderState);
+                    vmsvga3dSetRenderState(pThisCC, pContext->id, 1, pRenderState);
             }
             Log(("vmsvga3dChangeMode: Recreate render state END\n"));
@@ -3042 +3043 @@
 
                     if (pTextureState->name != SVGA3D_RS_INVALID)
-                        vmsvga3dSetTextureState(pThis, pContext->id, 1, pTextureState);
+                        vmsvga3dSetTextureState(pThisCC, pContext->id, 1, pTextureState);
                 }
             }
@@ -3050 +3051 @@
                 vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
             if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
-                vmsvga3dSetZRange(pThis, cid, pContext->state.zRange);
+                vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
             if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
                 vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
@@ -3065 +3066 @@
 
 
-int vmsvga3dSetTransform(PVGASTATE pThis, uint32_t cid, SVGA3dTransformType type, float matrix[16])
+int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
 {
     D3DTRANSFORMSTATETYPE d3dState;
     HRESULT               hr;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -3144 +3145 @@
 }
 
-int vmsvga3dSetZRange(PVGASTATE pThis, uint32_t cid, SVGA3dZRange zRange)
+int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
 {
     D3DVIEWPORT9          viewport;
     HRESULT               hr;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -3216 +3217 @@
 }
 
-int vmsvga3dSetRenderState(PVGASTATE pThis, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
+int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
 {
     DWORD                       val = 0; /* Shut up MSC */
     HRESULT                     hr;
-    PVMSVGA3DSTATE              pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE              pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -3887 +3888 @@
 }
 
-int vmsvga3dSetRenderTarget(PVGASTATE pThis, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
+int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
 {
     HRESULT        hr;
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
 
     AssertReturn(pState, VERR_NO_MEMORY);
@@ -4170 +4171 @@
         /* Changing the render target resets the viewport; restore it here. */
         if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
-            vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
+            vmsvga3dSetViewPort(pThisCC, cid, &pContext->state.RectViewPort);
         if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
-            vmsvga3dSetZRange(pThis, cid, pContext->state.zRange);
+            vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
         /* Changing the render target also resets the scissor rectangle; restore it as well. */
         if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
-            vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
+            vmsvga3dSetScissorRect(pThisCC, cid, &pContext->state.RectScissor);
 
         break;
@@ -4308 +4309 @@
 }
 
-int vmsvga3dSetTextureState(PVGASTATE pThis, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
+int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
 {
     DWORD                       val = 0; /* Shut up MSC */
     HRESULT                     hr;
     PVMSVGA3DCONTEXT            pContext;
-    PVMSVGA3DSTATE              pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE              pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4596 +4597 @@
 }
 
-int vmsvga3dSetMaterial(PVGASTATE pThis, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
+int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
 {
     HRESULT               hr;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4646 +4647 @@
 }
 
-int vmsvga3dSetLightData(PVGASTATE pThis, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
+int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
 {
     HRESULT               hr;
     D3DLIGHT9             light;
     PVMSVGA3DCONTEXT      pContext;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4720 +4721 @@
 }
 
-int vmsvga3dSetLightEnabled(PVGASTATE pThis, uint32_t cid, uint32_t index, uint32_t enabled)
+int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
 {
     HRESULT               hr;
     PVMSVGA3DCONTEXT      pContext;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4742 +4743 @@
 }
 
-int vmsvga3dSetViewPort(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
+int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
 {
     HRESULT               hr;
     D3DVIEWPORT9          viewPort;
     PVMSVGA3DCONTEXT      pContext;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4774 +4775 @@
 }
 
-int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid, uint32_t index, float plane[4])
+int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
 {
     HRESULT               hr;
     PVMSVGA3DCONTEXT      pContext;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -4796 +4797 @@
 }
 
-int vmsvga3dCommandClear(PVGASTATE pThis, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
+int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth,
+                         uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
 {
     DWORD                 clearFlagD3D = 0;
@@ -4802 +4804 @@
     HRESULT               hr;
     PVMSVGA3DCONTEXT      pContext;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5047 +5049 @@
 }
 
-int vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
+int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
                            uint32_t numRanges, SVGA3dPrimitiveRange *pRange,
                            uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
@@ -5053 +5055 @@
     static const D3DVERTEXELEMENT9 sVertexEnd = D3DDECL_END();
 
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_INTERNAL_ERROR);
 
@@ -5329 +5331 @@
 
         /* Make sure we can track drawing usage of active render targets and textures. */
-        vmsvga3dContextTrackUsage(pThis, pContext);
+        vmsvga3dContextTrackUsage(pThisCC, pContext);
     }
 
@@ -5358 +5360 @@
 
 
-int vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
+int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
 {
     HRESULT               hr;
     RECT                  rect;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5387 +5389 @@
 
 
-int vmsvga3dShaderDefine(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
+int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type,
+                         uint32_t cbData, uint32_t *pShaderData)
 {
     HRESULT               hr;
     PVMSVGA3DSHADER       pShader;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -5434 +5437 @@
         /* If one already exists with this id, then destroy it now. */
         if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
-            vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paVertexShader[shid].type);
+            vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
 
         pShader = &pContext->paVertexShader[shid];
@@ -5453 +5456 @@
         /* If one already exists with this id, then destroy it now. */
         if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
-            vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paPixelShader[shid].type);
+            vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
 
         pShader = &pContext->paPixelShader[shid];
@@ -5526 +5529 @@
 }
 
-int vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
-{
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
+{
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     PVMSVGA3DSHADER       pShader = NULL;
@@ -5572 +5575 @@
 }
 
-int vmsvga3dShaderSet(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
-{
-    PVMSVGA3DSTATE      pState = pThis->svga.p3dState;
+int vmsvga3dShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
+{
+    PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
     HRESULT             hr;
@@ -5639 +5642 @@
 }
 
-int vmsvga3dShaderSetConst(PVGASTATE pThis, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
+int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type,
+                           SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
 {
     HRESULT               hr;
-    PVMSVGA3DSTATE        pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE        pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 

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

@@ -46 +46 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The shared VGA instance data.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   sid                 The ID of the surface to (re-)define.
  * @param   surfaceFlags        .
@@ -56 +56 @@
  * @param   paMipLevelSizes     .
  */
-int vmsvga3dSurfaceDefine(PVGASTATE pThis, uint32_t sid, uint32_t surfaceFlags, SVGA3dSurfaceFormat format,
+int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, uint32_t surfaceFlags, SVGA3dSurfaceFormat format,
                           SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES], uint32_t multisampleCount,
                           SVGA3dTextureFilter autogenFilter, uint32_t cMipLevels, SVGA3dSize *paMipLevelSizes)
 {
     PVMSVGA3DSURFACE pSurface;
-    PVMSVGA3DSTATE   pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE   pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -119 +119 @@
     /* If one already exists with this id, then destroy it now. */
     if (pSurface->id != SVGA3D_INVALID_ID)
-        vmsvga3dSurfaceDestroy(pThis, sid);
+        vmsvga3dSurfaceDestroy(pThisCC, sid);
 
     RT_ZERO(*pSurface);
@@ -330 +330 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The shared VGA instance data.
- * @param   sid                 The ID of the surface to destroy.
+ * @param   pThisCC         The VGA/VMSVGA state for ring-3.
+ * @param   sid             The ID of the surface to destroy.
  */
-int vmsvga3dSurfaceDestroy(PVGASTATE pThis, uint32_t sid)
+int vmsvga3dSurfaceDestroy(PVGASTATECC pThisCC, uint32_t sid)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -379 +379 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The shared VGA instance data.
+ * @param   pThis               The shared VGA/VMSVGA state.
+ * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   pDstSfcImg
  * @param   pDstBox
@@ -386 +387 @@
  * @param   enmMode
  */
-int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
+int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
                               SVGA3dSurfaceImageId const *pSrcSfcImg, SVGA3dBox const *pSrcBox, SVGA3dStretchBltMode enmMode)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -472 +473 @@
  *
  * @returns VBox status code (currently ignored).
- * @param   pThis               The shared VGA instance data.
+ * @param   pThis               The shared VGA/VMSVGA instance data.
  * @param   pThisCC             The VGA/VMSVGA state for ring-3.
  * @param   guest               .
@@ -483 +484 @@
                        SVGA3dTransferType transfer, uint32_t cCopyBoxes, SVGA3dCopyBox *paBoxes)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -694 +695 @@
 }
 
-int vmsvga3dQueryBegin(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type)
+int vmsvga3dQueryBegin(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -728 +729 @@
 }
 
-int vmsvga3dQueryEnd(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
+int vmsvga3dQueryEnd(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
 {
     RT_NOREF(guestResult);
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -761 +762 @@
 int vmsvga3dQueryWait(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
 {
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -824 +825 @@
     }
 
-    VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, idDstScreen);
+    VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThisCC, idDstScreen);
     AssertReturn(pScreen, VERR_INTERNAL_ERROR);
 
@@ -902 +903 @@
 {
     /* Deprecated according to svga3d_reg.h. */
-    PVMSVGA3DSTATE pState = pThis->svga.p3dState;
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_NO_MEMORY);
 
@@ -910 +911 @@
 
     /** @todo Detect screen from coords? Or split rect to screens? */
-    VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThis, 0);
+    VMSVGASCREENOBJECT *pScreen = vmsvgaR3GetScreenObject(pThisCC, 0);
     AssertReturn(pScreen, VERR_INTERNAL_ERROR);
 

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

@@ -52 +52 @@
 
 /* DevVGA-SVGA.cpp: */
-void vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(PPDMDEVINS pDevIns, PVGASTATE pThis, uint32_t sid);
+void vmsvgaR33dSurfaceUpdateHeapBuffersOnFifoThread(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t sid);
 
 
@@ -59 +59 @@
 int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC);
 int vmsvga3dLoadExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
-int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATE pThis, PSSMHANDLE pSSM);
-int vmsvga3dTerminate(PVGASTATE pThis);
-int vmsvga3dReset(PVGASTATE pThis);
-void vmsvga3dUpdateHostScreenViewport(PVGASTATE pThis, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport);
-int vmsvga3dQueryCaps(PVGASTATE pThis, uint32_t idx3dCaps, uint32_t *pu32Val);
-
-int vmsvga3dSurfaceDefine(PVGASTATE pThis, uint32_t sid, uint32_t surfaceFlags, SVGA3dSurfaceFormat format, SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES], uint32_t multisampleCount, SVGA3dTextureFilter autogenFilter, uint32_t cMipLevels, SVGA3dSize *pMipLevelSize);
-int vmsvga3dSurfaceDestroy(PVGASTATE pThis, uint32_t sid);
-int vmsvga3dSurfaceCopy(PVGASTATE pThis, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox);
-int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
+int vmsvga3dSaveExec(PPDMDEVINS pDevIns, PVGASTATECC pThisCC, PSSMHANDLE pSSM);
+int vmsvga3dTerminate(PVGASTATECC pThisCC);
+int vmsvga3dReset(PVGASTATECC pThisCC);
+void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport);
+int vmsvga3dQueryCaps(PVGASTATECC pThisCC, uint32_t idx3dCaps, uint32_t *pu32Val);
+
+int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, uint32_t surfaceFlags, SVGA3dSurfaceFormat format,
+                          SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES], uint32_t multisampleCount,
+                          SVGA3dTextureFilter autogenFilter, uint32_t cMipLevels, SVGA3dSize *pMipLevelSize);
+int vmsvga3dSurfaceDestroy(PVGASTATECC pThisCC, uint32_t sid);
+int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
+                        uint32_t cCopyBoxes, SVGA3dCopyBox *pBox);
+int vmsvga3dSurfaceStretchBlt(PVGASTATE pThis, PVGASTATECC pThisCC,
+                              SVGA3dSurfaceImageId const *pDstSfcImg, SVGA3dBox const *pDstBox,
                               SVGA3dSurfaceImageId const *pSrcSfcImg, SVGA3dBox const *pSrcBox, SVGA3dStretchBltMode enmMode);
 int vmsvga3dSurfaceDMA(PVGASTATE pThis, PVGASTATECC pThisCC, SVGA3dGuestImage guest, SVGA3dSurfaceImageId host, SVGA3dTransferType transfer, uint32_t cCopyBoxes, SVGA3dCopyBox *pBoxes);
 int vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t dest, SVGASignedRect destRect, SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect);
 
-int vmsvga3dContextDefine(PVGASTATE pThis, uint32_t cid);
-int vmsvga3dContextDestroy(PVGASTATE pThis, uint32_t cid);
-
-int vmsvga3dChangeMode(PVGASTATE pThis);
-
-int vmsvga3dSetTransform(PVGASTATE pThis, uint32_t cid, SVGA3dTransformType type, float matrix[16]);
-int vmsvga3dSetZRange(PVGASTATE pThis, uint32_t cid, SVGA3dZRange zRange);
-int vmsvga3dSetRenderState(PVGASTATE pThis, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState);
-int vmsvga3dSetRenderTarget(PVGASTATE pThis, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target);
-int vmsvga3dSetTextureState(PVGASTATE pThis, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState);
-int vmsvga3dSetMaterial(PVGASTATE pThis, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial);
-int vmsvga3dSetLightData(PVGASTATE pThis, uint32_t cid, uint32_t index, SVGA3dLightData *pData);
-int vmsvga3dSetLightEnabled(PVGASTATE pThis, uint32_t cid, uint32_t index, uint32_t enabled);
-int vmsvga3dSetViewPort(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect);
-int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid,  uint32_t index, float plane[4]);
-int vmsvga3dCommandClear(PVGASTATE pThis, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect);
+int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid);
+int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid);
+
+int vmsvga3dChangeMode(PVGASTATECC pThisCC);
+
+int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16]);
+int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange);
+int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState);
+int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target);
+int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState);
+int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial);
+int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData);
+int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled);
+int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect);
+int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid,  uint32_t index, float plane[4]);
+int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect);
 int vmsvga3dCommandPresent(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect);
-int vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange *pNumRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor);
-int vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect);
-int vmsvga3dGenerateMipmaps(PVGASTATE pThis, uint32_t sid, SVGA3dTextureFilter filter);
-
-int vmsvga3dShaderDefine(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData);
-int vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type);
-int vmsvga3dShaderSet(PVGASTATE pThis, struct VMSVGA3DCONTEXT *pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid);
-int vmsvga3dShaderSetConst(PVGASTATE pThis, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues);
-
-int vmsvga3dQueryBegin(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type);
-int vmsvga3dQueryEnd(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
+int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange *pNumRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor);
+int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect);
+int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter);
+
+int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData);
+int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type);
+int vmsvga3dShaderSet(PVGASTATECC pThisCC, struct VMSVGA3DCONTEXT *pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid);
+int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues);
+
+int vmsvga3dQueryBegin(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type);
+int vmsvga3dQueryEnd(PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
 int vmsvga3dQueryWait(PVGASTATE pThis, PVGASTATECC pThisCC, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult);
 
@@ -118 +122 @@
 #endif
 
-void vmsvga3dUpdateHeapBuffersForSurfaces(PVGASTATE pThis, uint32_t sid);
-void vmsvga3dInfoContextWorker(PVGASTATE pThis, PCDBGFINFOHLP pHlp, uint32_t cid, bool fVerbose);
-void vmsvga3dInfoSurfaceWorker(PPDMDEVINS pDevIns, PVGASTATE pThis, PCDBGFINFOHLP pHlp, uint32_t sid, bool fVerbose,
-                               uint32_t cxAscii, bool fInvY, const char *pszBitmapPath);
+void vmsvga3dUpdateHeapBuffersForSurfaces(PVGASTATECC pThisCC, uint32_t sid);
+void vmsvga3dInfoContextWorker(PVGASTATECC pThisCC, PCDBGFINFOHLP pHlp, uint32_t cid, bool fVerbose);
+void vmsvga3dInfoSurfaceWorker(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC, PCDBGFINFOHLP pHlp, uint32_t sid,
+                               bool fVerbose, uint32_t cxAscii, bool fInvY, const char *pszBitmapPath);
 
 /* DevVGA-SVGA3d-shared.cpp: */

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

@@ -1243 +1243 @@
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
         ret = !pThis->svga.fEnabled            ? pThisCC->pbVRam[addr]
-            : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? pThis->svga.pbVgaFrameBufferR3[addr] : 0xff;
+            : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? pThisCC->svga.pbVgaFrameBufferR3[addr] : 0xff;
 #else
         ret = pThisCC->pbVRam[addr];
@@ -1255 +1255 @@
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
         ret = !pThis->svga.fEnabled           ? pThisCC->pbVRam[off]
-            : off < VMSVGA_VGA_FB_BACKUP_SIZE ? pThis->svga.pbVgaFrameBufferR3[off] : 0xff;
+            : off < VMSVGA_VGA_FB_BACKUP_SIZE ? pThisCC->svga.pbVgaFrameBufferR3[off] : 0xff;
 #else
         ret = pThisCC->pbVRam[off];
@@ -1264 +1264 @@
 #ifdef VMSVGA_WITH_VGA_FB_BACKUP_AND_IN_RING3
         pThis->latch = !pThis->svga.fEnabled            ? ((uint32_t *)pThisCC->pbVRam)[addr]
-                     : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? ((uint32_t *)pThis->svga.pbVgaFrameBufferR3)[addr] : UINT32_MAX;
+                     : addr < VMSVGA_VGA_FB_BACKUP_SIZE ? ((uint32_t *)pThisCC->svga.pbVgaFrameBufferR3)[addr] : UINT32_MAX;
 #else
         pThis->latch = ((uint32_t *)pThisCC->pbVRam)[addr];
@@ -1352 +1352 @@
                 pThisCC->pbVRam[addr]      = val;
             else if (addr < VMSVGA_VGA_FB_BACKUP_SIZE)
-                pThis->svga.pbVgaFrameBufferR3[addr] = val;
+                pThisCC->svga.pbVgaFrameBufferR3[addr] = val;
             else
             {
@@ -1381 +1381 @@
                 pThisCC->pbVRam[addr]      = val;
             else if (addr < VMSVGA_VGA_FB_BACKUP_SIZE)
-                pThis->svga.pbVgaFrameBufferR3[addr] = val;
+                pThisCC->svga.pbVgaFrameBufferR3[addr] = val;
             else
             {
@@ -1466 +1466 @@
             pu32Dst = &((uint32_t *)pThisCC->pbVRam)[addr];
         else if (addr * 4 + 3 < VMSVGA_VGA_FB_BACKUP_SIZE)
-            pu32Dst = &((uint32_t *)pThis->svga.pbVgaFrameBufferR3)[addr];
+            pu32Dst = &((uint32_t *)pThisCC->svga.pbVgaFrameBufferR3)[addr];
         else
         {
@@ -5564 +5564 @@
      */
     if (pThis->svga.fFIFOThreadSleeping && pThis->svga.fEnabled && pThis->svga.fConfigured)
-        vmsvgaR3FifoWatchdogTimer(pDevIns, pThis);
+        vmsvgaR3FifoWatchdogTimer(pDevIns, pThis, pThisCC);
 # endif
 }
@@ -6587 +6587 @@
         rc = PDMDevHlpPCIIORegionCreateMmio2Ex(pDevIns, pThis->pciRegions.iFIFO, pThis->svga.cbFIFO,
                                                PCI_ADDRESS_SPACE_MEM_PREFETCH, 0 /*fFlags*/, vmsvgaR3PciIORegionFifoMapUnmap,
-                                               "VMSVGA-FIFO", (void **)&pThis->svga.pFIFOR3, &pThis->hMmio2VmSvgaFifo);
+                                               "VMSVGA-FIFO", (void **)&pThisCC->svga.pau32FIFO, &pThis->hMmio2VmSvgaFifo);
         AssertRCReturn(rc, PDMDevHlpVMSetError(pDevIns, rc, RT_SRC_POS,
                                                N_("Failed to create VMSVGA FIFO (%u bytes)"), pThis->svga.cbFIFO));
@@ -7335 +7335 @@
     {
         rc = PDMDevHlpMmio2SetUpContext(pDevIns, pThis->hMmio2VmSvgaFifo, 0 /* off */, PAGE_SIZE,
-                                        (void **)&pThis->svga.CTX_SUFF(pFIFO));
+                                        (void **)&pThisCC->svga.pau32FIFO);
         AssertLogRelMsgRCReturn(rc, ("PDMDevHlpMapMMIO2IntoR0(%#x,) -> %Rrc\n", pThis->svga.cbFIFO, rc), rc);
     }

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

@@ -342 +342 @@
 
 #ifdef VBOX_WITH_VMSVGA
-    VMSVGAState                 svga;
+    VMSVGASTATE                 svga;
 #endif
 
@@ -571 +571 @@
     /** Status LUN: Partner of ILeds. */
     R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
+
+#ifdef VBOX_WITH_VMSVGA
+    /** The VMSVGA ring-3 state. */
+    VMSVGASTATER3               svga;
+#endif
 
     /** The VGA BIOS ROM data. */
@@ -636 +641 @@
 typedef struct VGASTATER0
 {
-    /** The R0 vram pointer... */
+    /** The R0 vram pointer. */
     R0PTRTYPE(uint8_t *)        pbVRam;
+#ifdef VBOX_WITH_VMSVGA
+    /** The VMSVGA ring-0 state. */
+    VMSVGASTATER0               svga;
+#endif
 } VGASTATER0;
 /** Pointer to the ring-0 VGA state. */
@@ -648 +657 @@
 typedef struct VGASTATERC
 {
-    /** Pointer to the GC vram mapping. */
+    /** Pointer to the RC vram mapping. */
     RCPTRTYPE(uint8_t *)        pbVRam;
 } VGASTATERC;