Changeset 80346 in vbox for trunk/src/VBox/VMM

Timestamp:

Aug 19, 2019 7:36:29 PM (5 years ago)

Author:

vboxsync

Message:

VMM,PciRaw: Eliminate duplicate PGVM/PVMCC and PGVMCPU/PVMCPUCC parameters in ring-0 code. butref:9217

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/NEMAllNativeTemplate-win.cpp.h (modified) (62 diffs)
• VMMR0/GMMR0.cpp (modified) (70 diffs)
• VMMR0/GVMMR0.cpp (modified) (85 diffs)
• VMMR0/NEMR0Native-win.cpp (modified) (93 diffs)
• VMMR0/PDMR0Device.cpp (modified) (16 diffs)
• VMMR0/PDMR0Driver.cpp (modified) (2 diffs)
• VMMR0/PGMR0.cpp (modified) (31 diffs)
• VMMR0/VMMR0.cpp (modified) (110 diffs)
• VMMR3/NEMR3Native-win.cpp (modified) (1 diff)

trunk/src/VBox/VMM/VMMAll/NEMAllNativeTemplate-win.cpp.h

@@ -36 +36 @@
 # define NEMWIN_NEED_GET_REGISTER
 # if defined(IN_RING0) || defined(NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS)
-#  define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_pGVCpu, a_enmReg, a_Expr, a_Msg) \
+#  define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, a_Expr, a_Msg) \
     do { \
         HV_REGISTER_VALUE TmpVal; \
-        nemHCWinGetRegister(a_pVCpu, a_pGVCpu, a_enmReg, &TmpVal); \
+        nemHCWinGetRegister(a_pVCpu, a_enmReg, &TmpVal); \
         AssertMsg(a_Expr, a_Msg); \
     } while (0)
 # else
-#  define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_pGVCpu, a_enmReg, a_Expr, a_Msg) \
+#  define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, a_Expr, a_Msg) \
     do { \
         WHV_REGISTER_VALUE TmpVal; \
@@ -51 +51 @@
 # endif
 #else
-# define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_pGVCpu, a_enmReg, a_Expr, a_Msg) do { } while (0)
+# define NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, a_Expr, a_Msg) do { } while (0)
 #endif
 
@@ -57 +57 @@
  * Asserts the correctness of a 64-bit register value in a message/context.
  */
-#define NEMWIN_ASSERT_MSG_REG_VAL64(a_pVCpu, a_pGVCpu, a_enmReg, a_u64Val) \
-    NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_pGVCpu, a_enmReg, (a_u64Val) == TmpVal.Reg64, \
+#define NEMWIN_ASSERT_MSG_REG_VAL64(a_pVCpu, a_enmReg, a_u64Val) \
+    NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, (a_u64Val) == TmpVal.Reg64, \
                               (#a_u64Val "=%#RX64, expected %#RX64\n", (a_u64Val), TmpVal.Reg64))
 /** @def NEMWIN_ASSERT_MSG_REG_VAL
  * Asserts the correctness of a segment register value in a message/context.
  */
-#define NEMWIN_ASSERT_MSG_REG_SEG(a_pVCpu, a_pGVCpu, a_enmReg, a_SReg) \
-    NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_pGVCpu, a_enmReg, \
+#define NEMWIN_ASSERT_MSG_REG_SEG(a_pVCpu, a_enmReg, a_SReg) \
+    NEMWIN_ASSERT_MSG_REG_VAL(a_pVCpu, a_enmReg, \
                                  (a_SReg).Base       == TmpVal.Segment.Base \
                               && (a_SReg).Limit      == TmpVal.Segment.Limit \
@@ -109 +109 @@
 #ifdef IN_RING0
     /** @todo optimize further, caller generally has the physical address. */
-    PGVM pGVM = GVMMR0FastGetGVMByVM(pVM);
-    AssertReturn(pGVM, VERR_INVALID_VM_HANDLE);
-    return nemR0WinMapPages(pGVM, pVM, &pGVM->aCpus[pVCpu->idCpu],
+    return nemR0WinMapPages(pVM, pVCpu,
                             GCPhysSrc & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
                             GCPhysDst & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK,
@@ -136 +134 @@
 {
 # ifdef IN_RING0
-    PGVM pGVM = GVMMR0FastGetGVMByVM(pVM);
-    AssertReturn(pGVM, VERR_INVALID_VM_HANDLE);
-    return nemR0WinUnmapPages(pGVM, &pGVM->aCpus[pVCpu->idCpu], GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, 1);
+    return nemR0WinUnmapPages(pVM, pVCpu, GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK, 1);
 # else
     pVCpu->nem.s.Hypercall.UnmapPages.GCPhys    = GCPhys & ~(RTGCPHYS)X86_PAGE_OFFSET_MASK;
@@ -398 +394 @@
         ADD_REG64(WHvX64RegisterTscAux, pCtxMsrs->msr.TscAux);
 #if 0 /** @todo these registers aren't available? Might explain something.. .*/
-        const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM->pVM);
+        const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pVM);
         if (enmCpuVendor != CPUMCPUVENDOR_AMD)
         {
@@ -665 +661 @@
 
 //#ifdef LOG_ENABLED
-//    const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM->pVM);
+//    const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pVM);
 //#endif
     if (fWhat & CPUMCTX_EXTRN_OTHER_MSRS)
@@ -1291 +1287 @@
     AssertReturn(g_pfnHvlInvokeHypercall, VERR_NEM_MISSING_KERNEL_API);
 
-    pInput->PartitionId = pGVCpu->pGVM->nemr0.s.idHvPartition;
-    pInput->VpIndex     = pGVCpu->idCpu;
+    pInput->PartitionId = pVCpu->pGVM->nemr0.s.idHvPartition;
+    pInput->VpIndex     = pVCpu->idCpu;
     pInput->fFlags      = 0;
     pInput->Names[0]    = (HV_REGISTER_NAME)enmReg;
@@ -1823 +1819 @@
  * @param   pGVM            The global (ring-0) VM structure.
  * @param   pGVCpu          The global (ring-0) per CPU structure.
+ * @param   fWhat           What to import.
+ * @param   pszCaller       Who is doing the importing.
+ */
+DECLINLINE(VBOXSTRICTRC) nemR0WinImportStateStrict(PGVM pGVM, PGVMCPU pGVCpu, uint64_t fWhat, const char *pszCaller)
+{
+    int rc = nemR0WinImportState(pGVM, pGVCpu, &pGVCpu->cpum.GstCtx, fWhat, true /*fCanUpdateCr3*/);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(rc == VINF_SUCCESS);
+        return VINF_SUCCESS;
+    }
+
+    if (rc == VERR_NEM_FLUSH_TLB)
+    {
+        Log4(("%s/%u: nemR0WinImportState -> %Rrc\n", pszCaller, pGVCpu->idCpu, -rc));
+        return -rc;
+    }
+    RT_NOREF(pszCaller);
+    AssertMsgFailedReturn(("%s/%u: nemR0WinImportState failed: %Rrc\n", pszCaller, pGVCpu->idCpu, rc), rc);
+}
+#endif /* IN_RING0 && NEM_WIN_TEMPLATE_MODE_OWN_RUN_API*/
+
+#if defined(NEM_WIN_TEMPLATE_MODE_OWN_RUN_API) || defined(IN_RING3)
+/**
+ * Wrapper around nemR0WinImportStateStrict and nemHCWinCopyStateFromHyperV.
+ *
+ * Unlike the wrapped APIs, this checks whether it's necessary.
+ *
+ * @returns VBox strict status code.
  * @param   pVCpu           The cross context per CPU structure.
  * @param   fWhat           What to import.
  * @param   pszCaller       Who is doing the importing.
  */
-DECLINLINE(VBOXSTRICTRC) nemR0WinImportStateStrict(PGVM pGVM, PGVMCPU pGVCpu, PVMCPUCC pVCpu, uint64_t fWhat, const char *pszCaller)
-{
-    int rc = nemR0WinImportState(pGVM, pGVCpu, &pVCpu->cpum.GstCtx, fWhat, true /*fCanUpdateCr3*/);
-    if (RT_SUCCESS(rc))
-    {
-        Assert(rc == VINF_SUCCESS);
-        return VINF_SUCCESS;
-    }
-
-    if (rc == VERR_NEM_FLUSH_TLB)
-    {
-        Log4(("%s/%u: nemR0WinImportState -> %Rrc\n", pszCaller, pGVCpu->idCpu, -rc));
-        return -rc;
-    }
-    RT_NOREF(pszCaller);
-    AssertMsgFailedReturn(("%s/%u: nemR0WinImportState failed: %Rrc\n", pszCaller, pGVCpu->idCpu, rc), rc);
-}
-#endif /* IN_RING0 && NEM_WIN_TEMPLATE_MODE_OWN_RUN_API*/
-
-#if defined(NEM_WIN_TEMPLATE_MODE_OWN_RUN_API) || defined(IN_RING3)
-/**
- * Wrapper around nemR0WinImportStateStrict and nemHCWinCopyStateFromHyperV.
- *
- * Unlike the wrapped APIs, this checks whether it's necessary.
- *
- * @returns VBox strict status code.
- * @param   pGVM            The global (ring-0) VM structure.
- * @param   pGVCpu          The global (ring-0) per CPU structure.
- * @param   fWhat           What to import.
- * @param   pszCaller       Who is doing the importing.
- */
-DECLINLINE(VBOXSTRICTRC) nemHCWinImportStateIfNeededStrict(PVMCPUCC pVCpu, PGVMCPU pGVCpu, uint64_t fWhat, const char *pszCaller)
+DECLINLINE(VBOXSTRICTRC) nemHCWinImportStateIfNeededStrict(PVMCPUCC pVCpu, uint64_t fWhat, const char *pszCaller)
 {
     if (pVCpu->cpum.GstCtx.fExtrn & fWhat)
     {
 # ifdef IN_RING0
-        return nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pVCpu, fWhat, pszCaller);
+        return nemR0WinImportStateStrict(pVCpu->pGVM, pVCpu, fWhat, pszCaller);
 # else
-        RT_NOREF(pGVCpu, pszCaller);
+        RT_NOREF(pszCaller);
         int rc = nemHCWinCopyStateFromHyperV(pVCpu->pVMR3, pVCpu, fWhat);
         AssertRCReturn(rc, rc);
@@ -1947 +1941 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsg            The message.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExitMemory
  */
 NEM_TMPL_STATIC VBOXSTRICTRC
-nemHCWinHandleMessageMemory(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_MEMORY_INTERCEPT_MESSAGE const *pMsg, PGVMCPU pGVCpu)
+nemHCWinHandleMessageMemory(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_MEMORY_INTERCEPT_MESSAGE const *pMsg)
 {
     uint64_t const uHostTsc = ASMReadTSC();
@@ -2030 +2023 @@
     VBOXSTRICTRC rcStrict;
 # ifdef IN_RING0
-    rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pVCpu,
+    rcStrict = nemR0WinImportStateStrict(pVM, pVCpu,
                                          NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_DS | CPUMCTX_EXTRN_ES, "MemExit");
     if (rcStrict != VINF_SUCCESS)
@@ -2037 +2030 @@
     rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_DS | CPUMCTX_EXTRN_ES);
     AssertRCReturn(rc, rc);
-    NOREF(pGVCpu);
 # endif
 
@@ -2172 +2164 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsg            The message.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  */
 NEM_TMPL_STATIC VBOXSTRICTRC
-nemHCWinHandleMessageIoPort(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_IO_PORT_INTERCEPT_MESSAGE const *pMsg, PGVMCPU pGVCpu)
+nemHCWinHandleMessageIoPort(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_IO_PORT_INTERCEPT_MESSAGE const *pMsg)
 {
     /*
@@ -2185 +2176 @@
     Assert(   pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_READ
            || pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE);
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRip, pMsg->Header.Rip);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRax, pMsg->Rax);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRip, pMsg->Header.Rip);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRax, pMsg->Rax);
     if (pMsg->AccessInfo.StringOp)
     {
-        NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterDs,  pMsg->DsSegment);
-        NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterEs,  pMsg->EsSegment);
-        NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRcx, pMsg->Rcx);
-        NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRsi, pMsg->Rsi);
-        NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRdi, pMsg->Rdi);
+        NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterDs,  pMsg->DsSegment);
+        NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterEs,  pMsg->EsSegment);
+        NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRcx, pMsg->Rcx);
+        NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRsi, pMsg->Rsi);
+        NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRdi, pMsg->Rdi);
     }
 
@@ -2308 +2299 @@
             pVCpu->cpum.GstCtx.rsi = pMsg->Rsi;
 # ifdef IN_RING0
-            rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IOExit");
+            rcStrict = nemR0WinImportStateStrict(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IOExit");
             if (rcStrict != VINF_SUCCESS)
                 return rcStrict;
@@ -2314 +2305 @@
             int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
             AssertRCReturn(rc, rc);
-            RT_NOREF(pGVCpu);
 # endif
 
@@ -2359 +2349 @@
 
 # ifdef IN_RING0
-    rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IOExit");
+    rcStrict = nemR0WinImportStateStrict(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "IOExit");
     if (rcStrict != VINF_SUCCESS)
         return rcStrict;
@@ -2365 +2355 @@
     int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
     AssertRCReturn(rc, rc);
-    RT_NOREF(pGVCpu);
 # endif
 
@@ -2554 +2543 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsg            The message.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExitInterruptWindow
  */
 NEM_TMPL_STATIC VBOXSTRICTRC
-nemHCWinHandleMessageInterruptWindow(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_INTERRUPT_WINDOW_MESSAGE const *pMsg, PGVMCPU pGVCpu)
+nemHCWinHandleMessageInterruptWindow(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_INTERRUPT_WINDOW_MESSAGE const *pMsg)
 {
     /*
@@ -2580 +2568 @@
 
     /** @todo call nemHCWinHandleInterruptFF   */
-    RT_NOREF(pVM, pGVCpu);
+    RT_NOREF(pVM);
     return VINF_SUCCESS;
 }
@@ -2629 +2617 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsg            The message.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExitCpuId
  */
-NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageCpuId(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_CPUID_INTERCEPT_MESSAGE const *pMsg,
-                                                        PGVMCPU pGVCpu)
+NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageCpuId(PVMCC pVM, PVMCPUCC pVCpu, HV_X64_CPUID_INTERCEPT_MESSAGE const *pMsg)
 {
     /* Check message register value sanity. */
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRip, pMsg->Header.Rip);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRax, pMsg->Rax);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRcx, pMsg->Rcx);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRdx, pMsg->Rdx);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRbx, pMsg->Rbx);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRip, pMsg->Header.Rip);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRax, pMsg->Rax);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRcx, pMsg->Rcx);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRdx, pMsg->Rdx);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRbx, pMsg->Rbx);
 
     /* Do exit history. */
@@ -2698 +2684 @@
           pMsg->DefaultResultRax, pMsg->DefaultResultRcx, pMsg->DefaultResultRdx, pMsg->DefaultResultRbx));
 # ifdef IN_RING0
-    VBOXSTRICTRC rcStrict = nemR0WinImportStateStrict(pGVCpu->pGVM, pGVCpu, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "CpuIdExit");
+    VBOXSTRICTRC rcStrict = nemR0WinImportStateStrict(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM, "CpuIdExit");
     if (rcStrict != VINF_SUCCESS)
         return rcStrict;
@@ -2705 +2691 @@
     int rc = nemHCWinCopyStateFromHyperV(pVM, pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM);
     AssertRCReturn(rc, rc);
-    RT_NOREF(pGVCpu);
 # endif
     VBOXSTRICTRC rcStrictExec = EMHistoryExec(pVCpu, pExitRec, 0);
@@ -2796 +2781 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsg            The message.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExitMsr
  */
-NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageMsr(PVMCPUCC pVCpu, HV_X64_MSR_INTERCEPT_MESSAGE const *pMsg, PGVMCPU pGVCpu)
+NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleMessageMsr(PVMCPUCC pVCpu, HV_X64_MSR_INTERCEPT_MESSAGE const *pMsg)
 {
     /*
@@ -2806 +2790 @@
     Assert(   pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_READ
            || pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE);
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRip, pMsg->Header.Rip);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRax, pMsg->Rax);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRdx, pMsg->Rdx);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRip, pMsg->Header.Rip);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRax, pMsg->Rax);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRdx, pMsg->Rdx);
 
     /*
@@ -2830 +2814 @@
 
         nemHCWinCopyStateFromX64Header(pVCpu, &pMsg->Header);
-        rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu,
+        rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu,
                                                      (!pExitRec ? 0 : IEM_CPUMCTX_EXTRN_MUST_MASK)
                                                      | CPUMCTX_EXTRN_ALL_MSRS | CPUMCTX_EXTRN_CR0
@@ -2930 +2914 @@
      * If we get down here, we're supposed to #GP(0).
      */
-    rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL_MSRS, "MSR");
+    rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL_MSRS, "MSR");
     if (rcStrict == VINF_SUCCESS)
     {
@@ -2969 +2953 @@
                                                 pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
         nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
-        rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL,
+        rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu,
                                                      (!pExitRec ? 0 : IEM_CPUMCTX_EXTRN_MUST_MASK)
                                                      | CPUMCTX_EXTRN_ALL_MSRS | CPUMCTX_EXTRN_CR0
@@ -3056 +3040 @@
      * If we get down here, we're supposed to #GP(0).
      */
-    rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL,
-                                                 NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL_MSRS, "MSR");
+    rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL_MSRS, "MSR");
     if (rcStrict == VINF_SUCCESS)
     {
@@ -3195 +3178 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsg            The message.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExitMsr
  */
 NEM_TMPL_STATIC VBOXSTRICTRC
-nemHCWinHandleMessageException(PVMCPUCC pVCpu, HV_X64_EXCEPTION_INTERCEPT_MESSAGE const *pMsg, PGVMCPU pGVCpu)
+nemHCWinHandleMessageException(PVMCPUCC pVCpu, HV_X64_EXCEPTION_INTERCEPT_MESSAGE const *pMsg)
 {
     /*
@@ -3207 +3189 @@
            || pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_WRITE
            || pMsg->Header.InterceptAccessType == HV_INTERCEPT_ACCESS_EXECUTE);
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRip, pMsg->Header.Rip);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterDs,  pMsg->DsSegment);
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterSs,  pMsg->SsSegment);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRax, pMsg->Rax);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRcx, pMsg->Rcx);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRdx, pMsg->Rdx);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRbx, pMsg->Rbx);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRsp, pMsg->Rsp);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRbp, pMsg->Rbp);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRsi, pMsg->Rsi);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRdi, pMsg->Rdi);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR8,  pMsg->R8);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR9,  pMsg->R9);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR10, pMsg->R10);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR11, pMsg->R11);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR12, pMsg->R12);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR13, pMsg->R13);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR14, pMsg->R14);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterR15, pMsg->R15);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterCs, pMsg->Header.CsSegment);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRip, pMsg->Header.Rip);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRflags, pMsg->Header.Rflags);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterCr8, (uint64_t)pMsg->Header.Cr8);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterDs,  pMsg->DsSegment);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterSs,  pMsg->SsSegment);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRax, pMsg->Rax);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRcx, pMsg->Rcx);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRdx, pMsg->Rdx);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRbx, pMsg->Rbx);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRsp, pMsg->Rsp);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRbp, pMsg->Rbp);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRsi, pMsg->Rsi);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRdi, pMsg->Rdi);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR8,  pMsg->R8);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR9,  pMsg->R9);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR10, pMsg->R10);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR11, pMsg->R11);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR12, pMsg->R12);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR13, pMsg->R13);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR14, pMsg->R14);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterR15, pMsg->R15);
 
     /*
@@ -3243 +3225 @@
     if (pMsg->ExceptionVector == X86_XCPT_DB)
         fWhat |= CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_DR6;
-    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu, fWhat, "Xcpt");
+    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, fWhat, "Xcpt");
     if (rcStrict != VINF_SUCCESS)
         return rcStrict;
@@ -3341 +3323 @@
     if (pExit->VpException.ExceptionType == X86_XCPT_DB)
         fWhat |= CPUMCTX_EXTRN_DR0_DR3 | CPUMCTX_EXTRN_DR7 | CPUMCTX_EXTRN_DR6;
-    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL, fWhat, "Xcpt");
+    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, fWhat, "Xcpt");
     if (rcStrict != VINF_SUCCESS)
         return rcStrict;
@@ -3431 +3413 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMsgHdr         The message header.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExitUnrecoverableException
  */
 NEM_TMPL_STATIC VBOXSTRICTRC
-nemHCWinHandleMessageUnrecoverableException(PVMCPUCC pVCpu, HV_X64_INTERCEPT_MESSAGE_HEADER const *pMsgHdr, PGVMCPU pGVCpu)
+nemHCWinHandleMessageUnrecoverableException(PVMCPUCC pVCpu, HV_X64_INTERCEPT_MESSAGE_HEADER const *pMsgHdr)
 {
     /* Check message register value sanity. */
-    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, pGVCpu, HvX64RegisterCs, pMsgHdr->CsSegment);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRip, pMsgHdr->Rip);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterRflags, pMsgHdr->Rflags);
-    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, pGVCpu, HvX64RegisterCr8, (uint64_t)pMsgHdr->Cr8);
+    NEMWIN_ASSERT_MSG_REG_SEG(  pVCpu, HvX64RegisterCs, pMsgHdr->CsSegment);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRip, pMsgHdr->Rip);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterRflags, pMsgHdr->Rflags);
+    NEMWIN_ASSERT_MSG_REG_VAL64(pVCpu, HvX64RegisterCr8, (uint64_t)pMsgHdr->Cr8);
 
 # if 0
@@ -3458 +3439 @@
                      pMsgHdr->Rip + pMsgHdr->CsSegment.Base, ASMReadTSC());
     nemHCWinCopyStateFromX64Header(pVCpu, pMsgHdr);
-    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu,
-                                                              NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL, "TripleExit");
+    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL, "TripleExit");
     if (rcStrict == VINF_SUCCESS)
     {
@@ -3511 +3491 @@
                      pExit->VpContext.Rip + pExit->VpContext.Cs.Base, ASMReadTSC());
     nemR3WinCopyStateFromX64Header(pVCpu, &pExit->VpContext);
-    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NULL,
-                                                              NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL, "TripleExit");
+    VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM | CPUMCTX_EXTRN_ALL, "TripleExit");
     if (rcStrict == VINF_SUCCESS)
     {
@@ -3549 +3528 @@
  * @param   pVCpu           The cross context per CPU structure.
  * @param   pMappingHeader  The message slot mapping.
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  * @sa      nemR3WinHandleExit
  */
 NEM_TMPL_STATIC VBOXSTRICTRC
-nemHCWinHandleMessage(PVMCC pVM, PVMCPUCC pVCpu, VID_MESSAGE_MAPPING_HEADER volatile *pMappingHeader, PGVMCPU pGVCpu)
+nemHCWinHandleMessage(PVMCC pVM, PVMCPUCC pVCpu, VID_MESSAGE_MAPPING_HEADER volatile *pMappingHeader)
 {
     if (pMappingHeader->enmVidMsgType == VidMessageHypervisorMessage)
@@ -3564 +3542 @@
                 Assert(pMsg->Header.PayloadSize == RT_UOFFSETOF(HV_X64_MEMORY_INTERCEPT_MESSAGE, DsSegment));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMemUnmapped);
-                return nemHCWinHandleMessageMemory(pVM, pVCpu, &pMsg->X64MemoryIntercept, pGVCpu);
+                return nemHCWinHandleMessageMemory(pVM, pVCpu, &pMsg->X64MemoryIntercept);
 
             case HvMessageTypeGpaIntercept:
                 Assert(pMsg->Header.PayloadSize == RT_UOFFSETOF(HV_X64_MEMORY_INTERCEPT_MESSAGE, DsSegment));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMemIntercept);
-                return nemHCWinHandleMessageMemory(pVM, pVCpu, &pMsg->X64MemoryIntercept, pGVCpu);
+                return nemHCWinHandleMessageMemory(pVM, pVCpu, &pMsg->X64MemoryIntercept);
 
             case HvMessageTypeX64IoPortIntercept:
                 Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64IoPortIntercept));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitPortIo);
-                return nemHCWinHandleMessageIoPort(pVM, pVCpu, &pMsg->X64IoPortIntercept, pGVCpu);
+                return nemHCWinHandleMessageIoPort(pVM, pVCpu, &pMsg->X64IoPortIntercept);
 
             case HvMessageTypeX64Halt:
@@ -3586 +3564 @@
                 Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64InterruptWindow));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitInterruptWindow);
-                return nemHCWinHandleMessageInterruptWindow(pVM, pVCpu, &pMsg->X64InterruptWindow, pGVCpu);
+                return nemHCWinHandleMessageInterruptWindow(pVM, pVCpu, &pMsg->X64InterruptWindow);
 
             case HvMessageTypeX64CpuidIntercept:
                 Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64CpuIdIntercept));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitCpuId);
-                return nemHCWinHandleMessageCpuId(pVM, pVCpu, &pMsg->X64CpuIdIntercept, pGVCpu);
+                return nemHCWinHandleMessageCpuId(pVM, pVCpu, &pMsg->X64CpuIdIntercept);
 
             case HvMessageTypeX64MsrIntercept:
                 Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64MsrIntercept));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitMsr);
-                return nemHCWinHandleMessageMsr(pVCpu, &pMsg->X64MsrIntercept, pGVCpu);
+                return nemHCWinHandleMessageMsr(pVCpu, &pMsg->X64MsrIntercept);
 
             case HvMessageTypeX64ExceptionIntercept:
                 Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64ExceptionIntercept));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitException);
-                return nemHCWinHandleMessageException(pVCpu, &pMsg->X64ExceptionIntercept, pGVCpu);
+                return nemHCWinHandleMessageException(pVCpu, &pMsg->X64ExceptionIntercept);
 
             case HvMessageTypeUnrecoverableException:
                 Assert(pMsg->Header.PayloadSize == sizeof(pMsg->X64InterceptHeader));
                 STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatExitUnrecoverable);
-                return nemHCWinHandleMessageUnrecoverableException(pVCpu, &pMsg->X64InterceptHeader, pGVCpu);
+                return nemHCWinHandleMessageUnrecoverableException(pVCpu, &pMsg->X64InterceptHeader);
 
             case HvMessageTypeInvalidVpRegisterValue:
@@ -3712 +3690 @@
  * @returns NT status code.
  * @param   pGVM            The ring-0 VM structure.
- * @param   pGVCpu          The ring-0 CPU structure.
- * @param   pVCpu           The calling cross context CPU structure.
+ * @param   pGVCpu          The global (ring-0) per CPU structure.
  * @param   fFlags          The wait flags.
  * @param   cMillies        The timeout in milliseconds
  */
-static NTSTATUS nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(PGVM pGVM, PGVMCPU pGVCpu, PVMCPUCC pVCpu,
-                                                               uint32_t fFlags, uint32_t cMillies)
-{
-    pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu     = pGVCpu->idCpu;
-    pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags   = fFlags;
-    pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = cMillies;
-    NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pVCpu, pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
-                                            &pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
+static NTSTATUS nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(PGVM pGVM, PGVMCPU pGVCpu, uint32_t fFlags, uint32_t cMillies)
+{
+    pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu     = pGVCpu->idCpu;
+    pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags   = fFlags;
+    pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = cMillies;
+    NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pGVCpu, pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
+                                            &pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
                                             pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.cbInput,
                                             NULL, 0);
@@ -3740 +3716 @@
              || rcNt == STATUS_USER_APC   /* just in case */)
     {
-        DBGFTRACE_CUSTOM(pVCpu->CTX_SUFF(pVM), "IoCtlMessageSlotHandleAndGetNextRestart/1 %#x (f=%#x)", rcNt, fFlags);
-        STAM_REL_COUNTER_INC(&pVCpu->nem.s.StatStopCpuPendingAlerts);
+        DBGFTRACE_CUSTOM(pGVCpu->CTX_SUFF(pVM), "IoCtlMessageSlotHandleAndGetNextRestart/1 %#x (f=%#x)", rcNt, fFlags);
+        STAM_REL_COUNTER_INC(&pGVCpu->nem.s.StatStopCpuPendingAlerts);
         Assert(fFlags & VID_MSHAGN_F_GET_NEXT_MESSAGE);
 
-        pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu     = pVCpu->idCpu;
-        pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags   = fFlags & ~VID_MSHAGN_F_HANDLE_MESSAGE;
-        pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = cMillies;
-        rcNt = nemR0NtPerformIoControl(pGVM, pVCpu, pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
-                                       &pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
+        pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu     = pGVCpu->idCpu;
+        pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags   = fFlags & ~VID_MSHAGN_F_HANDLE_MESSAGE;
+        pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = cMillies;
+        rcNt = nemR0NtPerformIoControl(pGVM, pGVCpu, pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
+                                       &pGVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
                                        pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.cbInput,
                                        NULL, 0);
-        DBGFTRACE_CUSTOM(pVCpu->CTX_SUFF(pVM), "IoCtlMessageSlotHandleAndGetNextRestart/2 %#x", rcNt);
+        DBGFTRACE_CUSTOM(pGVM, "IoCtlMessageSlotHandleAndGetNextRestart/2 %#x", rcNt);
     }
     return rcNt;
 }
-
 #endif /* IN_RING0 */
 
@@ -3774 +3749 @@
  *                          exit.
  * @param   pMappingHeader  The message slot mapping.
- * @param   pGVM            The global (ring-0) VM structure (NULL in r3).
- * @param   pGVCpu          The global (ring-0) per CPU structure (NULL in r3).
  */
 NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinStopCpu(PVMCC pVM, PVMCPUCC pVCpu, VBOXSTRICTRC rcStrict,
-                                             VID_MESSAGE_MAPPING_HEADER volatile *pMappingHeader,
-                                             PGVM pGVM, PGVMCPU pGVCpu)
+                                             VID_MESSAGE_MAPPING_HEADER volatile *pMappingHeader)
 {
 # ifdef DBGFTRACE_ENABLED
@@ -3791 +3763 @@
     DBGFTRACE_CUSTOM(pVM, "nemStop#0");
 # ifdef IN_RING0
-    pVCpu->nem.s.uIoCtlBuf.idCpu = pGVCpu->idCpu;
-    NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pVCpu, pGVM->nemr0.s.IoCtlStopVirtualProcessor.uFunction,
+    pVCpu->nem.s.uIoCtlBuf.idCpu = pVCpu->idCpu;
+    NTSTATUS rcNt = nemR0NtPerformIoControl(pVM, pVCpu, pVM->nemr0.s.IoCtlStopVirtualProcessor.uFunction,
                                             &pVCpu->nem.s.uIoCtlBuf.idCpu, sizeof(pVCpu->nem.s.uIoCtlBuf.idCpu),
                                             NULL, 0);
@@ -3811 +3783 @@
         return rcStrict;
     }
-    RT_NOREF(pGVM, pGVCpu);
 # endif
 
@@ -3835 +3806 @@
      */
 # ifdef IN_RING0
-    rcNt = nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(pGVM, pGVCpu, pVCpu, VID_MSHAGN_F_GET_NEXT_MESSAGE, 30000 /*ms*/);
+    rcNt = nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(pVM, pVCpu, VID_MSHAGN_F_GET_NEXT_MESSAGE, 30000 /*ms*/);
     DBGFTRACE_CUSTOM(pVM, "nemStop#1: %#x / %#x %#x %#x", rcNt, pMappingHeader->enmVidMsgType, pMappingHeader->cbMessage,
                      pMsgForTrace->Header.MessageType);
@@ -3853 +3824 @@
     if (enmVidMsgType != VidMessageStopRequestComplete)
     {
-        VBOXSTRICTRC rcStrict2 = nemHCWinHandleMessage(pVM, pVCpu, pMappingHeader, pGVCpu);
+        VBOXSTRICTRC rcStrict2 = nemHCWinHandleMessage(pVM, pVCpu, pMappingHeader);
         if (rcStrict2 != VINF_SUCCESS && RT_SUCCESS(rcStrict))
             rcStrict = rcStrict2;
@@ -3863 +3834 @@
          */
 # ifdef IN_RING0
-        rcNt = nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(pGVM, pGVCpu, pVCpu,
+        rcNt = nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(pVM, pVCpu,
                                                               VID_MSHAGN_F_HANDLE_MESSAGE | VID_MSHAGN_F_GET_NEXT_MESSAGE,
                                                               30000 /*ms*/);
@@ -3891 +3862 @@
          */
 # ifdef IN_RING0
-        rcNt = nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(pGVM, pGVCpu, pVCpu, VID_MSHAGN_F_HANDLE_MESSAGE, 30000 /*ms*/);
+        rcNt = nemR0NtPerformIoCtlMessageSlotHandleAndGetNext(pVM, pVCpu, VID_MSHAGN_F_HANDLE_MESSAGE, 30000 /*ms*/);
         DBGFTRACE_CUSTOM(pVM, "nemStop#3: %#x / %#x %#x %#x", rcNt, pMappingHeader->enmVidMsgType,
                          pMsgForTrace->Header.MessageType, pMappingHeader->cbMessage, pMsgForTrace->Header.MessageType);
@@ -3927 +3898 @@
  * @param   pVM                 The cross context VM structure.
  * @param   pVCpu               The cross context per CPU structure.
- * @param   pGVCpu              The global (ring-0) per CPU structure.
  * @param   pfInterruptWindows  Where to return interrupt window flags.
  */
-NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleInterruptFF(PVMCC pVM, PVMCPUCC pVCpu, PGVMCPU pGVCpu, uint8_t *pfInterruptWindows)
+NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinHandleInterruptFF(PVMCC pVM, PVMCPUCC pVCpu, uint8_t *pfInterruptWindows)
 {
     Assert(!TRPMHasTrap(pVCpu));
@@ -3961 +3931 @@
     if (pVCpu->cpum.GstCtx.fExtrn & fNeedExtrn)
     {
-        VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu,
-                                                                  NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "IntFF");
+        VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "IntFF");
         if (rcStrict != VINF_SUCCESS)
             return rcStrict;
@@ -3977 +3946 @@
             && !VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
         {
-            VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu,
-                                                                      NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "NMI");
+            VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "NMI");
             if (rcStrict == VINF_SUCCESS)
             {
@@ -4000 +3968 @@
         {
             AssertCompile(NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT & CPUMCTX_EXTRN_APIC_TPR);
-            VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, pGVCpu,
-                                                                      NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "NMI");
+            VBOXSTRICTRC rcStrict = nemHCWinImportStateIfNeededStrict(pVCpu, NEM_WIN_CPUMCTX_EXTRN_MASK_FOR_IEM_XCPT, "NMI");
             if (rcStrict == VINF_SUCCESS)
             {
@@ -4035 +4002 @@
  * @param   pVM             The cross context VM structure.
  * @param   pVCpu           The cross context per CPU structure.
- * @param   pGVM            The ring-0 VM structure (NULL in ring-3).
- * @param   pGVCpu          The ring-0 per CPU structure (NULL in ring-3).
  */
-NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinRunGC(PVMCC pVM, PVMCPUCC pVCpu, PGVM pGVM, PGVMCPU pGVCpu)
+NEM_TMPL_STATIC VBOXSTRICTRC nemHCWinRunGC(PVMCC pVM, PVMCPUCC pVCpu)
 {
     LogFlow(("NEM/%u: %04x:%08RX64 efl=%#08RX64 <=\n", pVCpu->idCpu, pVCpu->cpum.GstCtx.cs.Sel, pVCpu->cpum.GstCtx.rip, pVCpu->cpum.GstCtx.rflags));
@@ -4044 +4009 @@
     if (LogIs3Enabled())
         nemHCWinLogState(pVM, pVCpu);
-# endif
-# ifdef IN_RING0
-    Assert(pVCpu->idCpu == pGVCpu->idCpu);
 # endif
 
@@ -4102 +4064 @@
             {
                 pVCpu->nem.s.fHandleAndGetFlags = 0;
-                rcStrict = nemHCWinStopCpu(pVM, pVCpu, rcStrict, pMappingHeader, pGVM, pGVCpu);
+                rcStrict = nemHCWinStopCpu(pVM, pVCpu, rcStrict, pMappingHeader);
                 if (rcStrict == VINF_SUCCESS)
                 { /* likely */ }
@@ -4115 +4077 @@
 
             /* Try inject interrupt. */
-            rcStrict = nemHCWinHandleInterruptFF(pVM, pVCpu, pGVCpu, &pVCpu->nem.s.fDesiredInterruptWindows);
+            rcStrict = nemHCWinHandleInterruptFF(pVM, pVCpu, &pVCpu->nem.s.fDesiredInterruptWindows);
             if (rcStrict == VINF_SUCCESS)
             { /* likely */ }
@@ -4148 +4110 @@
 # endif
 # ifdef IN_RING0
-            int rc2 = nemR0WinExportState(pGVM, pGVCpu, &pVCpu->cpum.GstCtx);
+            int rc2 = nemR0WinExportState(pVM, pVCpu, &pVCpu->cpum.GstCtx);
 # else
             int rc2 = nemHCWinCopyStateToHyperV(pVM, pVCpu);
-            RT_NOREF(pGVM, pGVCpu);
 # endif
             AssertRCReturn(rc2, rc2);
@@ -4176 +4137 @@
             {
 #  ifdef IN_RING0
-                pVCpu->nem.s.uIoCtlBuf.idCpu = pGVCpu->idCpu;
-                NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pVCpu, pGVM->nemr0.s.IoCtlStartVirtualProcessor.uFunction,
+                pVCpu->nem.s.uIoCtlBuf.idCpu = pVCpu->idCpu;
+                NTSTATUS rcNt = nemR0NtPerformIoControl(pVM, pVCpu, pVM->nemr0.s.IoCtlStartVirtualProcessor.uFunction,
                                                         &pVCpu->nem.s.uIoCtlBuf.idCpu, sizeof(pVCpu->nem.s.uIoCtlBuf.idCpu),
                                                         NULL, 0);
                 LogFlow(("NEM/%u: IoCtlStartVirtualProcessor -> %#x\n", pVCpu->idCpu, rcNt));
-                AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("VidStartVirtualProcessor failed for CPU #%u: %#x\n", pGVCpu->idCpu, rcNt),
+                AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("VidStartVirtualProcessor failed for CPU #%u: %#x\n", pVCpu->idCpu, rcNt),
                                       VERR_NEM_IPE_5);
 #  else
@@ -4211 +4172 @@
                     cMsWait = RT_MS_1SEC;
 #  ifdef IN_RING0
-                pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu     = pGVCpu->idCpu;
+                pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.iCpu     = pVCpu->idCpu;
                 pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.fFlags   = pVCpu->nem.s.fHandleAndGetFlags;
                 pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext.cMillies = cMsWait;
-                NTSTATUS rcNt = nemR0NtPerformIoControl(pGVM, pVCpu, pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
+                NTSTATUS rcNt = nemR0NtPerformIoControl(pVM, pVCpu, pVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.uFunction,
                                                         &pVCpu->nem.s.uIoCtlBuf.MsgSlotHandleAndGetNext,
-                                                        pGVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.cbInput,
+                                                        pVM->nemr0.s.IoCtlMessageSlotHandleAndGetNext.cbInput,
                                                         NULL, 0);
                 VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_EXEC_NEM, VMCPUSTATE_STARTED_EXEC_NEM_WAIT);
@@ -4238 +4199 @@
                      */
 # ifdef NEM_WIN_TEMPLATE_MODE_OWN_RUN_API
-                    rcStrict = nemHCWinHandleMessage(pVM, pVCpu, pMappingHeader, pGVCpu);
+                    rcStrict = nemHCWinHandleMessage(pVM, pVCpu, pMappingHeader);
                     pVCpu->nem.s.fHandleAndGetFlags |= VID_MSHAGN_F_HANDLE_MESSAGE;
 # else
@@ -4315 +4276 @@
     {
         pVCpu->nem.s.fHandleAndGetFlags = 0;
-        rcStrict = nemHCWinStopCpu(pVM, pVCpu, rcStrict, pMappingHeader, pGVM, pGVCpu);
+        rcStrict = nemHCWinStopCpu(pVM, pVCpu, rcStrict, pMappingHeader);
     }
 # endif
@@ -4343 +4304 @@
         {
 # ifdef IN_RING0
-            int rc2 = nemR0WinImportState(pGVM, pGVCpu, &pVCpu->cpum.GstCtx, fImport | CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT,
+            int rc2 = nemR0WinImportState(pVM, pVCpu, &pVCpu->cpum.GstCtx, fImport | CPUMCTX_EXTRN_NEM_WIN_EVENT_INJECT,
                                           true /*fCanUpdateCr3*/);
             if (RT_SUCCESS(rc2))

trunk/src/VBox/VMM/VMMR0/GMMR0.cpp

@@ -1541 +1541 @@
  *
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The VCPU id - must be zero.
  * @param   cBasePages      The number of pages that may be allocated for the base RAM and ROMs.
@@ -1553 +1552 @@
  * @thread  The creator thread / EMT(0).
  */
-GMMR0DECL(int) GMMR0InitialReservation(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint64_t cBasePages, uint32_t cShadowPages,
+GMMR0DECL(int) GMMR0InitialReservation(PGVM pGVM, VMCPUID idCpu, uint64_t cBasePages, uint32_t cShadowPages,
                                        uint32_t cFixedPages, GMMOCPOLICY enmPolicy, GMMPRIORITY enmPriority)
 {
-    LogFlow(("GMMR0InitialReservation: pGVM=%p pVM=%p cBasePages=%#llx cShadowPages=%#x cFixedPages=%#x enmPolicy=%d enmPriority=%d\n",
-             pGVM, pVM, cBasePages, cShadowPages, cFixedPages, enmPolicy, enmPriority));
+    LogFlow(("GMMR0InitialReservation: pGVM=%p cBasePages=%#llx cShadowPages=%#x cFixedPages=%#x enmPolicy=%d enmPriority=%d\n",
+             pGVM, cBasePages, cShadowPages, cFixedPages, enmPolicy, enmPriority));
 
     /*
@@ -1565 +1564 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -1619 +1618 @@
  * @returns see GMMR0InitialReservation.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The VCPU id.
  * @param   pReq            Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0InitialReservationReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMINITIALRESERVATIONREQ pReq)
+GMMR0DECL(int) GMMR0InitialReservationReq(PGVM pGVM, VMCPUID idCpu, PGMMINITIALRESERVATIONREQ pReq)
 {
     /*
      * Validate input and pass it on.
      */
-    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
+    AssertPtrReturn(pGVM, VERR_INVALID_POINTER);
     AssertPtrReturn(pReq, VERR_INVALID_POINTER);
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GMMR0InitialReservation(pGVM, pVM, idCpu, pReq->cBasePages, pReq->cShadowPages,
+    return GMMR0InitialReservation(pGVM, idCpu, pReq->cBasePages, pReq->cShadowPages,
                                    pReq->cFixedPages, pReq->enmPolicy, pReq->enmPriority);
 }
@@ -1644 +1642 @@
  *
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The VCPU id.
  * @param   cBasePages      The number of pages that may be allocated for the base RAM and ROMs.
@@ -1654 +1651 @@
  * @thread  EMT(idCpu)
  */
-GMMR0DECL(int) GMMR0UpdateReservation(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint64_t cBasePages,
+GMMR0DECL(int) GMMR0UpdateReservation(PGVM pGVM, VMCPUID idCpu, uint64_t cBasePages,
                                       uint32_t cShadowPages, uint32_t cFixedPages)
 {
-    LogFlow(("GMMR0UpdateReservation: pGVM=%p pVM=%p cBasePages=%#llx cShadowPages=%#x cFixedPages=%#x\n",
-             pGVM, pVM, cBasePages, cShadowPages, cFixedPages));
+    LogFlow(("GMMR0UpdateReservation: pGVM=%p cBasePages=%#llx cShadowPages=%#x cFixedPages=%#x\n",
+             pGVM, cBasePages, cShadowPages, cFixedPages));
 
     /*
@@ -1665 +1662 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -1716 +1713 @@
  * @returns see GMMR0UpdateReservation.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The VCPU id.
  * @param   pReq            Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0UpdateReservationReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMUPDATERESERVATIONREQ pReq)
+GMMR0DECL(int) GMMR0UpdateReservationReq(PGVM pGVM, VMCPUID idCpu, PGMMUPDATERESERVATIONREQ pReq)
 {
     /*
      * Validate input and pass it on.
      */
-    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
     AssertPtrReturn(pReq, VERR_INVALID_POINTER);
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GMMR0UpdateReservation(pGVM, pVM, idCpu, pReq->cBasePages, pReq->cShadowPages, pReq->cFixedPages);
+    return GMMR0UpdateReservation(pGVM, idCpu, pReq->cBasePages, pReq->cShadowPages, pReq->cFixedPages);
 }
 
@@ -2729 +2724 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The VCPU id.
  * @param   cPagesToUpdate      The number of pages to update (starting from the head).
@@ -2737 +2731 @@
  * @thread  EMT(idCpu)
  */
-GMMR0DECL(int) GMMR0AllocateHandyPages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint32_t cPagesToUpdate,
+GMMR0DECL(int) GMMR0AllocateHandyPages(PGVM pGVM, VMCPUID idCpu, uint32_t cPagesToUpdate,
                                        uint32_t cPagesToAlloc, PGMMPAGEDESC paPages)
 {
-    LogFlow(("GMMR0AllocateHandyPages: pGVM=%p pVM=%p cPagesToUpdate=%#x cPagesToAlloc=%#x paPages=%p\n",
-             pGVM, pVM, cPagesToUpdate, cPagesToAlloc, paPages));
+    LogFlow(("GMMR0AllocateHandyPages: pGVM=%p cPagesToUpdate=%#x cPagesToAlloc=%#x paPages=%p\n",
+             pGVM, cPagesToUpdate, cPagesToAlloc, paPages));
 
     /*
@@ -2749 +2743 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -2925 +2919 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   cPages      The number of pages to allocate.
@@ -2935 +2928 @@
  * @thread  EMT.
  */
-GMMR0DECL(int) GMMR0AllocatePages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint32_t cPages, PGMMPAGEDESC paPages, GMMACCOUNT enmAccount)
-{
-    LogFlow(("GMMR0AllocatePages: pGVM=%p pVM=%p cPages=%#x paPages=%p enmAccount=%d\n", pGVM, pVM, cPages, paPages, enmAccount));
+GMMR0DECL(int) GMMR0AllocatePages(PGVM pGVM, VMCPUID idCpu, uint32_t cPages, PGMMPAGEDESC paPages, GMMACCOUNT enmAccount)
+{
+    LogFlow(("GMMR0AllocatePages: pGVM=%p cPages=%#x paPages=%p enmAccount=%d\n", pGVM, cPages, paPages, enmAccount));
 
     /*
@@ -2944 +2937 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -2991 +2984 @@
  * @returns see GMMR0AllocatePages.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0AllocatePagesReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMALLOCATEPAGESREQ pReq)
+GMMR0DECL(int) GMMR0AllocatePagesReq(PGVM pGVM, VMCPUID idCpu, PGMMALLOCATEPAGESREQ pReq)
 {
     /*
@@ -3008 +3000 @@
                     VERR_INVALID_PARAMETER);
 
-    return GMMR0AllocatePages(pGVM, pVM, idCpu, pReq->cPages, &pReq->aPages[0], pReq->enmAccount);
+    return GMMR0AllocatePages(pGVM, idCpu, pReq->cPages, &pReq->aPages[0], pReq->enmAccount);
 }
 
@@ -3027 +3019 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   cbPage      Large page size.
@@ -3033 +3024 @@
  * @param   pHCPhys     Where to return the host physical address of the page.
  */
-GMMR0DECL(int)  GMMR0AllocateLargePage(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint32_t cbPage, uint32_t *pIdPage, RTHCPHYS *pHCPhys)
-{
-    LogFlow(("GMMR0AllocateLargePage: pGVM=%p pVM=%p cbPage=%x\n", pGVM, pVM, cbPage));
+GMMR0DECL(int)  GMMR0AllocateLargePage(PGVM pGVM, VMCPUID idCpu, uint32_t cbPage, uint32_t *pIdPage, RTHCPHYS *pHCPhys)
+{
+    LogFlow(("GMMR0AllocateLargePage: pGVM=%p cbPage=%x\n", pGVM, cbPage));
 
     AssertReturn(cbPage == GMM_CHUNK_SIZE, VERR_INVALID_PARAMETER);
@@ -3046 +3037 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -3134 +3125 @@
  * @returns VBox status code:
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   idPage      The large page id.
  */
-GMMR0DECL(int)  GMMR0FreeLargePage(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint32_t idPage)
-{
-    LogFlow(("GMMR0FreeLargePage: pGVM=%p pVM=%p idPage=%x\n", pGVM, pVM, idPage));
+GMMR0DECL(int)  GMMR0FreeLargePage(PGVM pGVM, VMCPUID idCpu, uint32_t idPage)
+{
+    LogFlow(("GMMR0FreeLargePage: pGVM=%p idPage=%x\n", pGVM, idPage));
 
     /*
@@ -3147 +3137 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -3201 +3191 @@
  * @returns see GMMR0FreeLargePage.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0FreeLargePageReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMFREELARGEPAGEREQ pReq)
+GMMR0DECL(int) GMMR0FreeLargePageReq(PGVM pGVM, VMCPUID idCpu, PGMMFREELARGEPAGEREQ pReq)
 {
     /*
@@ -3215 +3204 @@
                     VERR_INVALID_PARAMETER);
 
-    return GMMR0FreeLargePage(pGVM, pVM, idCpu, pReq->idPage);
+    return GMMR0FreeLargePage(pGVM, idCpu, pReq->idPage);
 }
 
@@ -3562 +3551 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   cPages      The number of pages to allocate.
@@ -3570 +3558 @@
  * @thread  EMT.
  */
-GMMR0DECL(int) GMMR0FreePages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint32_t cPages, PGMMFREEPAGEDESC paPages, GMMACCOUNT enmAccount)
-{
-    LogFlow(("GMMR0FreePages: pGVM=%p pVM=%p cPages=%#x paPages=%p enmAccount=%d\n", pGVM, pVM, cPages, paPages, enmAccount));
+GMMR0DECL(int) GMMR0FreePages(PGVM pGVM, VMCPUID idCpu, uint32_t cPages, PGMMFREEPAGEDESC paPages, GMMACCOUNT enmAccount)
+{
+    LogFlow(("GMMR0FreePages: pGVM=%p cPages=%#x paPages=%p enmAccount=%d\n", pGVM, cPages, paPages, enmAccount));
 
     /*
@@ -3579 +3567 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -3614 +3602 @@
  * @returns see GMMR0FreePages.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0FreePagesReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMFREEPAGESREQ pReq)
+GMMR0DECL(int) GMMR0FreePagesReq(PGVM pGVM, VMCPUID idCpu, PGMMFREEPAGESREQ pReq)
 {
     /*
@@ -3631 +3618 @@
                     VERR_INVALID_PARAMETER);
 
-    return GMMR0FreePages(pGVM, pVM, idCpu, pReq->cPages, &pReq->aPages[0], pReq->enmAccount);
+    return GMMR0FreePages(pGVM, idCpu, pReq->cPages, &pReq->aPages[0], pReq->enmAccount);
 }
 
@@ -3652 +3639 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The VCPU id.
  * @param   enmAction           Inflate/deflate/reset.
@@ -3659 +3645 @@
  * @thread  EMT(idCpu)
  */
-GMMR0DECL(int) GMMR0BalloonedPages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, GMMBALLOONACTION enmAction, uint32_t cBalloonedPages)
-{
-    LogFlow(("GMMR0BalloonedPages: pGVM=%p pVM=%p enmAction=%d cBalloonedPages=%#x\n",
-             pGVM, pVM, enmAction, cBalloonedPages));
+GMMR0DECL(int) GMMR0BalloonedPages(PGVM pGVM, VMCPUID idCpu, GMMBALLOONACTION enmAction, uint32_t cBalloonedPages)
+{
+    LogFlow(("GMMR0BalloonedPages: pGVM=%p enmAction=%d cBalloonedPages=%#x\n",
+             pGVM, enmAction, cBalloonedPages));
 
     AssertMsgReturn(cBalloonedPages < RT_BIT(32 - PAGE_SHIFT), ("%#x\n", cBalloonedPages), VERR_INVALID_PARAMETER);
@@ -3671 +3657 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -3784 +3770 @@
  * @returns see GMMR0BalloonedPages.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0BalloonedPagesReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMBALLOONEDPAGESREQ pReq)
+GMMR0DECL(int) GMMR0BalloonedPagesReq(PGVM pGVM, VMCPUID idCpu, PGMMBALLOONEDPAGESREQ pReq)
 {
     /*
@@ -3798 +3783 @@
                     VERR_INVALID_PARAMETER);
 
-    return GMMR0BalloonedPages(pGVM, pVM, idCpu, pReq->enmAction, pReq->cBalloonedPages);
+    return GMMR0BalloonedPages(pGVM, idCpu, pReq->enmAction, pReq->cBalloonedPages);
 }
 
@@ -3839 +3824 @@
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       Cpu id.
  * @param   pReq        Pointer to the request packet.
@@ -3845 +3829 @@
  * @thread  EMT(idCpu)
  */
-GMMR0DECL(int) GMMR0QueryMemoryStatsReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMMEMSTATSREQ pReq)
+GMMR0DECL(int) GMMR0QueryMemoryStatsReq(PGVM pGVM, VMCPUID idCpu, PGMMMEMSTATSREQ pReq)
 {
     /*
@@ -3860 +3844 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -4131 +4115 @@
  * @returns VBox status code.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idChunkMap      The chunk to map. NIL_GMM_CHUNKID if nothing to map.
  * @param   idChunkUnmap    The chunk to unmap. NIL_GMM_CHUNKID if nothing to unmap.
@@ -4137 +4120 @@
  * @thread  EMT ???
  */
-GMMR0DECL(int) GMMR0MapUnmapChunk(PGVM pGVM, PVMCC pVM, uint32_t idChunkMap, uint32_t idChunkUnmap, PRTR3PTR ppvR3)
-{
-    LogFlow(("GMMR0MapUnmapChunk: pGVM=%p pVM=%p idChunkMap=%#x idChunkUnmap=%#x ppvR3=%p\n",
-             pGVM, pVM, idChunkMap, idChunkUnmap, ppvR3));
+GMMR0DECL(int) GMMR0MapUnmapChunk(PGVM pGVM, uint32_t idChunkMap, uint32_t idChunkUnmap, PRTR3PTR ppvR3)
+{
+    LogFlow(("GMMR0MapUnmapChunk: pGVM=%p idChunkMap=%#x idChunkUnmap=%#x ppvR3=%p\n",
+             pGVM, idChunkMap, idChunkUnmap, ppvR3));
 
     /*
@@ -4147 +4130 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+    int rc = GVMMR0ValidateGVM(pGVM);
     if (RT_FAILURE(rc))
         return rc;
@@ -4223 +4206 @@
  * @returns see GMMR0MapUnmapChunk.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int)  GMMR0MapUnmapChunkReq(PGVM pGVM, PVMCC pVM, PGMMMAPUNMAPCHUNKREQ pReq)
+GMMR0DECL(int)  GMMR0MapUnmapChunkReq(PGVM pGVM, PGMMMAPUNMAPCHUNKREQ pReq)
 {
     /*
@@ -4234 +4216 @@
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GMMR0MapUnmapChunk(pGVM, pVM, pReq->idChunkMap, pReq->idChunkUnmap, &pReq->pvR3);
+    return GMMR0MapUnmapChunk(pGVM, pReq->idChunkMap, pReq->idChunkUnmap, &pReq->pvR3);
 }
 
@@ -4246 +4228 @@
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pvR3        Pointer to the chunk size memory block to lock down.
  */
-GMMR0DECL(int) GMMR0SeedChunk(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, RTR3PTR pvR3)
+GMMR0DECL(int) GMMR0SeedChunk(PGVM pGVM, VMCPUID idCpu, RTR3PTR pvR3)
 {
     /*
@@ -4257 +4238 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -4530 +4511 @@
  * @returns VBox status code.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The VCPU id.
  * @param   enmGuestOS      The guest OS type.
@@ -4541 +4521 @@
  * @thread  EMT(idCpu)
  */
-GMMR0DECL(int) GMMR0RegisterSharedModule(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, VBOXOSFAMILY enmGuestOS, char *pszModuleName,
+GMMR0DECL(int) GMMR0RegisterSharedModule(PGVM pGVM, VMCPUID idCpu, VBOXOSFAMILY enmGuestOS, char *pszModuleName,
                                          char *pszVersion, RTGCPTR GCPtrModBase, uint32_t cbModule,
                                          uint32_t cRegions, struct VMMDEVSHAREDREGIONDESC const *paRegions)
@@ -4554 +4534 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -4666 +4646 @@
 #else
 
-    NOREF(pGVM); NOREF(pVM); NOREF(idCpu); NOREF(enmGuestOS); NOREF(pszModuleName); NOREF(pszVersion);
+    NOREF(pGVM); NOREF(idCpu); NOREF(enmGuestOS); NOREF(pszModuleName); NOREF(pszVersion);
     NOREF(GCPtrModBase); NOREF(cbModule); NOREF(cRegions); NOREF(paRegions);
     return VERR_NOT_IMPLEMENTED;
@@ -4678 +4658 @@
  * @returns see GMMR0RegisterSharedModule.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0RegisterSharedModuleReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMREGISTERSHAREDMODULEREQ pReq)
+GMMR0DECL(int) GMMR0RegisterSharedModuleReq(PGVM pGVM, VMCPUID idCpu, PGMMREGISTERSHAREDMODULEREQ pReq)
 {
     /*
@@ -4693 +4672 @@
 
     /* Pass back return code in the request packet to preserve informational codes. (VMMR3CallR0 chokes on them) */
-    pReq->rc = GMMR0RegisterSharedModule(pGVM, pVM, idCpu, pReq->enmGuestOS, pReq->szName, pReq->szVersion,
+    pReq->rc = GMMR0RegisterSharedModule(pGVM, idCpu, pReq->enmGuestOS, pReq->szName, pReq->szVersion,
                                          pReq->GCBaseAddr, pReq->cbModule, pReq->cRegions, pReq->aRegions);
     return VINF_SUCCESS;
@@ -4704 +4683 @@
  * @returns VBox status code.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The VCPU id.
  * @param   pszModuleName   The module name.
@@ -4711 +4689 @@
  * @param   cbModule        The module size.
  */
-GMMR0DECL(int) GMMR0UnregisterSharedModule(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, char *pszModuleName, char *pszVersion,
+GMMR0DECL(int) GMMR0UnregisterSharedModule(PGVM pGVM, VMCPUID idCpu, char *pszModuleName, char *pszVersion,
                                            RTGCPTR GCPtrModBase, uint32_t cbModule)
 {
@@ -4720 +4698 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -4763 +4741 @@
 #else
 
-    NOREF(pGVM); NOREF(pVM); NOREF(idCpu); NOREF(pszModuleName); NOREF(pszVersion); NOREF(GCPtrModBase); NOREF(cbModule);
+    NOREF(pGVM); NOREF(idCpu); NOREF(pszModuleName); NOREF(pszVersion); NOREF(GCPtrModBase); NOREF(cbModule);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -4774 +4752 @@
  * @returns see GMMR0UnregisterSharedModule.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int)  GMMR0UnregisterSharedModuleReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGMMUNREGISTERSHAREDMODULEREQ pReq)
+GMMR0DECL(int)  GMMR0UnregisterSharedModuleReq(PGVM pGVM, VMCPUID idCpu, PGMMUNREGISTERSHAREDMODULEREQ pReq)
 {
     /*
@@ -4786 +4763 @@
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GMMR0UnregisterSharedModule(pGVM, pVM, idCpu, pReq->szName, pReq->szVersion, pReq->GCBaseAddr, pReq->cbModule);
+    return GMMR0UnregisterSharedModule(pGVM, idCpu, pReq->szName, pReq->szVersion, pReq->GCBaseAddr, pReq->cbModule);
 }
 
@@ -5081 +5058 @@
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The VCPU id.
  */
-GMMR0DECL(int) GMMR0ResetSharedModules(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+GMMR0DECL(int) GMMR0ResetSharedModules(PGVM pGVM, VMCPUID idCpu)
 {
 #ifdef VBOX_WITH_PAGE_SHARING
@@ -5092 +5068 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -5118 +5094 @@
     return rc;
 #else
-    RT_NOREF(pGVM, pVM, idCpu);
+    RT_NOREF(pGVM, idCpu);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -5150 +5126 @@
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The calling EMT number.
  * @thread  EMT(idCpu)
  */
-GMMR0DECL(int) GMMR0CheckSharedModules(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+GMMR0DECL(int) GMMR0CheckSharedModules(PGVM pGVM, VMCPUID idCpu)
 {
 #ifdef VBOX_WITH_PAGE_SHARING
@@ -5162 +5137 @@
     PGMM pGMM;
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_FAILURE(rc))
         return rc;
@@ -5195 +5170 @@
     return rc;
 #else
-    RT_NOREF(pGVM, pVM, idCpu);
+    RT_NOREF(pGVM, idCpu);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -5252 +5227 @@
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0FindDuplicatePageReq(PGVM pGVM, PVMCC pVM, PGMMFINDDUPLICATEPAGEREQ pReq)
+GMMR0DECL(int) GMMR0FindDuplicatePageReq(PGVM pGVM, PGMMFINDDUPLICATEPAGEREQ pReq)
 {
     /*
@@ -5266 +5240 @@
     GMM_GET_VALID_INSTANCE(pGMM, VERR_GMM_INSTANCE);
 
-    int rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+    int rc = GVMMR0ValidateGVM(pGVM);
     if (RT_FAILURE(rc))
         return rc;
@@ -5325 +5299 @@
  * @param   pSession    The current session.
  * @param   pGVM        The GVM to obtain statistics for. Optional.
- * @param   pVM         The VM structure corresponding to @a pGVM.
- */
-GMMR0DECL(int) GMMR0QueryStatistics(PGMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM, PVMCC pVM)
-{
-    LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pGVM=%p pVM=%p\n", pStats, pSession, pGVM, pVM));
+ */
+GMMR0DECL(int) GMMR0QueryStatistics(PGMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM)
+{
+    LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pGVM=%p\n", pStats, pSession, pGVM));
 
     /*
@@ -5347 +5320 @@
     if (pGVM)
     {
-        rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+        rc = GVMMR0ValidateGVM(pGVM);
         if (RT_FAILURE(rc))
             return rc;
@@ -5390 +5363 @@
  * @returns see GMMR0QueryStatistics.
  * @param   pGVM        The global (ring-0) VM structure. Optional.
- * @param   pVM         The cross context VM structure. Optional.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0QueryStatisticsReq(PGVM pGVM, PVMCC pVM, PGMMQUERYSTATISTICSSREQ pReq)
+GMMR0DECL(int) GMMR0QueryStatisticsReq(PGVM pGVM, PGMMQUERYSTATISTICSSREQ pReq)
 {
     /*
@@ -5401 +5373 @@
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GMMR0QueryStatistics(&pReq->Stats, pReq->pSession, pGVM, pVM);
+    return GMMR0QueryStatistics(&pReq->Stats, pReq->pSession, pGVM);
 }
 
@@ -5414 +5386 @@
  * @param   pSession    The current session.
  * @param   pGVM        The GVM to reset statistics for. Optional.
- * @param   pVM         The VM structure corresponding to @a pGVM.
- */
-GMMR0DECL(int) GMMR0ResetStatistics(PCGMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM, PVMCC pVM)
-{
-    NOREF(pStats); NOREF(pSession); NOREF(pVM); NOREF(pGVM);
+ */
+GMMR0DECL(int) GMMR0ResetStatistics(PCGMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM)
+{
+    NOREF(pStats); NOREF(pSession); NOREF(pGVM);
     /* Currently nothing we can reset at the moment. */
     return VINF_SUCCESS;
@@ -5429 +5400 @@
  * @returns see GMMR0ResetStatistics.
  * @param   pGVM        The global (ring-0) VM structure. Optional.
- * @param   pVM         The cross context VM structure. Optional.
  * @param   pReq        Pointer to the request packet.
  */
-GMMR0DECL(int) GMMR0ResetStatisticsReq(PGVM pGVM, PVMCC pVM, PGMMRESETSTATISTICSSREQ pReq)
+GMMR0DECL(int) GMMR0ResetStatisticsReq(PGVM pGVM, PGMMRESETSTATISTICSSREQ pReq)
 {
     /*
@@ -5440 +5410 @@
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GMMR0ResetStatistics(&pReq->Stats, pReq->pSession, pGVM, pVM);
-}
-
+    return GMMR0ResetStatistics(&pReq->Stats, pReq->pSession, pGVM);
+}
+

trunk/src/VBox/VMM/VMMR0/GVMMR0.cpp

@@ -119 +119 @@
         } \
     } while (0)
-# define GVMM_CHECK_SMAP_CHECK2(a_pVM, a_BadExpr) \
+# define GVMM_CHECK_SMAP_CHECK2(a_pGVM, a_BadExpr) \
     do { \
         if (fKernelFeatures & SUPKERNELFEATURES_SMAP) \
@@ -128 +128 @@
             else \
             { \
-                SUPR0BadContext((a_pVM) ? (a_pVM)->pSession : NULL, __FILE__, __LINE__, "EFLAGS.AC is zero!"); \
+                SUPR0BadContext((a_pGVM) ? (a_pGVM)->pSession : NULL, __FILE__, __LINE__, "EFLAGS.AC is zero!"); \
                 a_BadExpr; \
             } \
@@ -136 +136 @@
 # define GVMM_CHECK_SMAP_SETUP()           uint32_t const fKernelFeatures = 0
 # define GVMM_CHECK_SMAP_CHECK(a_BadExpr)           NOREF(fKernelFeatures)
-# define GVMM_CHECK_SMAP_CHECK2(a_pVM, a_BadExpr)   NOREF(fKernelFeatures)
+# define GVMM_CHECK_SMAP_CHECK2(a_pGVM, a_BadExpr)   NOREF(fKernelFeatures)
 #endif
 
@@ -159 +159 @@
     /** The pointer to the ring-0 only (aka global) VM structure. */
     PGVM                pGVM;
-    /** The ring-0 mapping of the shared VM instance data. */
-    PVMCC                 pVM;
+    /** The ring-0 mapping of the shared VM instance data.
+     * @todo remove this  */
+    PVMCC               pVMRemoveMe;
     /** The virtual machine object. */
     void               *pvObj;
@@ -361 +362 @@
 static void gvmmR0InitPerVMData(PGVM pGVM, int16_t hSelf, VMCPUID cCpus, PSUPDRVSESSION pSession);
 static DECLCALLBACK(void) gvmmR0HandleObjDestructor(void *pvObj, void *pvGVMM, void *pvHandle);
-static int gvmmR0ByGVMandVM(PGVM pGVM, PVMCC pVM, PGVMM *ppGVMM, bool fTakeUsedLock);
-static int gvmmR0ByGVMandVMandEMT(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGVMM *ppGVMM);
+static int gvmmR0ByGVM(PGVM pGVM, PGVMM *ppGVMM, bool fTakeUsedLock);
+static int gvmmR0ByGVMandEMT(PGVM pGVM, VMCPUID idCpu, PGVMM *ppGVMM);
 
 #ifdef GVMM_SCHED_WITH_PPT
@@ -528 +529 @@
     PGVMM pGVMM = g_pGVMM;
     g_pGVMM = NULL;
-    if (RT_UNLIKELY(!VALID_PTR(pGVMM)))
+    if (RT_UNLIKELY(!RT_VALID_PTR(pGVMM)))
     {
         SUPR0Printf("GVMMR0Term: pGVMM=%RKv\n", pGVMM);
@@ -779 +780 @@
      * Validate the request.
      */
-    if (!VALID_PTR(pReq))
+    if (!RT_VALID_PTR(pReq))
         return VERR_INVALID_POINTER;
     if (pReq->Hdr.cbReq != sizeof(*pReq))
@@ -789 +790 @@
      * Execute it.
      */
-    PVMCC pVM;
+    PGVM pGVM;
     pReq->pVMR0 = NULL;
     pReq->pVMR3 = NIL_RTR3PTR;
-    int rc = GVMMR0CreateVM(pSession, pReq->cCpus, &pVM);
+    int rc = GVMMR0CreateVM(pSession, pReq->cCpus, &pGVM);
     if (RT_SUCCESS(rc))
     {
-        pReq->pVMR0 = pVM;
-        pReq->pVMR3 = pVM->pVMR3;
+        pReq->pVMR0 = pGVM; /** @todo don't expose this to ring-3, use a unique random number instead. */
+        pReq->pVMR3 = pGVM->pVMR3;
     }
     return rc;
@@ -810 +811 @@
  * @param   pSession    The support driver session.
  * @param   cCpus       Number of virtual CPUs for the new VM.
- * @param   ppVM        Where to store the pointer to the VM structure.
+ * @param   ppGVM       Where to store the pointer to the VM structure.
  *
  * @thread  EMT.
  */
-GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCpus, PVMCC *ppVM)
+GVMMR0DECL(int) GVMMR0CreateVM(PSUPDRVSESSION pSession, uint32_t cCpus, PGVM *ppGVM)
 {
     LogFlow(("GVMMR0CreateVM: pSession=%p\n", pSession));
@@ -820 +821 @@
     GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
 
-    AssertPtrReturn(ppVM, VERR_INVALID_POINTER);
-    *ppVM = NULL;
+    AssertPtrReturn(ppGVM, VERR_INVALID_POINTER);
+    *ppGVM = NULL;
 
     if (    cCpus == 0
@@ -857 +858 @@
 
         /* consistency checks, a bit paranoid as always. */
-        if (    !pHandle->pVM
+        if (    !pHandle->pVMRemoveMe
             &&  !pHandle->pGVM
             &&  !pHandle->pvObj
@@ -876 +877 @@
                 pGVMM->cVMs++;
 
-                pHandle->pVM      = NULL;
+                pHandle->pVMRemoveMe = NULL;
                 pHandle->pGVM     = NULL;
                 pHandle->pSession = pSession;
@@ -967 +968 @@
                                 AssertRC(rc);
 
-                                pHandle->pVM                    = pGVM;
+                                pHandle->pVMRemoveMe            = pGVM;
                                 pHandle->pGVM                   = pGVM;
                                 pHandle->hEMT0                  = hEMT0;
@@ -994 +995 @@
                                         CPUMR0RegisterVCpuThread(&pGVM->aCpus[0]);
 
-                                        *ppVM = pGVM;
+                                        *ppGVM = pGVM;
                                         Log(("GVMMR0CreateVM: pVMR3=%p pGVM=%p hGVM=%d\n", pVMR3, pGVM, iHandle));
                                         return VINF_SUCCESS;
@@ -1192 +1193 @@
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  *
  * @thread  EMT(0) if it's associated with the VM, otherwise any thread.
  */
-GVMMR0DECL(int) GVMMR0DestroyVM(PGVM pGVM, PVMCC pVM)
-{
-    LogFlow(("GVMMR0DestroyVM: pGVM=%p pVM=%p\n", pGVM, pVM));
+GVMMR0DECL(int) GVMMR0DestroyVM(PGVM pGVM)
+{
+    LogFlow(("GVMMR0DestroyVM: pGVM=%p\n", pGVM));
     PGVMM pGVMM;
     GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
@@ -1206 +1206 @@
      */
     AssertPtrReturn(pGVM, VERR_INVALID_POINTER);
-    AssertPtrReturn(pVM, VERR_INVALID_POINTER);
-    AssertReturn(!((uintptr_t)pVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
-    AssertReturn(pGVM == pVM, VERR_INVALID_POINTER);
-    AssertMsgReturn(pVM->enmVMState >= VMSTATE_CREATING && pVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pVM->enmVMState),
+    AssertReturn(!((uintptr_t)pGVM & PAGE_OFFSET_MASK), VERR_INVALID_POINTER);
+    AssertMsgReturn(pGVM->enmVMState >= VMSTATE_CREATING && pGVM->enmVMState <= VMSTATE_TERMINATED, ("%d\n", pGVM->enmVMState),
                     VERR_WRONG_ORDER);
 
@@ -1218 +1216 @@
 
     PGVMHANDLE      pHandle = &pGVMM->aHandles[hGVM];
-    AssertReturn(pHandle->pVM == pVM, VERR_NOT_OWNER);
+    AssertReturn(pHandle->pGVM == pGVM, VERR_NOT_OWNER);
 
     RTPROCESS       ProcId = RTProcSelf();
@@ -1235 +1233 @@
 
     /* Be careful here because we might theoretically be racing someone else cleaning up. */
-    if (   pHandle->pVM == pVM
+    if (   pHandle->pGVM == pGVM
         && (   (   pHandle->hEMT0  == hSelf
                 && pHandle->ProcId == ProcId)
             || pHandle->hEMT0 == NIL_RTNATIVETHREAD)
-        && VALID_PTR(pHandle->pvObj)
-        && VALID_PTR(pHandle->pSession)
-        && VALID_PTR(pHandle->pGVM)
+        && RT_VALID_PTR(pHandle->pvObj)
+        && RT_VALID_PTR(pHandle->pSession)
+        && RT_VALID_PTR(pHandle->pGVM)
         && pHandle->pGVM->u32Magic == GVM_MAGIC)
     {
@@ -1265 +1263 @@
     else
     {
-        SUPR0Printf("GVMMR0DestroyVM: pHandle=%RKv:{.pVM=%p, .hEMT0=%p, .ProcId=%u, .pvObj=%p} pVM=%p hSelf=%p\n",
-                    pHandle, pHandle->pVM, pHandle->hEMT0, pHandle->ProcId, pHandle->pvObj, pVM, hSelf);
+        SUPR0Printf("GVMMR0DestroyVM: pHandle=%RKv:{.pGVM=%p, .hEMT0=%p, .ProcId=%u, .pvObj=%p} pGVM=%p hSelf=%p\n",
+                    pHandle, pHandle->pGVM, pHandle->hEMT0, pHandle->ProcId, pHandle->pvObj, pGVM, hSelf);
         gvmmR0CreateDestroyUnlock(pGVMM);
         rc = VERR_GVMM_IPE_2;
@@ -1289 +1287 @@
         {
             LogFlow(("gvmmR0CleanupVM: Calling VMMR0TermVM\n"));
-            VMMR0TermVM(pGVM, pGVM, NIL_VMCPUID);
+            VMMR0TermVM(pGVM, NIL_VMCPUID);
         }
         else
@@ -1399 +1397 @@
      */
     PGVM pGVM = pHandle->pGVM;
-    if (   VALID_PTR(pGVM)
+    if (   RT_VALID_PTR(pGVM)
         && pGVM->u32Magic == GVM_MAGIC)
     {
@@ -1465 +1463 @@
     pGVMM->iFreeHead = iHandle;
     ASMAtomicWriteNullPtr(&pHandle->pGVM);
-    ASMAtomicWriteNullPtr(&pHandle->pVM);
+    ASMAtomicWriteNullPtr(&pHandle->pVMRemoveMe);
     ASMAtomicWriteNullPtr(&pHandle->pvObj);
     ASMAtomicWriteNullPtr(&pHandle->pSession);
@@ -1484 +1482 @@
  * @returns VBox status code
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       VCPU id to register the current thread as.
  */
-GVMMR0DECL(int) GVMMR0RegisterVCpu(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+GVMMR0DECL(int) GVMMR0RegisterVCpu(PGVM pGVM, VMCPUID idCpu)
 {
     AssertReturn(idCpu != 0, VERR_INVALID_FUNCTION);
@@ -1495 +1492 @@
      */
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, false /* fTakeUsedLock */); /** @todo take lock here. */
+    int rc = gvmmR0ByGVM(pGVM, &pGVMM, false /* fTakeUsedLock */); /** @todo take lock here. */
     if (RT_SUCCESS(rc))
     {
@@ -1540 +1537 @@
  * @returns VBox status code
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       VCPU id to register the current thread as.
  */
-GVMMR0DECL(int) GVMMR0DeregisterVCpu(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+GVMMR0DECL(int) GVMMR0DeregisterVCpu(PGVM pGVM, VMCPUID idCpu)
 {
     AssertReturn(idCpu != 0, VERR_INVALID_FUNCTION);
@@ -1551 +1547 @@
      */
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVMandEMT(pGVM, pVM, idCpu, &pGVMM);
+    int rc = gvmmR0ByGVMandEMT(pGVM, idCpu, &pGVMM);
     if (RT_SUCCESS(rc))
     {
@@ -1606 +1602 @@
      */
     PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
-    AssertPtrReturn(pHandle->pVM, NULL);
+    AssertPtrReturn(pHandle->pVMRemoveMe, NULL);
     AssertPtrReturn(pHandle->pvObj, NULL);
     PGVM pGVM = pHandle->pGVM;
     AssertPtrReturn(pGVM, NULL);
-    AssertReturn(pGVM == pHandle->pVM, NULL);
-
-    return pHandle->pGVM;
-}
-
-
-/**
- * Lookup a GVM structure by the shared VM structure.
+
+    return pGVM;
+}
+
+
+/**
+ * Check that the given GVM and VM structures match up.
  *
  * The calling thread must be in the same process as the VM. All current lookups
@@ -1623 +1618 @@
  *
  * @returns VBox status code.
- * @param   pVM             The cross context VM structure.
- * @param   ppGVM           Where to store the GVM pointer.
+ * @param   pGVM            The global (ring-0) VM structure.
  * @param   ppGVMM          Where to store the pointer to the GVMM instance data.
  * @param   fTakeUsedLock   Whether to take the used lock or not.  We take it in
@@ -1632 +1626 @@
  *                          possible that the VM will disappear then!
  *
- * @remark  This will not assert on an invalid pVM but try return silently.
- */
-static int gvmmR0ByVM(PVMCC pVM, PGVM *ppGVM, PGVMM *ppGVMM, bool fTakeUsedLock)
-{
-    RTPROCESS ProcId = RTProcSelf();
-    PGVMM pGVMM;
-    GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
-
-    /*
-     * Validate.
-     */
-    if (RT_UNLIKELY(    !VALID_PTR(pVM)
-                    ||  ((uintptr_t)pVM & PAGE_OFFSET_MASK)))
-        return VERR_INVALID_POINTER;
-    if (RT_UNLIKELY(    pVM->enmVMState < VMSTATE_CREATING
-                    ||  pVM->enmVMState >= VMSTATE_TERMINATED))
-        return VERR_INVALID_POINTER;
-
-    uint16_t hGVM = pVM->hSelf;
-    ASMCompilerBarrier();
-    if (RT_UNLIKELY(    hGVM == NIL_GVM_HANDLE
-                    ||  hGVM >= RT_ELEMENTS(pGVMM->aHandles)))
-        return VERR_INVALID_HANDLE;
-
-    /*
-     * Look it up.
-     */
-    PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
-    PGVM pGVM;
-    if (fTakeUsedLock)
-    {
-        int rc = GVMMR0_USED_SHARED_LOCK(pGVMM);
-        AssertRCReturn(rc, rc);
-
-        pGVM = pHandle->pGVM;
-        if (RT_UNLIKELY(    pHandle->pVM != pVM
-                        ||  pHandle->ProcId != ProcId
-                        ||  !VALID_PTR(pHandle->pvObj)
-                        ||  !VALID_PTR(pGVM)
-                        ||  pGVM != pVM))
-        {
-            GVMMR0_USED_SHARED_UNLOCK(pGVMM);
-            return VERR_INVALID_HANDLE;
-        }
-    }
-    else
-    {
-        if (RT_UNLIKELY(pHandle->pVM != pVM))
-            return VERR_INVALID_HANDLE;
-        if (RT_UNLIKELY(pHandle->ProcId != ProcId))
-            return VERR_INVALID_HANDLE;
-        if (RT_UNLIKELY(!VALID_PTR(pHandle->pvObj)))
-            return VERR_INVALID_HANDLE;
-
-        pGVM = pHandle->pGVM;
-        if (RT_UNLIKELY(!VALID_PTR(pGVM)))
-            return VERR_INVALID_HANDLE;
-        if (RT_UNLIKELY(pGVM != pVM))
-            return VERR_INVALID_HANDLE;
-    }
-
-    *ppGVM = pGVM;
-    *ppGVMM = pGVMM;
-    return VINF_SUCCESS;
-}
-
-
-/**
- * Fast look up a GVM structure by the cross context VM structure.
- *
- * This is mainly used a glue function, so performance is .
- *
- * @returns GVM on success, NULL on failure.
- * @param   pVM             The cross context VM structure.  ASSUMES to be
- *                          reasonably valid, so we can do fewer checks than in
- *                          gvmmR0ByVM.
- *
- * @note    Do not use this on pVM structures from userland!
- */
-GVMMR0DECL(PGVM) GVMMR0FastGetGVMByVM(PVMCC pVM)
-{
-    AssertPtr(pVM);
-    Assert(!((uintptr_t)pVM & PAGE_OFFSET_MASK));
-
-    PGVMM pGVMM;
-    GVMM_GET_VALID_INSTANCE(pGVMM, NULL);
-
-    /*
-     * Validate.
-     */
-    uint16_t hGVM = pVM->hSelf;
-    ASMCompilerBarrier();
-    AssertReturn(hGVM != NIL_GVM_HANDLE && hGVM < RT_ELEMENTS(pGVMM->aHandles), NULL);
-
-    /*
-     * Look it up and check pVM against the value in the handle and GVM structures.
-     */
-    PGVMHANDLE pHandle = &pGVMM->aHandles[hGVM];
-    AssertReturn(pHandle->pVM == pVM, NULL);
-
-    PGVM pGVM = pHandle->pGVM;
-    AssertPtrReturn(pGVM, NULL);
-    AssertReturn(pGVM == pVM, NULL);
-
-    return pGVM;
-}
-
-
-/**
- * Check that the given GVM and VM structures match up.
- *
- * The calling thread must be in the same process as the VM. All current lookups
- * are by threads inside the same process, so this will not be an issue.
- *
- * @returns VBox status code.
- * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
- * @param   ppGVMM          Where to store the pointer to the GVMM instance data.
- * @param   fTakeUsedLock   Whether to take the used lock or not.  We take it in
- *                          shared mode when requested.
- *
- *                          Be very careful if not taking the lock as it's
- *                          possible that the VM will disappear then!
- *
- * @remark  This will not assert on an invalid pVM but try return silently.
- */
-static int gvmmR0ByGVMandVM(PGVM pGVM, PVMCC pVM, PGVMM *ppGVMM, bool fTakeUsedLock)
+ * @remark  This will not assert on an invalid pGVM but try return silently.
+ */
+static int gvmmR0ByGVM(PGVM pGVM, PGVMM *ppGVMM, bool fTakeUsedLock)
 {
     /*
@@ -1764 +1634 @@
      */
     int rc;
-    if (RT_LIKELY(RT_VALID_PTR(pGVM)))
-    {
-        if (RT_LIKELY(   RT_VALID_PTR(pVM)
-                      && ((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0))
-        {
-            if (RT_LIKELY(pGVM == pVM))
+    if (RT_LIKELY(   RT_VALID_PTR(pGVM)
+                  && ((uintptr_t)pGVM & PAGE_OFFSET_MASK) == 0 ))
+    {
+        /*
+         * Get the pGVMM instance and check the VM handle.
+         */
+        PGVMM pGVMM;
+        GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
+
+        uint16_t hGVM = pGVM->hSelf;
+        if (RT_LIKELY(   hGVM != NIL_GVM_HANDLE
+                      && hGVM < RT_ELEMENTS(pGVMM->aHandles)))
+        {
+            RTPROCESS const pidSelf = RTProcSelf();
+            PGVMHANDLE      pHandle = &pGVMM->aHandles[hGVM];
+            if (fTakeUsedLock)
+            {
+                rc = GVMMR0_USED_SHARED_LOCK(pGVMM);
+                AssertRCReturn(rc, rc);
+            }
+
+            if (RT_LIKELY(   pHandle->pGVM   == pGVM
+                          && pHandle->ProcId == pidSelf
+                          && RT_VALID_PTR(pHandle->pvObj)))
             {
                 /*
-                 * Get the pGVMM instance and check the VM handle.
+                 * Some more VM data consistency checks.
                  */
-                PGVMM pGVMM;
-                GVMM_GET_VALID_INSTANCE(pGVMM, VERR_GVMM_INSTANCE);
-
-                uint16_t hGVM = pGVM->hSelf;
-                if (RT_LIKELY(   hGVM != NIL_GVM_HANDLE
-                              && hGVM < RT_ELEMENTS(pGVMM->aHandles)))
+                if (RT_LIKELY(   pGVM->cCpusUnsafe == pGVM->cCpus
+                              && pGVM->hSelfUnsafe == hGVM
+                              && pGVM->pSelf       == pGVM))
                 {
-                    RTPROCESS const pidSelf = RTProcSelf();
-                    PGVMHANDLE      pHandle = &pGVMM->aHandles[hGVM];
-                    if (fTakeUsedLock)
+                    if (RT_LIKELY(   pGVM->enmVMState >= VMSTATE_CREATING
+                                  && pGVM->enmVMState <= VMSTATE_TERMINATED))
                     {
-                        rc = GVMMR0_USED_SHARED_LOCK(pGVMM);
-                        AssertRCReturn(rc, rc);
+                        *ppGVMM = pGVMM;
+                        return VINF_SUCCESS;
                     }
-
-                    if (RT_LIKELY(   pHandle->pGVM   == pGVM
-                                  && pHandle->pVM    == pVM
-                                  && pHandle->ProcId == pidSelf
-                                  && RT_VALID_PTR(pHandle->pvObj)))
-                    {
-                        /*
-                         * Some more VM data consistency checks.
-                         */
-                        if (RT_LIKELY(   pVM->cCpus == pGVM->cCpus
-                                      && pVM->hSelf == hGVM
-                                      && pVM->enmVMState >= VMSTATE_CREATING
-                                      && pVM->enmVMState <= VMSTATE_TERMINATED
-                                      && pVM->pSelf == pVM
-                                      ))
-                        {
-                            *ppGVMM = pGVMM;
-                            return VINF_SUCCESS;
-                        }
-                    }
-
-                    if (fTakeUsedLock)
-                        GVMMR0_USED_SHARED_UNLOCK(pGVMM);
+                    rc = VERR_INCONSISTENT_VM_HANDLE;
                 }
+                else
+                    rc = VERR_INCONSISTENT_VM_HANDLE;
             }
+            else
+                rc = VERR_INVALID_VM_HANDLE;
+
+            if (fTakeUsedLock)
+                GVMMR0_USED_SHARED_UNLOCK(pGVMM);
+        }
+        else
             rc = VERR_INVALID_VM_HANDLE;
-        }
-        else
-            rc = VERR_INVALID_POINTER;
     }
     else
@@ -1825 +1693 @@
 
 /**
+ * Validates a GVM/VM pair.
+ *
+ * @returns VBox status code.
+ * @param   pGVM        The global (ring-0) VM structure.
+ */
+GVMMR0DECL(int) GVMMR0ValidateGVM(PGVM pGVM)
+{
+    PGVMM pGVMM;
+    return gvmmR0ByGVM(pGVM, &pGVMM, false /*fTakeUsedLock*/);
+}
+
+
+/**
  * Check that the given GVM and VM structures match up.
  *
@@ -1832 +1713 @@
  * @returns VBox status code.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The (alleged) Virtual CPU ID of the calling EMT.
  * @param   ppGVMM          Where to store the pointer to the GVMM instance data.
@@ -1839 +1719 @@
  * @remarks This will assert in all failure paths.
  */
-static int gvmmR0ByGVMandVMandEMT(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, PGVMM *ppGVMM)
+static int gvmmR0ByGVMandEMT(PGVM pGVM, VMCPUID idCpu, PGVMM *ppGVMM)
 {
     /*
@@ -1845 +1725 @@
      */
     AssertPtrReturn(pGVM, VERR_INVALID_POINTER);
-
-    AssertPtrReturn(pVM,  VERR_INVALID_POINTER);
-    AssertReturn(((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0, VERR_INVALID_POINTER);
-    AssertReturn(pGVM == pVM, VERR_INVALID_VM_HANDLE);
+    AssertReturn(((uintptr_t)pGVM & PAGE_OFFSET_MASK) == 0, VERR_INVALID_POINTER);
 
     /*
@@ -1864 +1741 @@
     PGVMHANDLE      pHandle = &pGVMM->aHandles[hGVM];
     AssertReturn(   pHandle->pGVM   == pGVM
-                 && pHandle->pVM    == pVM
                  && pHandle->ProcId == pidSelf
                  && RT_VALID_PTR(pHandle->pvObj),
@@ -1879 +1755 @@
      * Some more VM data consistency checks.
      */
-    AssertReturn(pVM->cCpus == pGVM->cCpus, VERR_INCONSISTENT_VM_HANDLE);
-    AssertReturn(pVM->hSelf == hGVM, VERR_INCONSISTENT_VM_HANDLE);
-    AssertReturn(   pVM->enmVMState >= VMSTATE_CREATING
-                 && pVM->enmVMState <= VMSTATE_TERMINATED, VERR_INCONSISTENT_VM_HANDLE);
+    AssertReturn(pGVM->cCpusUnsafe == pGVM->cCpus, VERR_INCONSISTENT_VM_HANDLE);
+    AssertReturn(pGVM->hSelfUnsafe == hGVM, VERR_INCONSISTENT_VM_HANDLE);
+    AssertReturn(   pGVM->enmVMState >= VMSTATE_CREATING
+                 && pGVM->enmVMState <= VMSTATE_TERMINATED, VERR_INCONSISTENT_VM_HANDLE);
 
     *ppGVMM = pGVMM;
@@ -1890 +1766 @@
 
 /**
- * Validates a GVM/VM pair.
+ * Validates a GVM/EMT pair.
  *
  * @returns VBox status code.
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
- */
-GVMMR0DECL(int) GVMMR0ValidateGVMandVM(PGVM pGVM, PVMCC pVM)
-{
-    PGVMM pGVMM;
-    return gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, false /*fTakeUsedLock*/);
-}
-
-
-
-/**
- * Validates a GVM/VM/EMT combo.
- *
- * @returns VBox status code.
- * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The Virtual CPU ID of the calling EMT.
  * @thread  EMT(idCpu)
  */
-GVMMR0DECL(int) GVMMR0ValidateGVMandVMandEMT(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+GVMMR0DECL(int) GVMMR0ValidateGVMandEMT(PGVM pGVM, VMCPUID idCpu)
 {
     PGVMM pGVMM;
-    return gvmmR0ByGVMandVMandEMT(pGVM, pVM, idCpu, &pGVMM);
+    return gvmmR0ByGVMandEMT(pGVM, idCpu, &pGVMM);
 }
 
@@ -1938 +1798 @@
      */
     PGVMM pGVMM = g_pGVMM;
-    if (    !VALID_PTR(pGVMM)
+    if (    !RT_VALID_PTR(pGVMM)
         ||  pGVMM->u32Magic != GVMM_MAGIC)
         return NULL;
@@ -1954 +1814 @@
         if (    pGVMM->aHandles[i].iSelf == i
             &&  pGVMM->aHandles[i].ProcId == ProcId
-            &&  VALID_PTR(pGVMM->aHandles[i].pvObj)
-            &&  VALID_PTR(pGVMM->aHandles[i].pVM)
-            &&  VALID_PTR(pGVMM->aHandles[i].pGVM))
+            &&  RT_VALID_PTR(pGVMM->aHandles[i].pvObj)
+            &&  RT_VALID_PTR(pGVMM->aHandles[i].pGVM))
         {
             if (pGVMM->aHandles[i].hEMT0 == hEMT)
-                return pGVMM->aHandles[i].pVM;
+                return pGVMM->aHandles[i].pGVM;
 
             /* This is fearly safe with the current process per VM approach. */
@@ -1970 +1829 @@
             for (VMCPUID idCpu = 1; idCpu < cCpus; idCpu++)
                 if (pGVM->aCpus[idCpu].hEMT == hEMT)
-                    return pGVMM->aHandles[i].pVM;
+                    return pGVMM->aHandles[i].pGVM;
         }
     }
@@ -1995 +1854 @@
      */
     PGVMM pGVMM = g_pGVMM;
-    if (   !VALID_PTR(pGVMM)
+    if (   !RT_VALID_PTR(pGVMM)
         || pGVMM->u32Magic != GVMM_MAGIC)
         return NULL;
@@ -2011 +1870 @@
         if (   pGVMM->aHandles[i].iSelf == i
             && pGVMM->aHandles[i].ProcId == ProcId
-            && VALID_PTR(pGVMM->aHandles[i].pvObj)
-            && VALID_PTR(pGVMM->aHandles[i].pVM)
-            && VALID_PTR(pGVMM->aHandles[i].pGVM))
+            && RT_VALID_PTR(pGVMM->aHandles[i].pvObj)
+            && RT_VALID_PTR(pGVMM->aHandles[i].pGVM))
         {
             PGVM pGVM = pGVMM->aHandles[i].pGVM;
@@ -2082 +1940 @@
     {
         PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
-        if (    VALID_PTR(pCurGVM)
+        if (    RT_VALID_PTR(pCurGVM)
             &&  pCurGVM->u32Magic == GVM_MAGIC)
         {
@@ -2123 +1981 @@
         {
             PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
-            if (    VALID_PTR(pCurGVM)
+            if (    RT_VALID_PTR(pCurGVM)
                 &&  pCurGVM->u32Magic == GVM_MAGIC)
             {
@@ -2153 +2011 @@
         {
             PGVM pCurGVM = pGVMM->aHandles[i].pGVM;
-            if (    VALID_PTR(pCurGVM)
+            if (    RT_VALID_PTR(pCurGVM)
                 &&  pCurGVM->u32Magic == GVM_MAGIC)
             {
@@ -2192 +2050 @@
  *          VERR_INTERRUPTED if a signal was scheduled for the thread.
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   pGVCpu              The global (ring-0) CPU structure of the calling
  *                              EMT.
@@ -2198 +2055 @@
  * @thread  EMT(pGVCpu).
  */
-GVMMR0DECL(int) GVMMR0SchedHalt(PGVM pGVM, PVMCC pVM, PGVMCPU pGVCpu, uint64_t u64ExpireGipTime)
-{
-    LogFlow(("GVMMR0SchedHalt: pGVM=%p pVM=%p pGVCpu=%p(%d) u64ExpireGipTime=%#RX64\n",
-             pGVM, pVM, pGVCpu, pGVCpu->idCpu, u64ExpireGipTime));
+GVMMR0DECL(int) GVMMR0SchedHalt(PGVM pGVM, PGVMCPU pGVCpu, uint64_t u64ExpireGipTime)
+{
+    LogFlow(("GVMMR0SchedHalt: pGVM=%p pGVCpu=%p(%d) u64ExpireGipTime=%#RX64\n",
+             pGVM, pGVCpu, pGVCpu->idCpu, u64ExpireGipTime));
     GVMM_CHECK_SMAP_SETUP();
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
     PGVMM pGVMM;
@@ -2220 +2077 @@
     {
         int rc2 = GVMMR0_USED_SHARED_LOCK(pGVMM); AssertRC(rc2);
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     }
 
@@ -2231 +2088 @@
     const uint64_t u64NowSys = RTTimeSystemNanoTS();
     const uint64_t u64NowGip = RTTimeNanoTS();
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
     if (fDoEarlyWakeUps)
     {
         pGVM->gvmm.s.StatsSched.cHaltWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64NowGip);
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     }
 
@@ -2261 +2118 @@
             GVMMR0_USED_SHARED_UNLOCK(pGVMM);
         }
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
         rc = RTSemEventMultiWaitEx(pGVCpu->gvmm.s.HaltEventMulti,
                                    RTSEMWAIT_FLAGS_ABSOLUTE | RTSEMWAIT_FLAGS_NANOSECS | RTSEMWAIT_FLAGS_INTERRUPTIBLE,
                                    u64NowGip > u64NowSys ? u64ExpireGipTime : u64NowSys + cNsInterval);
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
         ASMAtomicWriteU64(&pGVCpu->gvmm.s.u64HaltExpire, 0);
@@ -2275 +2132 @@
         {
             RTSemEventMultiReset(pGVCpu->gvmm.s.HaltEventMulti);
-            GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
         }
         else if (rc == VERR_TIMEOUT)
@@ -2288 +2145 @@
         if (fDoEarlyWakeUps)
             GVMMR0_USED_SHARED_UNLOCK(pGVMM);
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
         RTSemEventMultiReset(pGVCpu->gvmm.s.HaltEventMulti);
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
         rc = VINF_SUCCESS;
     }
@@ -2304 +2161 @@
  *          VERR_INTERRUPTED if a signal was scheduled for the thread.
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The Virtual CPU ID of the calling EMT.
  * @param   u64ExpireGipTime    The time for the sleep to expire expressed as GIP time.
  * @thread  EMT(idCpu).
  */
-GVMMR0DECL(int) GVMMR0SchedHaltReq(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint64_t u64ExpireGipTime)
+GVMMR0DECL(int) GVMMR0SchedHaltReq(PGVM pGVM, VMCPUID idCpu, uint64_t u64ExpireGipTime)
 {
     GVMM_CHECK_SMAP_SETUP();
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVMandEMT(pGVM, pVM, idCpu, &pGVMM);
+    int rc = gvmmR0ByGVMandEMT(pGVM, idCpu, &pGVMM);
     if (RT_SUCCESS(rc))
     {
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-        rc = GVMMR0SchedHalt(pGVM, pVM, &pGVM->aCpus[idCpu], u64ExpireGipTime);
-    }
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+        rc = GVMMR0SchedHalt(pGVM, &pGVM->aCpus[idCpu], u64ExpireGipTime);
+    }
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     return rc;
 }
@@ -2376 +2232 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The Virtual CPU ID of the EMT to wake up.
  * @param   fTakeUsedLock       Take the used lock or not
  * @thread  Any but EMT(idCpu).
  */
-GVMMR0DECL(int) GVMMR0SchedWakeUpEx(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, bool fTakeUsedLock)
+GVMMR0DECL(int) GVMMR0SchedWakeUpEx(PGVM pGVM, VMCPUID idCpu, bool fTakeUsedLock)
 {
     GVMM_CHECK_SMAP_SETUP();
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
     /*
@@ -2390 +2245 @@
      */
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, fTakeUsedLock);
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    int rc = gvmmR0ByGVM(pGVM, &pGVMM, fTakeUsedLock);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     if (RT_SUCCESS(rc))
     {
@@ -2400 +2255 @@
              */
             rc = gvmmR0SchedWakeUpOne(pGVM, &pGVM->aCpus[idCpu]);
-            GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
             if (fTakeUsedLock && pGVMM->fDoEarlyWakeUps)
@@ -2410 +2265 @@
                 const uint64_t u64Now = RTTimeNanoTS(); /* (GIP time) */
                 pGVM->gvmm.s.StatsSched.cWakeUpWakeUps += gvmmR0SchedDoWakeUps(pGVMM, u64Now);
-                GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             }
         }
@@ -2420 +2275 @@
             int rc2 = GVMMR0_USED_SHARED_UNLOCK(pGVMM);
             AssertRC(rc2);
-            GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
         }
     }
@@ -2437 +2292 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The Virtual CPU ID of the EMT to wake up.
  * @thread  Any but EMT(idCpu).
  */
-GVMMR0DECL(int) GVMMR0SchedWakeUp(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
-{
-    return GVMMR0SchedWakeUpEx(pGVM, pVM, idCpu, true /* fTakeUsedLock */);
+GVMMR0DECL(int) GVMMR0SchedWakeUp(PGVM pGVM, VMCPUID idCpu)
+{
+    return GVMMR0SchedWakeUpEx(pGVM, idCpu, true /* fTakeUsedLock */);
 }
 
@@ -2455 +2309 @@
  * @retval  VINF_GVM_NOT_BLOCKED if the EMT wasn't blocked.
  *
- * @param   pVM                 The cross context VM structure.
+ * @param   pGVM                The global (ring-0) VM structure.
  * @param   idCpu               The Virtual CPU ID of the EMT to wake up.
  * @thread  Any but EMT(idCpu).
  * @deprecated  Don't use in new code if possible!  Use the GVM variant.
  */
-GVMMR0DECL(int) GVMMR0SchedWakeUpNoGVMNoLock(PVMCC pVM, VMCPUID idCpu)
+GVMMR0DECL(int) GVMMR0SchedWakeUpNoGVMNoLock(PGVM pGVM, VMCPUID idCpu)
 {
     GVMM_CHECK_SMAP_SETUP();
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-    PGVM pGVM;
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     PGVMM pGVMM;
-    int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, false /*fTakeUsedLock*/);
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    int rc = gvmmR0ByGVM(pGVM, &pGVMM, false /*fTakeUsedLock*/);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     if (RT_SUCCESS(rc))
-        rc = GVMMR0SchedWakeUpEx(pGVM, pVM, idCpu, false /*fTakeUsedLock*/);
+        rc = GVMMR0SchedWakeUpEx(pGVM, idCpu, false /*fTakeUsedLock*/);
     return rc;
 }
@@ -2511 +2364 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The ID of the virtual CPU to poke.
  * @param   fTakeUsedLock       Take the used lock or not
  */
-GVMMR0DECL(int) GVMMR0SchedPokeEx(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, bool fTakeUsedLock)
+GVMMR0DECL(int) GVMMR0SchedPokeEx(PGVM pGVM, VMCPUID idCpu, bool fTakeUsedLock)
 {
     /*
@@ -2521 +2373 @@
      */
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, fTakeUsedLock);
+    int rc = gvmmR0ByGVM(pGVM, &pGVMM, fTakeUsedLock);
     if (RT_SUCCESS(rc))
     {
@@ -2549 +2401 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   idCpu               The ID of the virtual CPU to poke.
  */
-GVMMR0DECL(int) GVMMR0SchedPoke(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
-{
-    return GVMMR0SchedPokeEx(pGVM, pVM, idCpu, true /* fTakeUsedLock */);
+GVMMR0DECL(int) GVMMR0SchedPoke(PGVM pGVM, VMCPUID idCpu)
+{
+    return GVMMR0SchedPokeEx(pGVM, idCpu, true /* fTakeUsedLock */);
 }
 
@@ -2566 +2417 @@
  * @retval  VINF_GVM_NOT_BUSY_IN_GC if the EMT wasn't busy in GC.
  *
- * @param   pVM                 The cross context VM structure.
+ * @param   pGVM                The global (ring-0) VM structure.
  * @param   idCpu               The ID of the virtual CPU to poke.
  *
  * @deprecated  Don't use in new code if possible!  Use the GVM variant.
  */
-GVMMR0DECL(int) GVMMR0SchedPokeNoGVMNoLock(PVMCC pVM, VMCPUID idCpu)
-{
-    PGVM pGVM;
+GVMMR0DECL(int) GVMMR0SchedPokeNoGVMNoLock(PGVM pGVM, VMCPUID idCpu)
+{
     PGVMM pGVMM;
-    int rc = gvmmR0ByVM(pVM, &pGVM, &pGVMM, false /*fTakeUsedLock*/);
+    int rc = gvmmR0ByGVM(pGVM, &pGVMM, false /*fTakeUsedLock*/);
     if (RT_SUCCESS(rc))
     {
@@ -2593 +2443 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
  * @param   pSleepSet           The set of sleepers to wake up.
  * @param   pPokeSet            The set of CPUs to poke.
  */
-GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpus(PGVM pGVM, PVMCC pVM, PCVMCPUSET pSleepSet, PCVMCPUSET pPokeSet)
+GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpus(PGVM pGVM, PCVMCPUSET pSleepSet, PCVMCPUSET pPokeSet)
 {
     AssertPtrReturn(pSleepSet, VERR_INVALID_POINTER);
     AssertPtrReturn(pPokeSet, VERR_INVALID_POINTER);
     GVMM_CHECK_SMAP_SETUP();
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     RTNATIVETHREAD hSelf = RTThreadNativeSelf();
 
@@ -2609 +2458 @@
      */
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, true /* fTakeUsedLock */);
-    GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    int rc = gvmmR0ByGVM(pGVM, &pGVMM, true /* fTakeUsedLock */);
+    GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     if (RT_SUCCESS(rc))
     {
@@ -2625 +2474 @@
             {
                 gvmmR0SchedWakeUpOne(pGVM, &pGVM->aCpus[idCpu]);
-                GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             }
             else if (VMCPUSET_IS_PRESENT(pPokeSet, idCpu))
             {
                 gvmmR0SchedPokeOne(pGVM, &pGVM->aCpus[idCpu]);
-                GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             }
         }
@@ -2636 +2485 @@
         int rc2 = GVMMR0_USED_SHARED_UNLOCK(pGVMM);
         AssertRC(rc2);
-        GVMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+        GVMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     }
 
@@ -2649 +2498 @@
  * @returns see GVMMR0SchedWakeUpAndPokeCpus.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   pReq            Pointer to the request packet.
  */
-GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpusReq(PGVM pGVM, PVMCC pVM, PGVMMSCHEDWAKEUPANDPOKECPUSREQ pReq)
+GVMMR0DECL(int) GVMMR0SchedWakeUpAndPokeCpusReq(PGVM pGVM, PGVMMSCHEDWAKEUPANDPOKECPUSREQ pReq)
 {
     /*
@@ -2660 +2508 @@
     AssertMsgReturn(pReq->Hdr.cbReq == sizeof(*pReq), ("%#x != %#x\n", pReq->Hdr.cbReq, sizeof(*pReq)), VERR_INVALID_PARAMETER);
 
-    return GVMMR0SchedWakeUpAndPokeCpus(pGVM, pVM, &pReq->SleepSet, &pReq->PokeSet);
+    return GVMMR0SchedWakeUpAndPokeCpus(pGVM, &pReq->SleepSet, &pReq->PokeSet);
 }
 
@@ -2674 +2522 @@
  *          VINF_GVM_YIELDED if an attempt to switch to a different VM task was made.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           The Virtual CPU ID of the calling EMT.
  * @param   fYield          Whether to yield or not.
@@ -2680 +2527 @@
  * @thread  EMT(idCpu).
  */
-GVMMR0DECL(int) GVMMR0SchedPoll(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, bool fYield)
+GVMMR0DECL(int) GVMMR0SchedPoll(PGVM pGVM, VMCPUID idCpu, bool fYield)
 {
     /*
@@ -2686 +2533 @@
      */
     PGVMM pGVMM;
-    int rc = gvmmR0ByGVMandVMandEMT(pGVM, pVM, idCpu, &pGVMM);
+    int rc = gvmmR0ByGVMandEMT(pGVM, idCpu, &pGVMM);
     if (RT_SUCCESS(rc))
     {
@@ -2809 +2656 @@
  * The caller must check that the host can do high resolution timers.
  *
- * @param   pVM         The cross context VM structure.
+ * @param   pGVM        The global (ring-0) VM structure.
  * @param   idHostCpu   The current host CPU id.
  * @param   uHz         The desired frequency.
  */
-GVMMR0DECL(void) GVMMR0SchedUpdatePeriodicPreemptionTimer(PVMCC pVM, RTCPUID idHostCpu, uint32_t uHz)
-{
-    NOREF(pVM);
+GVMMR0DECL(void) GVMMR0SchedUpdatePeriodicPreemptionTimer(PGVM pGVM, RTCPUID idHostCpu, uint32_t uHz)
+{
+    NOREF(pGVM);
 #ifdef GVMM_SCHED_WITH_PPT
     Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
@@ -2825 +2672 @@
     uint32_t    iCpu  = RTMpCpuIdToSetIndex(idHostCpu);
     PGVMM       pGVMM = g_pGVMM;
-    if (   !VALID_PTR(pGVMM)
+    if (   !RT_VALID_PTR(pGVMM)
         || pGVMM->u32Magic != GVMM_MAGIC)
         return;
@@ -2894 +2741 @@
  * @param   pSession    The current session.
  * @param   pGVM        The GVM to obtain statistics for. Optional.
- * @param   pVM         The VM structure corresponding to @a pGVM.
- */
-GVMMR0DECL(int) GVMMR0QueryStatistics(PGVMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM, PVMCC pVM)
-{
-    LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pGVM=%p pVM=%p\n", pStats, pSession, pGVM, pVM));
+ */
+GVMMR0DECL(int) GVMMR0QueryStatistics(PGVMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM)
+{
+    LogFlow(("GVMMR0QueryStatistics: pStats=%p pSession=%p pGVM=%p\n", pStats, pSession, pGVM));
 
     /*
@@ -2913 +2759 @@
     if (pGVM)
     {
-        int rc = gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, true /*fTakeUsedLock*/);
+        int rc = gvmmR0ByGVM(pGVM, &pGVMM, true /*fTakeUsedLock*/);
         if (RT_FAILURE(rc))
             return rc;
@@ -2940 +2786 @@
         PGVM pOtherGVM = pGVMM->aHandles[i].pGVM;
         void *pvObj = pGVMM->aHandles[i].pvObj;
-        if (    VALID_PTR(pvObj)
-            &&  VALID_PTR(pOtherGVM)
+        if (    RT_VALID_PTR(pvObj)
+            &&  RT_VALID_PTR(pOtherGVM)
             &&  pOtherGVM->u32Magic == GVM_MAGIC
             &&  RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
@@ -3007 +2853 @@
  * @returns see GVMMR0QueryStatistics.
  * @param   pGVM            The global (ring-0) VM structure. Optional.
- * @param   pVM             The cross context VM structure. Optional.
  * @param   pReq            Pointer to the request packet.
  * @param   pSession        The current session.
  */
-GVMMR0DECL(int) GVMMR0QueryStatisticsReq(PGVM pGVM, PVMCC pVM, PGVMMQUERYSTATISTICSSREQ pReq, PSUPDRVSESSION pSession)
+GVMMR0DECL(int) GVMMR0QueryStatisticsReq(PGVM pGVM, PGVMMQUERYSTATISTICSSREQ pReq, PSUPDRVSESSION pSession)
 {
     /*
@@ -3020 +2865 @@
     AssertReturn(pReq->pSession == pSession, VERR_INVALID_PARAMETER);
 
-    return GVMMR0QueryStatistics(&pReq->Stats, pSession, pGVM, pVM);
+    return GVMMR0QueryStatistics(&pReq->Stats, pSession, pGVM);
 }
 
@@ -3032 +2877 @@
  * @param   pSession    The current session.
  * @param   pGVM        The GVM to reset statistics for. Optional.
- * @param   pVM         The VM structure corresponding to @a pGVM.
- */
-GVMMR0DECL(int) GVMMR0ResetStatistics(PCGVMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM, PVMCC pVM)
-{
-    LogFlow(("GVMMR0ResetStatistics: pStats=%p pSession=%p pGVM=%p pVM=%p\n", pStats, pSession, pGVM, pVM));
+ */
+GVMMR0DECL(int) GVMMR0ResetStatistics(PCGVMMSTATS pStats, PSUPDRVSESSION pSession, PGVM pGVM)
+{
+    LogFlow(("GVMMR0ResetStatistics: pStats=%p pSession=%p pGVM=%p\n", pStats, pSession, pGVM));
 
     /*
@@ -3050 +2894 @@
     if (pGVM)
     {
-        int rc = gvmmR0ByGVMandVM(pGVM, pVM, &pGVMM, true /*fTakeUsedLock*/);
+        int rc = gvmmR0ByGVM(pGVM, &pGVMM, true /*fTakeUsedLock*/);
         if (RT_FAILURE(rc))
             return rc;
@@ -3089 +2933 @@
             PGVM pOtherGVM = pGVMM->aHandles[i].pGVM;
             void *pvObj = pGVMM->aHandles[i].pvObj;
-            if (    VALID_PTR(pvObj)
-                &&  VALID_PTR(pOtherGVM)
+            if (    RT_VALID_PTR(pvObj)
+                &&  RT_VALID_PTR(pOtherGVM)
                 &&  pOtherGVM->u32Magic == GVM_MAGIC
                 &&  RT_SUCCESS(SUPR0ObjVerifyAccess(pvObj, pSession, NULL)))
@@ -3125 +2969 @@
  * @returns see GVMMR0ResetStatistics.
  * @param   pGVM            The global (ring-0) VM structure. Optional.
- * @param   pVM             The cross context VM structure. Optional.
  * @param   pReq            Pointer to the request packet.
  * @param   pSession        The current session.
  */
-GVMMR0DECL(int) GVMMR0ResetStatisticsReq(PGVM pGVM, PVMCC pVM, PGVMMRESETSTATISTICSSREQ pReq, PSUPDRVSESSION pSession)
+GVMMR0DECL(int) GVMMR0ResetStatisticsReq(PGVM pGVM, PGVMMRESETSTATISTICSSREQ pReq, PSUPDRVSESSION pSession)
 {
     /*
@@ -3138 +2981 @@
     AssertReturn(pReq->pSession == pSession, VERR_INVALID_PARAMETER);
 
-    return GVMMR0ResetStatistics(&pReq->Stats, pSession, pGVM, pVM);
-}
-
+    return GVMMR0ResetStatistics(&pReq->Stats, pSession, pGVM);
+}
+

trunk/src/VBox/VMM/VMMR0/NEMR0Native-win.cpp

@@ -80 +80 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-NEM_TMPL_STATIC int  nemR0WinMapPages(PGVM pGVM, PVMCC pVM, PGVMCPU pGVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
+NEM_TMPL_STATIC int  nemR0WinMapPages(PGVM pGVM, PGVMCPU pGVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
                                       uint32_t cPages, uint32_t fFlags);
 NEM_TMPL_STATIC int  nemR0WinUnmapPages(PGVM pGVM, PGVMCPU pGVCpu, RTGCPHYS GCPhys, uint32_t cPages);
@@ -89 +89 @@
 NEM_TMPL_STATIC int  nemR0WinResumeCpuTickOnAll(PGVM pGVM, PGVMCPU pGVCpu, uint64_t uPausedTscValue);
 #endif
-DECLINLINE(NTSTATUS) nemR0NtPerformIoControl(PGVM pGVM, PVMCPUCC pVCpu, uint32_t uFunction, void *pvInput, uint32_t cbInput,
+DECLINLINE(NTSTATUS) nemR0NtPerformIoControl(PGVM pGVM, PGVMCPU pGVCpu, uint32_t uFunction, void *pvInput, uint32_t cbInput,
                                              void *pvOutput, uint32_t cbOutput);
 
@@ -156 +156 @@
  * @returns VBox status code.
  * @param   pGVM            The ring-0 VM handle.
- * @param   pVM             The cross context VM handle.
  * @thread  EMT(0)
  */
-VMMR0_INT_DECL(int) NEMR0InitVM(PGVM pGVM, PVMCC pVM)
+VMMR0_INT_DECL(int) NEMR0InitVM(PGVM pGVM)
 {
     AssertCompile(sizeof(pGVM->nemr0.s) <= sizeof(pGVM->nemr0.padding));
     AssertCompile(sizeof(pGVM->aCpus[0].nemr0.s) <= sizeof(pGVM->aCpus[0].nemr0.padding));
 
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, 0);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, 0);
     AssertRCReturn(rc, rc);
 
@@ -228 +227 @@
     }
 
-    RT_NOREF(pVM);
     return rc;
 }
@@ -238 +236 @@
  * @returns NT status code.
  * @param   pGVM            The ring-0 VM structure.
- * @param   pVCpu           The cross context CPU structure of the calling EMT.
+ * @param   pGVCpu          The global (ring-0) CPU structure of the calling EMT.
  * @param   uFunction       The function to perform.
  * @param   pvInput         The input buffer.  This must point within the VM
@@ -249 +247 @@
  * @param   cbOutput        The size of the output.  @a pvOutput must be NULL
  *                          when zero.
- * @thread  EMT(pVCpu)
+ * @thread  EMT(pGVCpu)
  */
-DECLINLINE(NTSTATUS) nemR0NtPerformIoControl(PGVM pGVM, PVMCPUCC pVCpu, uint32_t uFunction, void *pvInput, uint32_t cbInput,
+DECLINLINE(NTSTATUS) nemR0NtPerformIoControl(PGVM pGVM, PGVMCPU pGVCpu, uint32_t uFunction, void *pvInput, uint32_t cbInput,
                                              void *pvOutput, uint32_t cbOutput)
 {
@@ -258 +256 @@
      * Input and output parameters are part of the VM CPU structure.
      */
-    VMCPU_ASSERT_EMT(pVCpu);
+    VMCPU_ASSERT_EMT(pGVCpu);
     if (pvInput)
-        AssertReturn(((uintptr_t)pvInput + cbInput) - (uintptr_t)pVCpu <= sizeof(*pVCpu), VERR_INVALID_PARAMETER);
+        AssertReturn(((uintptr_t)pvInput + cbInput) - (uintptr_t)pGVCpu <= sizeof(*pGVCpu), VERR_INVALID_PARAMETER);
     if (pvOutput)
-        AssertReturn(((uintptr_t)pvOutput + cbOutput) - (uintptr_t)pVCpu <= sizeof(*pVCpu), VERR_INVALID_PARAMETER);
+        AssertReturn(((uintptr_t)pvOutput + cbOutput) - (uintptr_t)pGVCpu <= sizeof(*pGVCpu), VERR_INVALID_PARAMETER);
 #endif
 
@@ -268 +266 @@
     int rc = SUPR0IoCtlPerform(pGVM->nemr0.s.pIoCtlCtx, uFunction,
                                pvInput,
-                               pvInput  ? (uintptr_t)pvInput  + pVCpu->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
+                               pvInput  ? (uintptr_t)pvInput  + pGVCpu->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
                                cbInput,
                                pvOutput,
-                               pvOutput ? (uintptr_t)pvOutput + pVCpu->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
+                               pvOutput ? (uintptr_t)pvOutput + pGVCpu->nemr0.s.offRing3ConversionDelta : NIL_RTR3PTR,
                                cbOutput,
                                &rcNt);
@@ -285 +283 @@
  * @returns VBox status code.
  * @param   pGVM            The ring-0 VM handle.
- * @param   pVM             The cross context VM handle.
  * @thread  EMT(0)
  */
-VMMR0_INT_DECL(int) NEMR0InitVMPart2(PGVM pGVM, PVMCC pVM)
+VMMR0_INT_DECL(int) NEMR0InitVMPart2(PGVM pGVM)
 {
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, 0);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, 0);
     AssertRCReturn(rc, rc);
     SUPR0Printf("NEMR0InitVMPart2\n"); LogRel(("2: NEMR0InitVMPart2\n"));
@@ -298 +295 @@
      * Copy and validate the I/O control information from ring-3.
      */
-    NEMWINIOCTL Copy = pVM->nem.s.IoCtlGetHvPartitionId;
+    NEMWINIOCTL Copy = pGVM->nem.s.IoCtlGetHvPartitionId;
     AssertLogRelReturn(Copy.uFunction != 0, VERR_NEM_INIT_FAILED);
     AssertLogRelReturn(Copy.cbInput == 0, VERR_NEM_INIT_FAILED);
@@ -304 +301 @@
     pGVM->nemr0.s.IoCtlGetHvPartitionId = Copy;
 
-    pGVM->nemr0.s.fMayUseRing0Runloop = pVM->nem.s.fUseRing0Runloop;
-
-    Copy = pVM->nem.s.IoCtlStartVirtualProcessor;
+    pGVM->nemr0.s.fMayUseRing0Runloop = pGVM->nem.s.fUseRing0Runloop;
+
+    Copy = pGVM->nem.s.IoCtlStartVirtualProcessor;
     AssertLogRelStmt(Copy.uFunction != 0, rc = VERR_NEM_INIT_FAILED);
     AssertLogRelStmt(Copy.cbInput == sizeof(HV_VP_INDEX), rc = VERR_NEM_INIT_FAILED);
@@ -314 +311 @@
         pGVM->nemr0.s.IoCtlStartVirtualProcessor = Copy;
 
-    Copy = pVM->nem.s.IoCtlStopVirtualProcessor;
+    Copy = pGVM->nem.s.IoCtlStopVirtualProcessor;
     AssertLogRelStmt(Copy.uFunction != 0, rc = VERR_NEM_INIT_FAILED);
     AssertLogRelStmt(Copy.cbInput == sizeof(HV_VP_INDEX), rc = VERR_NEM_INIT_FAILED);
@@ -323 +320 @@
         pGVM->nemr0.s.IoCtlStopVirtualProcessor = Copy;
 
-    Copy = pVM->nem.s.IoCtlMessageSlotHandleAndGetNext;
+    Copy = pGVM->nem.s.IoCtlMessageSlotHandleAndGetNext;
     AssertLogRelStmt(Copy.uFunction != 0, rc = VERR_NEM_INIT_FAILED);
     AssertLogRelStmt(   Copy.cbInput == sizeof(VID_IOCTL_INPUT_MESSAGE_SLOT_HANDLE_AND_GET_NEXT)
@@ -336 +333 @@
 
     if (   RT_SUCCESS(rc)
-        || !pVM->nem.s.fUseRing0Runloop)
+        || !pGVM->nem.s.fUseRing0Runloop)
     {
         /*
          * Setup of an I/O control context for the partition handle for later use.
          */
-        rc = SUPR0IoCtlSetupForHandle(pGVM->pSession, pVM->nem.s.hPartitionDevice, 0, &pGVM->nemr0.s.pIoCtlCtx);
+        rc = SUPR0IoCtlSetupForHandle(pGVM->pSession, pGVM->nem.s.hPartitionDevice, 0, &pGVM->nemr0.s.pIoCtlCtx);
         AssertLogRelRCReturn(rc, rc);
         for (VMCPUID idCpu = 0; idCpu < pGVM->cCpus; idCpu++)
@@ -357 +354 @@
         AssertLogRelMsgReturn(NT_SUCCESS(rcNt), ("IoCtlGetHvPartitionId failed: %#x\n", rcNt), VERR_NEM_INIT_FAILED);
         pGVM->nemr0.s.idHvPartition = pVCpu0->nem.s.uIoCtlBuf.idPartition;
-        AssertLogRelMsgReturn(pGVM->nemr0.s.idHvPartition == pVM->nem.s.idHvPartition,
-                              ("idHvPartition mismatch: r0=%#RX64, r3=%#RX64\n", pGVM->nemr0.s.idHvPartition, pVM->nem.s.idHvPartition),
+        AssertLogRelMsgReturn(pGVM->nemr0.s.idHvPartition == pGVM->nem.s.idHvPartition,
+                              ("idHvPartition mismatch: r0=%#RX64, r3=%#RX64\n", pGVM->nemr0.s.idHvPartition, pGVM->nem.s.idHvPartition),
                               VERR_NEM_INIT_FAILED);
     }
@@ -424 +421 @@
  * Worker for NEMR0MapPages and others.
  */
-NEM_TMPL_STATIC int nemR0WinMapPages(PGVM pGVM, PVMCC pVM, PGVMCPU pGVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
+NEM_TMPL_STATIC int nemR0WinMapPages(PGVM pGVM, PGVMCPU pGVCpu, RTGCPHYS GCPhysSrc, RTGCPHYS GCPhysDst,
                                      uint32_t cPages, uint32_t fFlags)
 {
@@ -458 +455 @@
         {
             RTHCPHYS HCPhys = NIL_RTGCPHYS;
-            int rc = PGMPhysGCPhys2HCPhys(pVM, GCPhysSrc, &HCPhys);
+            int rc = PGMPhysGCPhys2HCPhys(pGVM, GCPhysSrc, &HCPhys);
             AssertRCReturn(rc, rc);
             pMapPages->PageList[iPage] = HCPhys >> X86_PAGE_SHIFT;
@@ -501 +498 @@
  * @returns VBox status code.
  * @param   pGVM            The ring-0 VM handle.
- * @param   pVM             The cross context VM handle.
  * @param   idCpu           The calling EMT.  Necessary for getting the
  *                          hypercall page and arguments.
  * @thread  EMT(idCpu)
  */
-VMMR0_INT_DECL(int) NEMR0MapPages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) NEMR0MapPages(PGVM pGVM, VMCPUID idCpu)
 {
     /*
      * Unpack the call.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
 
-        RTGCPHYS const          GCPhysSrc = pVCpu->nem.s.Hypercall.MapPages.GCPhysSrc;
-        RTGCPHYS const          GCPhysDst = pVCpu->nem.s.Hypercall.MapPages.GCPhysDst;
-        uint32_t const          cPages    = pVCpu->nem.s.Hypercall.MapPages.cPages;
-        HV_MAP_GPA_FLAGS const  fFlags    = pVCpu->nem.s.Hypercall.MapPages.fFlags;
+        RTGCPHYS const          GCPhysSrc = pGVCpu->nem.s.Hypercall.MapPages.GCPhysSrc;
+        RTGCPHYS const          GCPhysDst = pGVCpu->nem.s.Hypercall.MapPages.GCPhysDst;
+        uint32_t const          cPages    = pGVCpu->nem.s.Hypercall.MapPages.cPages;
+        HV_MAP_GPA_FLAGS const  fFlags    = pGVCpu->nem.s.Hypercall.MapPages.fFlags;
 
         /*
          * Do the work.
          */
-        rc = nemR0WinMapPages(pGVM, pVM, pGVCpu, GCPhysSrc, GCPhysDst, cPages, fFlags);
+        rc = nemR0WinMapPages(pGVM, pGVCpu, GCPhysSrc, GCPhysDst, cPages, fFlags);
     }
     return rc;
@@ -581 +576 @@
  * @returns VBox status code.
  * @param   pGVM            The ring-0 VM handle.
- * @param   pVM             The cross context VM handle.
  * @param   idCpu           The calling EMT.  Necessary for getting the
  *                          hypercall page and arguments.
  * @thread  EMT(idCpu)
  */
-VMMR0_INT_DECL(int) NEMR0UnmapPages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) NEMR0UnmapPages(PGVM pGVM, VMCPUID idCpu)
 {
     /*
      * Unpack the call.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
 
-        RTGCPHYS const GCPhys = pVCpu->nem.s.Hypercall.UnmapPages.GCPhys;
-        uint32_t const cPages = pVCpu->nem.s.Hypercall.UnmapPages.cPages;
+        RTGCPHYS const GCPhys = pGVCpu->nem.s.Hypercall.UnmapPages.GCPhys;
+        uint32_t const cPages = pGVCpu->nem.s.Hypercall.UnmapPages.cPages;
 
         /*
@@ -622 +615 @@
 NEM_TMPL_STATIC int nemR0WinExportState(PGVM pGVM, PGVMCPU pGVCpu, PCPUMCTX pCtx)
 {
-    PVMCPUCC                   pVCpu  = pGVCpu;
     HV_INPUT_SET_VP_REGISTERS *pInput = (HV_INPUT_SET_VP_REGISTERS *)pGVCpu->nemr0.s.HypercallData.pbPage;
     AssertPtrReturn(pInput, VERR_INTERNAL_ERROR_3);
@@ -633 +625 @@
     uint64_t const fWhat = ~pCtx->fExtrn & (CPUMCTX_EXTRN_ALL | CPUMCTX_EXTRN_NEM_WIN_MASK);
     if (   !fWhat
-        && pVCpu->nem.s.fCurrentInterruptWindows == pVCpu->nem.s.fDesiredInterruptWindows)
+        && pGVCpu->nem.s.fCurrentInterruptWindows == pGVCpu->nem.s.fDesiredInterruptWindows)
         return VINF_SUCCESS;
     uintptr_t iReg = 0;
@@ -867 +859 @@
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterCr8;
-        pInput->Elements[iReg].Value.Reg64          = CPUMGetGuestCR8(pVCpu);
+        pInput->Elements[iReg].Value.Reg64          = CPUMGetGuestCR8(pGVCpu);
         iReg++;
     }
@@ -879 +871 @@
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterDr0;
-        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR0(pVCpu);
+        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR0(pGVCpu);
         pInput->Elements[iReg].Value.Reg64          = pCtx->dr[0];
         iReg++;
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterDr1;
-        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR1(pVCpu);
+        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR1(pGVCpu);
         pInput->Elements[iReg].Value.Reg64          = pCtx->dr[1];
         iReg++;
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterDr2;
-        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR2(pVCpu);
+        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR2(pGVCpu);
         pInput->Elements[iReg].Value.Reg64          = pCtx->dr[2];
         iReg++;
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterDr3;
-        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR3(pVCpu);
+        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR3(pGVCpu);
         pInput->Elements[iReg].Value.Reg64          = pCtx->dr[3];
         iReg++;
@@ -902 +894 @@
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterDr6;
-        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR6(pVCpu);
+        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR6(pGVCpu);
         pInput->Elements[iReg].Value.Reg64          = pCtx->dr[6];
         iReg++;
@@ -910 +902 @@
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterDr7;
-        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR7(pVCpu);
+        //pInput->Elements[iReg].Value.Reg64        = CPUMGetHyperDR7(pGVCpu);
         pInput->Elements[iReg].Value.Reg64          = pCtx->dr[7];
         iReg++;
@@ -1120 +1112 @@
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterApicBase;
-        pInput->Elements[iReg].Value.Reg64          = APICGetBaseMsrNoCheck(pVCpu);
+        pInput->Elements[iReg].Value.Reg64          = APICGetBaseMsrNoCheck(pGVCpu);
         iReg++;
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
@@ -1129 +1121 @@
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                 = HvX64RegisterMtrrCap;
-        pInput->Elements[iReg].Value.Reg64          = CPUMGetGuestIa32MtrrCap(pVCpu);
+        pInput->Elements[iReg].Value.Reg64          = CPUMGetGuestIa32MtrrCap(pGVCpu);
         iReg++;
 # endif
 
-        PCPUMCTXMSRS pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pVCpu);
+        PCPUMCTXMSRS pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pGVCpu);
 
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
@@ -1192 +1184 @@
 
 # if 0 /** @todo Why can't we write these on Intel systems? Not that we really care... */
-        const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM->pVM);
+        const CPUMCPUVENDOR enmCpuVendor = CPUMGetHostCpuVendor(pGVM);
         if (enmCpuVendor != CPUMCPUVENDOR_AMD)
         {
@@ -1201 +1193 @@
             HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
             pInput->Elements[iReg].Name                 = HvX64RegisterIa32FeatureControl;
-            pInput->Elements[iReg].Value.Reg64          = CPUMGetGuestIa32FeatureControl(pVCpu);
+            pInput->Elements[iReg].Value.Reg64          = CPUMGetGuestIa32FeatureControl(pGVCpu);
             iReg++;
         }
@@ -1224 +1216 @@
         pInput->Elements[iReg].Name                 = HvRegisterInterruptState;
         pInput->Elements[iReg].Value.Reg64          = 0;
-        if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
-            && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
+        if (   VMCPU_FF_IS_SET(pGVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
+            && EMGetInhibitInterruptsPC(pGVCpu) == pCtx->rip)
             pInput->Elements[iReg].Value.InterruptState.InterruptShadow = 1;
-        if (VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
+        if (VMCPU_FF_IS_SET(pGVCpu, VMCPU_FF_BLOCK_NMIS))
             pInput->Elements[iReg].Value.InterruptState.NmiMasked = 1;
         iReg++;
@@ -1233 +1225 @@
     else if (fWhat & CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT)
     {
-        if (   pVCpu->nem.s.fLastInterruptShadow
-            || (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
-                && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip))
+        if (   pGVCpu->nem.s.fLastInterruptShadow
+            || (   VMCPU_FF_IS_SET(pGVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
+                && EMGetInhibitInterruptsPC(pGVCpu) == pCtx->rip))
         {
             HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
             pInput->Elements[iReg].Name                 = HvRegisterInterruptState;
             pInput->Elements[iReg].Value.Reg64          = 0;
-            if (   VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
-                && EMGetInhibitInterruptsPC(pVCpu) == pCtx->rip)
+            if (   VMCPU_FF_IS_SET(pGVCpu, VMCPU_FF_INHIBIT_INTERRUPTS)
+                && EMGetInhibitInterruptsPC(pGVCpu) == pCtx->rip)
                 pInput->Elements[iReg].Value.InterruptState.InterruptShadow = 1;
             /** @todo Retrieve NMI state, currently assuming it's zero. (yes this may happen on I/O) */
-            //if (VMCPU_FF_IS_ANY_SET(pVCpu, VMCPU_FF_BLOCK_NMIS))
+            //if (VMCPU_FF_IS_ANY_SET(pGVCpu, VMCPU_FF_BLOCK_NMIS))
             //    pInput->Elements[iReg].Value.InterruptState.NmiMasked = 1;
             iReg++;
@@ -1253 +1245 @@
 
     /* Interrupt windows. Always set if active as Hyper-V seems to be forgetful. */
-    uint8_t const fDesiredIntWin = pVCpu->nem.s.fDesiredInterruptWindows;
+    uint8_t const fDesiredIntWin = pGVCpu->nem.s.fDesiredInterruptWindows;
     if (   fDesiredIntWin
-        || pVCpu->nem.s.fCurrentInterruptWindows != fDesiredIntWin)
-    {
-        pVCpu->nem.s.fCurrentInterruptWindows = pVCpu->nem.s.fDesiredInterruptWindows;
+        || pGVCpu->nem.s.fCurrentInterruptWindows != fDesiredIntWin)
+    {
+        pGVCpu->nem.s.fCurrentInterruptWindows = pGVCpu->nem.s.fDesiredInterruptWindows;
         HV_REGISTER_ASSOC_ZERO_PADDING_AND_HI64(&pInput->Elements[iReg]);
         pInput->Elements[iReg].Name                                         = HvX64RegisterDeliverabilityNotifications;
@@ -1296 +1288 @@
  * @returns VBox status code
  * @param   pGVM        The ring-0 VM handle.
- * @param   pVM         The cross context VM handle.
  * @param   idCpu       The calling EMT.  Necessary for getting the
  *                      hypercall page and arguments.
  */
-VMMR0_INT_DECL(int)  NEMR0ExportState(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int)  NEMR0ExportState(PGVM pGVM, VMCPUID idCpu)
 {
 #if defined(NEM_WIN_WITH_RING0_RUNLOOP) || defined(NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS)
@@ -1306 +1297 @@
      * Validate the call.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
         AssertReturn(g_pfnHvlInvokeHypercall, VERR_NEM_MISSING_KERNEL_API);
@@ -1316 +1306 @@
          * Call worker.
          */
-        rc = nemR0WinExportState(pGVM, pGVCpu, &pVCpu->cpum.GstCtx);
+        rc = nemR0WinExportState(pGVM, pGVCpu, &pGVCpu->cpum.GstCtx);
     }
     return rc;
 #else
-    RT_NOREF(pGVM, pVM, idCpu);
+    RT_NOREF(pGVM, idCpu);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -1576 +1566 @@
      * Copy information to the CPUM context.
      */
-    PVMCPUCC pVCpu = pGVCpu;
     iReg = 0;
 
@@ -1745 +1734 @@
             if (pCtx->cr0 != paValues[iReg].Reg64)
             {
-                CPUMSetGuestCR0(pVCpu, paValues[iReg].Reg64);
+                CPUMSetGuestCR0(pGVCpu, paValues[iReg].Reg64);
                 fMaybeChangedMode = true;
             }
@@ -1761 +1750 @@
             if (pCtx->cr3 != paValues[iReg].Reg64)
             {
-                CPUMSetGuestCR3(pVCpu, paValues[iReg].Reg64);
+                CPUMSetGuestCR3(pGVCpu, paValues[iReg].Reg64);
                 fUpdateCr3 = true;
             }
@@ -1771 +1760 @@
             if (pCtx->cr4 != paValues[iReg].Reg64)
             {
-                CPUMSetGuestCR4(pVCpu, paValues[iReg].Reg64);
+                CPUMSetGuestCR4(pGVCpu, paValues[iReg].Reg64);
                 fMaybeChangedMode = true;
             }
@@ -1780 +1769 @@
     {
         Assert(pInput->Names[iReg] == HvX64RegisterCr8);
-        APICSetTpr(pVCpu, (uint8_t)paValues[iReg].Reg64 << 4);
+        APICSetTpr(pGVCpu, (uint8_t)paValues[iReg].Reg64 << 4);
         iReg++;
     }
@@ -1789 +1778 @@
         Assert(pInput->Names[iReg] == HvX64RegisterDr7);
         if (pCtx->dr[7] != paValues[iReg].Reg64)
-            CPUMSetGuestDR7(pVCpu, paValues[iReg].Reg64);
+            CPUMSetGuestDR7(pGVCpu, paValues[iReg].Reg64);
         pCtx->fExtrn &= ~CPUMCTX_EXTRN_DR7; /* Hack alert! Avoids asserting when processing CPUMCTX_EXTRN_DR0_DR3. */
         iReg++;
@@ -1798 +1787 @@
         Assert(pInput->Names[iReg+3] == HvX64RegisterDr3);
         if (pCtx->dr[0] != paValues[iReg].Reg64)
-            CPUMSetGuestDR0(pVCpu, paValues[iReg].Reg64);
+            CPUMSetGuestDR0(pGVCpu, paValues[iReg].Reg64);
         iReg++;
         if (pCtx->dr[1] != paValues[iReg].Reg64)
-            CPUMSetGuestDR1(pVCpu, paValues[iReg].Reg64);
+            CPUMSetGuestDR1(pGVCpu, paValues[iReg].Reg64);
         iReg++;
         if (pCtx->dr[2] != paValues[iReg].Reg64)
-            CPUMSetGuestDR2(pVCpu, paValues[iReg].Reg64);
+            CPUMSetGuestDR2(pGVCpu, paValues[iReg].Reg64);
         iReg++;
         if (pCtx->dr[3] != paValues[iReg].Reg64)
-            CPUMSetGuestDR3(pVCpu, paValues[iReg].Reg64);
+            CPUMSetGuestDR3(pGVCpu, paValues[iReg].Reg64);
         iReg++;
     }
@@ -1814 +1803 @@
         Assert(pInput->Names[iReg] == HvX64RegisterDr6);
         if (pCtx->dr[6] != paValues[iReg].Reg64)
-            CPUMSetGuestDR6(pVCpu, paValues[iReg].Reg64);
+            CPUMSetGuestDR6(pGVCpu, paValues[iReg].Reg64);
         iReg++;
     }
@@ -1937 +1926 @@
         if (paValues[iReg].Reg64 != pCtx->msrEFER)
         {
-            Log7(("NEM/%u: MSR EFER changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrEFER, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR EFER changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrEFER, paValues[iReg].Reg64));
             if ((paValues[iReg].Reg64 ^ pCtx->msrEFER) & MSR_K6_EFER_NXE)
-                PGMNotifyNxeChanged(pVCpu, RT_BOOL(paValues[iReg].Reg64 & MSR_K6_EFER_NXE));
+                PGMNotifyNxeChanged(pGVCpu, RT_BOOL(paValues[iReg].Reg64 & MSR_K6_EFER_NXE));
             pCtx->msrEFER = paValues[iReg].Reg64;
             fMaybeChangedMode = true;
@@ -1949 +1938 @@
         Assert(pInput->Names[iReg] == HvX64RegisterKernelGsBase);
         if (pCtx->msrKERNELGSBASE != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR KERNELGSBASE changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrKERNELGSBASE, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR KERNELGSBASE changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrKERNELGSBASE, paValues[iReg].Reg64));
         pCtx->msrKERNELGSBASE = paValues[iReg].Reg64;
         iReg++;
@@ -1957 +1946 @@
         Assert(pInput->Names[iReg] == HvX64RegisterSysenterCs);
         if (pCtx->SysEnter.cs != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR SYSENTER.CS changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->SysEnter.cs, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR SYSENTER.CS changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->SysEnter.cs, paValues[iReg].Reg64));
         pCtx->SysEnter.cs = paValues[iReg].Reg64;
         iReg++;
@@ -1963 +1952 @@
         Assert(pInput->Names[iReg] == HvX64RegisterSysenterEip);
         if (pCtx->SysEnter.eip != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR SYSENTER.EIP changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->SysEnter.eip, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR SYSENTER.EIP changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->SysEnter.eip, paValues[iReg].Reg64));
         pCtx->SysEnter.eip = paValues[iReg].Reg64;
         iReg++;
@@ -1969 +1958 @@
         Assert(pInput->Names[iReg] == HvX64RegisterSysenterEsp);
         if (pCtx->SysEnter.esp != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR SYSENTER.ESP changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->SysEnter.esp, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR SYSENTER.ESP changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->SysEnter.esp, paValues[iReg].Reg64));
         pCtx->SysEnter.esp = paValues[iReg].Reg64;
         iReg++;
@@ -1977 +1966 @@
         Assert(pInput->Names[iReg] == HvX64RegisterStar);
         if (pCtx->msrSTAR != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR STAR changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrSTAR, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR STAR changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrSTAR, paValues[iReg].Reg64));
         pCtx->msrSTAR   = paValues[iReg].Reg64;
         iReg++;
@@ -1983 +1972 @@
         Assert(pInput->Names[iReg] == HvX64RegisterLstar);
         if (pCtx->msrLSTAR != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR LSTAR changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrLSTAR, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR LSTAR changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrLSTAR, paValues[iReg].Reg64));
         pCtx->msrLSTAR  = paValues[iReg].Reg64;
         iReg++;
@@ -1989 +1978 @@
         Assert(pInput->Names[iReg] == HvX64RegisterCstar);
         if (pCtx->msrCSTAR != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR CSTAR changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrCSTAR, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR CSTAR changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrCSTAR, paValues[iReg].Reg64));
         pCtx->msrCSTAR  = paValues[iReg].Reg64;
         iReg++;
@@ -1995 +1984 @@
         Assert(pInput->Names[iReg] == HvX64RegisterSfmask);
         if (pCtx->msrSFMASK != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR SFMASK changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrSFMASK, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR SFMASK changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrSFMASK, paValues[iReg].Reg64));
         pCtx->msrSFMASK = paValues[iReg].Reg64;
         iReg++;
@@ -2002 +1991 @@
     {
         Assert(pInput->Names[iReg] == HvX64RegisterApicBase);
-        const uint64_t uOldBase = APICGetBaseMsrNoCheck(pVCpu);
+        const uint64_t uOldBase = APICGetBaseMsrNoCheck(pGVCpu);
         if (paValues[iReg].Reg64 != uOldBase)
         {
             Log7(("NEM/%u: MSR APICBase changed %RX64 -> %RX64 (%RX64)\n",
-                  pVCpu->idCpu, uOldBase, paValues[iReg].Reg64, paValues[iReg].Reg64 ^ uOldBase));
-            int rc2 = APICSetBaseMsr(pVCpu, paValues[iReg].Reg64);
+                  pGVCpu->idCpu, uOldBase, paValues[iReg].Reg64, paValues[iReg].Reg64 ^ uOldBase));
+            int rc2 = APICSetBaseMsr(pGVCpu, paValues[iReg].Reg64);
             AssertLogRelMsg(rc2 == VINF_SUCCESS, ("rc2=%Rrc [%#RX64]\n", rc2, paValues[iReg].Reg64));
         }
@@ -2014 +2003 @@
         Assert(pInput->Names[iReg] == HvX64RegisterPat);
         if (pCtx->msrPAT != paValues[iReg].Reg64)
-            Log7(("NEM/%u: MSR PAT changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtx->msrPAT, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR PAT changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtx->msrPAT, paValues[iReg].Reg64));
         pCtx->msrPAT    = paValues[iReg].Reg64;
         iReg++;
@@ -2020 +2009 @@
 # if 0 /*def LOG_ENABLED*/ /** @todo something's wrong with HvX64RegisterMtrrCap? (AMD) */
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrCap);
-        if (paValues[iReg].Reg64 != CPUMGetGuestIa32MtrrCap(pVCpu))
-            Log7(("NEM/%u: MSR MTRR_CAP changed %RX64 -> %RX64 (!!)\n", pVCpu->idCpu, CPUMGetGuestIa32MtrrCap(pVCpu), paValues[iReg].Reg64));
+        if (paValues[iReg].Reg64 != CPUMGetGuestIa32MtrrCap(pGVCpu))
+            Log7(("NEM/%u: MSR MTRR_CAP changed %RX64 -> %RX64 (!!)\n", pGVCpu->idCpu, CPUMGetGuestIa32MtrrCap(pGVCpu), paValues[iReg].Reg64));
         iReg++;
 # endif
 
-        PCPUMCTXMSRS pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pVCpu);
+        PCPUMCTXMSRS pCtxMsrs = CPUMQueryGuestCtxMsrsPtr(pGVCpu);
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrDefType);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrDefType )
-            Log7(("NEM/%u: MSR MTRR_DEF_TYPE changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrDefType, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_DEF_TYPE changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrDefType, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrDefType = paValues[iReg].Reg64;
         iReg++;
@@ -2036 +2025 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix64k00000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix64K_00000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_00000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix64K_00000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_00000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix64K_00000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix64K_00000 = paValues[iReg].Reg64;
         iReg++;
@@ -2042 +2031 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix16k80000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix16K_80000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_80000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix16K_80000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_80000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix16K_80000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix16K_80000 = paValues[iReg].Reg64;
         iReg++;
@@ -2048 +2037 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix16kA0000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix16K_A0000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_A0000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix16K_A0000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_A0000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix16K_A0000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix16K_A0000 = paValues[iReg].Reg64;
         iReg++;
@@ -2054 +2043 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kC0000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_C0000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_C0000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_C0000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_C0000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_C0000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_C0000 = paValues[iReg].Reg64;
         iReg++;
@@ -2060 +2049 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kC8000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_C8000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_C8000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_C8000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_C8000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_C8000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_C8000 = paValues[iReg].Reg64;
         iReg++;
@@ -2066 +2055 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kD0000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_D0000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_D0000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_D0000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_D0000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_D0000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_D0000 = paValues[iReg].Reg64;
         iReg++;
@@ -2072 +2061 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kD8000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_D8000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_D8000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_D8000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_D8000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_D8000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_D8000 = paValues[iReg].Reg64;
         iReg++;
@@ -2078 +2067 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kE0000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_E0000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_E0000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_E0000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_E0000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_E0000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_E0000 = paValues[iReg].Reg64;
         iReg++;
@@ -2084 +2073 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kE8000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_E8000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_E8000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_E8000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_E8000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_E8000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_E8000 = paValues[iReg].Reg64;
         iReg++;
@@ -2090 +2079 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kF0000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_F0000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_F0000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_F0000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_F0000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_F0000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_F0000 = paValues[iReg].Reg64;
         iReg++;
@@ -2096 +2085 @@
         Assert(pInput->Names[iReg] == HvX64RegisterMtrrFix4kF8000);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.MtrrFix4K_F8000 )
-            Log7(("NEM/%u: MSR MTRR_FIX16K_F8000 changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_F8000, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR MTRR_FIX16K_F8000 changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MtrrFix4K_F8000, paValues[iReg].Reg64));
         pCtxMsrs->msr.MtrrFix4K_F8000 = paValues[iReg].Reg64;
         iReg++;
@@ -2102 +2091 @@
         Assert(pInput->Names[iReg] == HvX64RegisterTscAux);
         if (paValues[iReg].Reg64 != pCtxMsrs->msr.TscAux )
-            Log7(("NEM/%u: MSR TSC_AUX changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.TscAux, paValues[iReg].Reg64));
+            Log7(("NEM/%u: MSR TSC_AUX changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.TscAux, paValues[iReg].Reg64));
         pCtxMsrs->msr.TscAux = paValues[iReg].Reg64;
         iReg++;
@@ -2111 +2100 @@
             Assert(pInput->Names[iReg] == HvX64RegisterIa32MiscEnable);
             if (paValues[iReg].Reg64 != pCtxMsrs->msr.MiscEnable)
-                Log7(("NEM/%u: MSR MISC_ENABLE changed %RX64 -> %RX64\n", pVCpu->idCpu, pCtxMsrs->msr.MiscEnable, paValues[iReg].Reg64));
+                Log7(("NEM/%u: MSR MISC_ENABLE changed %RX64 -> %RX64\n", pGVCpu->idCpu, pCtxMsrs->msr.MiscEnable, paValues[iReg].Reg64));
             pCtxMsrs->msr.MiscEnable = paValues[iReg].Reg64;
             iReg++;
@@ -2121 +2110 @@
             Assert(pInput->Names[iReg] == HvX64RegisterIa32FeatureControl);
             if (paValues[iReg].Reg64 != pCtx->hwvirt.vmx.Msrs.u64FeatCtrl)
-                Log7(("NEM/%u: MSR FEATURE_CONTROL changed %RX64 -> %RX64 (!!)\n", pVCpu->idCpu, pCtx->hwvirt.vmx.Msrs.u64FeatCtrl, paValues[iReg].Reg64));
+                Log7(("NEM/%u: MSR FEATURE_CONTROL changed %RX64 -> %RX64 (!!)\n", pGVCpu->idCpu, pCtx->hwvirt.vmx.Msrs.u64FeatCtrl, paValues[iReg].Reg64));
             iReg++;
         }
@@ -2135 +2124 @@
         if (!(pCtx->fExtrn & CPUMCTX_EXTRN_NEM_WIN_INHIBIT_INT))
         {
-            pVCpu->nem.s.fLastInterruptShadow = paValues[iReg].InterruptState.InterruptShadow;
+            pGVCpu->nem.s.fLastInterruptShadow = paValues[iReg].InterruptState.InterruptShadow;
             if (paValues[iReg].InterruptState.InterruptShadow)
-                EMSetInhibitInterruptsPC(pVCpu, paValues[iReg + 1].Reg64);
+                EMSetInhibitInterruptsPC(pGVCpu, paValues[iReg + 1].Reg64);
             else
-                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
+                VMCPU_FF_CLEAR(pGVCpu, VMCPU_FF_INHIBIT_INTERRUPTS);
         }
 
@@ -2145 +2134 @@
         {
             if (paValues[iReg].InterruptState.NmiMasked)
-                VMCPU_FF_SET(pVCpu, VMCPU_FF_BLOCK_NMIS);
+                VMCPU_FF_SET(pGVCpu, VMCPU_FF_BLOCK_NMIS);
             else
-                VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_BLOCK_NMIS);
+                VMCPU_FF_CLEAR(pGVCpu, VMCPU_FF_BLOCK_NMIS);
         }
 
@@ -2185 +2174 @@
     if (fMaybeChangedMode)
     {
-        rc = PGMChangeMode(pVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
+        rc = PGMChangeMode(pGVCpu, pCtx->cr0, pCtx->cr4, pCtx->msrEFER);
         AssertMsgReturn(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc), RT_FAILURE_NP(rc) ? rc : VERR_NEM_IPE_1);
     }
@@ -2194 +2183 @@
         {
             LogFlow(("nemR0WinImportState: -> PGMUpdateCR3!\n"));
-            rc = PGMUpdateCR3(pVCpu, pCtx->cr3);
+            rc = PGMUpdateCR3(pGVCpu, pCtx->cr3);
             AssertMsgReturn(rc == VINF_SUCCESS, ("rc=%Rrc\n", rc), RT_FAILURE_NP(rc) ? rc : VERR_NEM_IPE_2);
         }
@@ -2214 +2203 @@
  * @returns VBox status code
  * @param   pGVM        The ring-0 VM handle.
- * @param   pVM         The cross context VM handle.
  * @param   idCpu       The calling EMT.  Necessary for getting the
  *                      hypercall page and arguments.
@@ -2220 +2208 @@
  *                      CPUMCTX_EXTERN_ALL for everything.
  */
-VMMR0_INT_DECL(int) NEMR0ImportState(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint64_t fWhat)
+VMMR0_INT_DECL(int) NEMR0ImportState(PGVM pGVM, VMCPUID idCpu, uint64_t fWhat)
 {
 #if defined(NEM_WIN_WITH_RING0_RUNLOOP) || defined(NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS)
@@ -2226 +2214 @@
      * Validate the call.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
         AssertReturn(g_pfnHvlInvokeHypercall, VERR_NEM_MISSING_KERNEL_API);
@@ -2236 +2223 @@
          * Call worker.
          */
-        rc = nemR0WinImportState(pGVM, pGVCpu, &pVCpu->cpum.GstCtx, fWhat, false /*fCanUpdateCr3*/);
+        rc = nemR0WinImportState(pGVM, pGVCpu, &pGVCpu->cpum.GstCtx, fWhat, false /*fCanUpdateCr3*/);
     }
     return rc;
 #else
-    RT_NOREF(pGVM, pVM, idCpu, fWhat);
+    RT_NOREF(pGVM, idCpu, fWhat);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -2300 +2287 @@
  * @returns VBox status code
  * @param   pGVM        The ring-0 VM handle.
- * @param   pVM         The cross context VM handle.
  * @param   idCpu       The calling EMT.  Necessary for getting the
  *                      hypercall page and arguments.
  */
-VMMR0_INT_DECL(int) NEMR0QueryCpuTick(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) NEMR0QueryCpuTick(PGVM pGVM, VMCPUID idCpu)
 {
 #if defined(NEM_WIN_WITH_RING0_RUNLOOP) || defined(NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS)
@@ -2310 +2296 @@
      * Validate the call.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
         AssertReturn(g_pfnHvlInvokeHypercall, VERR_NEM_MISSING_KERNEL_API);
@@ -2320 +2305 @@
          * Call worker.
          */
-        pVCpu->nem.s.Hypercall.QueryCpuTick.cTicks = 0;
-        pVCpu->nem.s.Hypercall.QueryCpuTick.uAux   = 0;
-        rc = nemR0WinQueryCpuTick(pGVM, pGVCpu, &pVCpu->nem.s.Hypercall.QueryCpuTick.cTicks,
-                                  &pVCpu->nem.s.Hypercall.QueryCpuTick.uAux);
+        pGVCpu->nem.s.Hypercall.QueryCpuTick.cTicks = 0;
+        pGVCpu->nem.s.Hypercall.QueryCpuTick.uAux   = 0;
+        rc = nemR0WinQueryCpuTick(pGVM, pGVCpu, &pGVCpu->nem.s.Hypercall.QueryCpuTick.cTicks,
+                                  &pGVCpu->nem.s.Hypercall.QueryCpuTick.uAux);
     }
     return rc;
 #else
-    RT_NOREF(pGVM, pVM, idCpu);
+    RT_NOREF(pGVM, idCpu);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -2409 +2394 @@
  * @returns VBox status code
  * @param   pGVM            The ring-0 VM handle.
- * @param   pVM             The cross context VM handle.
  * @param   idCpu           The calling EMT.  Necessary for getting the
  *                          hypercall page and arguments.
  * @param   uPausedTscValue The TSC value at the time of pausing.
  */
-VMMR0_INT_DECL(int) NEMR0ResumeCpuTickOnAll(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint64_t uPausedTscValue)
+VMMR0_INT_DECL(int) NEMR0ResumeCpuTickOnAll(PGVM pGVM, VMCPUID idCpu, uint64_t uPausedTscValue)
 {
 #if defined(NEM_WIN_WITH_RING0_RUNLOOP) || defined(NEM_WIN_USE_HYPERCALLS_FOR_REGISTERS)
@@ -2420 +2404 @@
      * Validate the call.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
         AssertReturn(g_pfnHvlInvokeHypercall, VERR_NEM_MISSING_KERNEL_API);
@@ -2430 +2413 @@
          * Call worker.
          */
-        pVCpu->nem.s.Hypercall.QueryCpuTick.cTicks = 0;
-        pVCpu->nem.s.Hypercall.QueryCpuTick.uAux   = 0;
+        pGVCpu->nem.s.Hypercall.QueryCpuTick.cTicks = 0;
+        pGVCpu->nem.s.Hypercall.QueryCpuTick.uAux   = 0;
         rc = nemR0WinResumeCpuTickOnAll(pGVM, pGVCpu, uPausedTscValue);
     }
     return rc;
 #else
-    RT_NOREF(pGVM, pVM, idCpu, uPausedTscValue);
+    RT_NOREF(pGVM, idCpu, uPausedTscValue);
     return VERR_NOT_IMPLEMENTED;
 #endif
@@ -2446 +2429 @@
 #ifdef NEM_WIN_WITH_RING0_RUNLOOP
     if (pGVM->nemr0.s.fMayUseRing0Runloop)
-        return nemHCWinRunGC(pGVM, &pGVM->aCpus[idCpu], pGVM, &pGVM->aCpus[idCpu]);
+        return nemHCWinRunGC(pGVM, &pGVM->aCpus[idCpu]);
     return VERR_NEM_RING3_ONLY;
 #else
@@ -2460 +2443 @@
  * @returns VBox status code.
  * @param   pGVM        The ring-0 VM handle.
- * @param   pVM         The cross context VM handle.
  * @param   idCpu       The calling EMT, or NIL.  Necessary for getting the hypercall
  *                      page and arguments.
  */
-VMMR0_INT_DECL(int)  NEMR0UpdateStatistics(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int)  NEMR0UpdateStatistics(PGVM pGVM, VMCPUID idCpu)
 {
     /*
@@ -2471 +2453 @@
     int rc;
     if (idCpu == NIL_VMCPUID)
-        rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+        rc = GVMMR0ValidateGVM(pGVM);
     else
-        rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+        rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
@@ -2506 +2488 @@
                 if (uResult == HV_STATUS_SUCCESS)
                 {
-                    pVM->nem.s.R0Stats.cPagesAvailable = pOutput->PagesAvailable;
-                    pVM->nem.s.R0Stats.cPagesInUse     = pOutput->PagesInUse;
+                    pGVM->nem.s.R0Stats.cPagesAvailable = pOutput->PagesAvailable;
+                    pGVM->nem.s.R0Stats.cPagesInUse     = pOutput->PagesInUse;
                     rc = VINF_SUCCESS;
                 }
@@ -2533 +2515 @@
  *
  * @param   pGVM        The ring-0 VM handle.
- * @param   pVM         The cross context VM handle.
  * @param   idCpu       The calling EMT.
  * @param   u64Arg      What to query.  0 == registers.
  */
-VMMR0_INT_DECL(int) NEMR0DoExperiment(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, uint64_t u64Arg)
+VMMR0_INT_DECL(int) NEMR0DoExperiment(PGVM pGVM, VMCPUID idCpu, uint64_t u64Arg)
 {
     /*
      * Resolve CPU structures.
      */
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
     if (RT_SUCCESS(rc))
     {
@@ -2548 +2529 @@
 
         PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
-        PVMCPUCC  pVCpu  = VMCC_GET_CPU(pVM, idCpu);
         if (u64Arg == 0)
         {
@@ -2564 +2544 @@
             pInput->VpIndex     = pGVCpu->idCpu;
             pInput->fFlags      = 0;
-            pInput->Names[0]    = (HV_REGISTER_NAME)pVCpu->nem.s.Hypercall.Experiment.uItem;
+            pInput->Names[0]    = (HV_REGISTER_NAME)pGVCpu->nem.s.Hypercall.Experiment.uItem;
 
             uint64_t uResult = g_pfnHvlInvokeHypercall(HV_MAKE_CALL_INFO(HvCallGetVpRegisters, 1),
                                                        pGVCpu->nemr0.s.HypercallData.HCPhysPage,
                                                        pGVCpu->nemr0.s.HypercallData.HCPhysPage + cbInput);
-            pVCpu->nem.s.Hypercall.Experiment.fSuccess = uResult == HV_MAKE_CALL_REP_RET(1);
-            pVCpu->nem.s.Hypercall.Experiment.uStatus  = uResult;
-            pVCpu->nem.s.Hypercall.Experiment.uLoValue = paValues[0].Reg128.Low64;
-            pVCpu->nem.s.Hypercall.Experiment.uHiValue = paValues[0].Reg128.High64;
+            pGVCpu->nem.s.Hypercall.Experiment.fSuccess = uResult == HV_MAKE_CALL_REP_RET(1);
+            pGVCpu->nem.s.Hypercall.Experiment.uStatus  = uResult;
+            pGVCpu->nem.s.Hypercall.Experiment.uLoValue = paValues[0].Reg128.Low64;
+            pGVCpu->nem.s.Hypercall.Experiment.uHiValue = paValues[0].Reg128.High64;
             rc = VINF_SUCCESS;
         }
@@ -2588 +2568 @@
 
             pInput->PartitionId  = pGVM->nemr0.s.idHvPartition;
-            pInput->PropertyCode = (HV_PARTITION_PROPERTY_CODE)pVCpu->nem.s.Hypercall.Experiment.uItem;
+            pInput->PropertyCode = (HV_PARTITION_PROPERTY_CODE)pGVCpu->nem.s.Hypercall.Experiment.uItem;
             pInput->uPadding     = 0;
 
@@ -2594 +2574 @@
                                                        pGVCpu->nemr0.s.HypercallData.HCPhysPage,
                                                        pGVCpu->nemr0.s.HypercallData.HCPhysPage + cbInput);
-            pVCpu->nem.s.Hypercall.Experiment.fSuccess = uResult == HV_STATUS_SUCCESS;
-            pVCpu->nem.s.Hypercall.Experiment.uStatus  = uResult;
-            pVCpu->nem.s.Hypercall.Experiment.uLoValue = pOutput->PropertyValue;
-            pVCpu->nem.s.Hypercall.Experiment.uHiValue = 0;
+            pGVCpu->nem.s.Hypercall.Experiment.fSuccess = uResult == HV_STATUS_SUCCESS;
+            pGVCpu->nem.s.Hypercall.Experiment.uStatus  = uResult;
+            pGVCpu->nem.s.Hypercall.Experiment.uLoValue = pOutput->PropertyValue;
+            pGVCpu->nem.s.Hypercall.Experiment.uHiValue = 0;
             rc = VINF_SUCCESS;
         }
@@ -2612 +2592 @@
             pInput->VpIndex     = pGVCpu->idCpu;
             pInput->RsvdZ      = 0;
-            pInput->Elements[0].Name = (HV_REGISTER_NAME)pVCpu->nem.s.Hypercall.Experiment.uItem;
-            pInput->Elements[0].Value.Reg128.High64 = pVCpu->nem.s.Hypercall.Experiment.uHiValue;
-            pInput->Elements[0].Value.Reg128.Low64  = pVCpu->nem.s.Hypercall.Experiment.uLoValue;
+            pInput->Elements[0].Name = (HV_REGISTER_NAME)pGVCpu->nem.s.Hypercall.Experiment.uItem;
+            pInput->Elements[0].Value.Reg128.High64 = pGVCpu->nem.s.Hypercall.Experiment.uHiValue;
+            pInput->Elements[0].Value.Reg128.Low64  = pGVCpu->nem.s.Hypercall.Experiment.uLoValue;
 
             uint64_t uResult = g_pfnHvlInvokeHypercall(HV_MAKE_CALL_INFO(HvCallSetVpRegisters, 1),
                                                        pGVCpu->nemr0.s.HypercallData.HCPhysPage, 0);
-            pVCpu->nem.s.Hypercall.Experiment.fSuccess = uResult == HV_MAKE_CALL_REP_RET(1);
-            pVCpu->nem.s.Hypercall.Experiment.uStatus  = uResult;
+            pGVCpu->nem.s.Hypercall.Experiment.fSuccess = uResult == HV_MAKE_CALL_REP_RET(1);
+            pGVCpu->nem.s.Hypercall.Experiment.uStatus  = uResult;
             rc = VINF_SUCCESS;
         }

trunk/src/VBox/VMM/VMMR0/PDMR0Device.cpp

@@ -60 +60 @@
 *   Internal Functions                                                                                                           *
 *********************************************************************************************************************************/
-static bool pdmR0IsaSetIrq(PVMCC pVM, int iIrq, int iLevel, uint32_t uTagSrc);
+static bool pdmR0IsaSetIrq(PGVM pGVM, int iIrq, int iLevel, uint32_t uTagSrc);
 
 
@@ -132 +132 @@
     LogFlow(("pdmR0DevHlp_PCISetIrq: caller=%p/%d: pPciDev=%p:{%#x} iIrq=%d iLevel=%d\n",
              pDevIns, pDevIns->iInstance, pPciDev, pPciDev->uDevFn, iIrq, iLevel));
-    PVMCC        pVM     = pDevIns->Internal.s.pVMR0;
+    PGVM         pGVM    = pDevIns->Internal.s.pVMR0;
     PPDMPCIBUS   pPciBus = pPciDev->Int.s.pPdmBusR0;
 
-    pdmLock(pVM);
+    pdmLock(pGVM);
     uint32_t uTagSrc;
     if (iLevel & PDM_IRQ_LEVEL_HIGH)
     {
-        pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pVM, pDevIns->idTracing);
+        pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pGVM, pDevIns->idTracing);
         if (iLevel == PDM_IRQ_LEVEL_HIGH)
-            VBOXVMM_PDM_IRQ_HIGH(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+            VBOXVMM_PDM_IRQ_HIGH(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
         else
-            VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+            VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
     }
     else
@@ -153 +153 @@
         pPciBus->pfnSetIrqR0(pPciBus->pDevInsR0, pPciDev, iIrq, iLevel, uTagSrc);
 
-        pdmUnlock(pVM);
+        pdmUnlock(pGVM);
 
         if (iLevel == PDM_IRQ_LEVEL_LOW)
-            VBOXVMM_PDM_IRQ_LOW(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+            VBOXVMM_PDM_IRQ_LOW(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
     }
     else
     {
-        pdmUnlock(pVM);
+        pdmUnlock(pGVM);
 
         /* queue for ring-3 execution. */
-        PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)PDMQueueAlloc(pVM->pdm.s.pDevHlpQueueR0);
+        PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)PDMQueueAlloc(pGVM->pdm.s.pDevHlpQueueR0);
         AssertReturnVoid(pTask);
 
@@ -171 +171 @@
         pTask->u.PciSetIRQ.iLevel = iLevel;
         pTask->u.PciSetIRQ.uTagSrc = uTagSrc;
-        pTask->u.PciSetIRQ.pPciDevR3 = MMHyperR0ToR3(pVM, pPciDev);
-
-        PDMQueueInsertEx(pVM->pdm.s.pDevHlpQueueR0, &pTask->Core, 0);
+        pTask->u.PciSetIRQ.pPciDevR3 = MMHyperR0ToR3(pGVM, pPciDev);
+
+        PDMQueueInsertEx(pGVM->pdm.s.pDevHlpQueueR0, &pTask->Core, 0);
     }
 
@@ -185 +185 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: iIrq=%d iLevel=%d\n", pDevIns, pDevIns->iInstance, iIrq, iLevel));
-    PVMCC pVM = pDevIns->Internal.s.pVMR0;
-
-    pdmLock(pVM);
+    PGVM pGVM = pDevIns->Internal.s.pVMR0;
+
+    pdmLock(pGVM);
     uint32_t uTagSrc;
     if (iLevel & PDM_IRQ_LEVEL_HIGH)
     {
-        pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pVM, pDevIns->idTracing);
+        pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pGVM, pDevIns->idTracing);
         if (iLevel == PDM_IRQ_LEVEL_HIGH)
-            VBOXVMM_PDM_IRQ_HIGH(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+            VBOXVMM_PDM_IRQ_HIGH(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
         else
-            VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+            VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
     }
     else
         uTagSrc = pDevIns->Internal.s.uLastIrqTag;
 
-    bool fRc = pdmR0IsaSetIrq(pVM, iIrq, iLevel, uTagSrc);
+    bool fRc = pdmR0IsaSetIrq(pGVM, iIrq, iLevel, uTagSrc);
 
     if (iLevel == PDM_IRQ_LEVEL_LOW && fRc)
-        VBOXVMM_PDM_IRQ_LOW(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
-    pdmUnlock(pVM);
+        VBOXVMM_PDM_IRQ_LOW(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+    pdmUnlock(pGVM);
     LogFlow(("pdmR0DevHlp_ISASetIrq: caller=%p/%d: returns void; uTagSrc=%#x\n", pDevIns, pDevIns->iInstance, uTagSrc));
 }
@@ -214 +214 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     LogFlow(("pdmR0DevHlp_IoApicSendMsi: caller=%p/%d: GCPhys=%RGp uValue=%#x\n", pDevIns, pDevIns->iInstance, GCPhys, uValue));
-    PVMCC pVM = pDevIns->Internal.s.pVMR0;
+    PGVM pGVM = pDevIns->Internal.s.pVMR0;
 
     uint32_t uTagSrc;
-    pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pVM, pDevIns->idTracing);
-    VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
-
-    if (pVM->pdm.s.IoApic.pDevInsR0)
-        pVM->pdm.s.IoApic.pfnSendMsiR0(pVM->pdm.s.IoApic.pDevInsR0, GCPhys, uValue, uTagSrc);
+    pDevIns->Internal.s.uLastIrqTag = uTagSrc = pdmCalcIrqTag(pGVM, pDevIns->idTracing);
+    VBOXVMM_PDM_IRQ_HILO(VMMGetCpu(pGVM), RT_LOWORD(uTagSrc), RT_HIWORD(uTagSrc));
+
+    if (pGVM->pdm.s.IoApic.pDevInsR0)
+        pGVM->pdm.s.IoApic.pfnSendMsiR0(pGVM->pdm.s.IoApic.pDevInsR0, GCPhys, uValue, uTagSrc);
     else
         AssertFatalMsgFailed(("Lazy bastards!"));
@@ -518 +518 @@
 {
     PDMDEV_ASSERT_DEVINS(pDevIns);
-    PVMCC pVM = pDevIns->Internal.s.pVMR0;
+    PGVM pGVM = pDevIns->Internal.s.pVMR0;
     LogFlow(("pdmR0IoApicHlp_ApicBusDeliver: caller=%p/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 uVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8 uTagSrc=%#x\n",
              pDevIns, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, uVector, u8Polarity, u8TriggerMode, uTagSrc));
-    return APICBusDeliver(pVM, u8Dest, u8DestMode, u8DeliveryMode, uVector, u8Polarity, u8TriggerMode, uTagSrc);
+    return APICBusDeliver(pGVM, u8Dest, u8DestMode, u8DeliveryMode, uVector, u8Polarity, u8TriggerMode, uTagSrc);
 }
 
@@ -567 +567 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR0PciHlp_IsaSetIrq: iIrq=%d iLevel=%d uTagSrc=%#x\n", iIrq, iLevel, uTagSrc));
-    PVMCC pVM = pDevIns->Internal.s.pVMR0;
-
-    pdmLock(pVM);
-    pdmR0IsaSetIrq(pVM, iIrq, iLevel, uTagSrc);
-    pdmUnlock(pVM);
+    PGVM pGVM = pDevIns->Internal.s.pVMR0;
+
+    pdmLock(pGVM);
+    pdmR0IsaSetIrq(pGVM, iIrq, iLevel, uTagSrc);
+    pdmUnlock(pGVM);
 }
 
@@ -580 +580 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR0PciHlp_IoApicSetIrq: iIrq=%d iLevel=%d uTagSrc=%#x\n", iIrq, iLevel, uTagSrc));
-    PVMCC pVM = pDevIns->Internal.s.pVMR0;
-
-    if (pVM->pdm.s.IoApic.pDevInsR0)
-        pVM->pdm.s.IoApic.pfnSetIrqR0(pVM->pdm.s.IoApic.pDevInsR0, iIrq, iLevel, uTagSrc);
-    else if (pVM->pdm.s.IoApic.pDevInsR3)
+    PGVM pGVM = pDevIns->Internal.s.pVMR0;
+
+    if (pGVM->pdm.s.IoApic.pDevInsR0)
+        pGVM->pdm.s.IoApic.pfnSetIrqR0(pGVM->pdm.s.IoApic.pDevInsR0, iIrq, iLevel, uTagSrc);
+    else if (pGVM->pdm.s.IoApic.pDevInsR3)
     {
         /* queue for ring-3 execution. */
-        PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)PDMQueueAlloc(pVM->pdm.s.pDevHlpQueueR0);
+        PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)PDMQueueAlloc(pGVM->pdm.s.pDevHlpQueueR0);
         if (pTask)
         {
@@ -596 +596 @@
             pTask->u.IoApicSetIRQ.uTagSrc = uTagSrc;
 
-            PDMQueueInsertEx(pVM->pdm.s.pDevHlpQueueR0, &pTask->Core, 0);
+            PDMQueueInsertEx(pGVM->pdm.s.pDevHlpQueueR0, &pTask->Core, 0);
         }
         else
@@ -609 +609 @@
     PDMDEV_ASSERT_DEVINS(pDevIns);
     Log4(("pdmR0PciHlp_IoApicSendMsi: GCPhys=%p uValue=%d uTagSrc=%#x\n", GCPhys, uValue, uTagSrc));
-    PVMCC pVM = pDevIns->Internal.s.pVMR0;
-    if (pVM->pdm.s.IoApic.pDevInsR0)
-        pVM->pdm.s.IoApic.pfnSendMsiR0(pVM->pdm.s.IoApic.pDevInsR0, GCPhys, uValue, uTagSrc);
+    PGVM pGVM = pDevIns->Internal.s.pVMR0;
+    if (pGVM->pdm.s.IoApic.pDevInsR0)
+        pGVM->pdm.s.IoApic.pfnSendMsiR0(pGVM->pdm.s.IoApic.pDevInsR0, GCPhys, uValue, uTagSrc);
     else
         AssertFatalMsgFailed(("Lazy bastards!"));
@@ -784 +784 @@
  *
  * @returns true if delivered, false if postponed.
- * @param   pVM         The cross context VM structure.
+ * @param   pGVM        The global (ring-0) VM structure.
  * @param   iIrq        The irq.
  * @param   iLevel      The new level.
@@ -791 +791 @@
  * @remarks The caller holds the PDM lock.
  */
-static bool pdmR0IsaSetIrq(PVMCC pVM, int iIrq, int iLevel, uint32_t uTagSrc)
-{
-    if (RT_LIKELY(    (   pVM->pdm.s.IoApic.pDevInsR0
-                       || !pVM->pdm.s.IoApic.pDevInsR3)
-                  &&  (   pVM->pdm.s.Pic.pDevInsR0
-                       || !pVM->pdm.s.Pic.pDevInsR3)))
+static bool pdmR0IsaSetIrq(PGVM pGVM, int iIrq, int iLevel, uint32_t uTagSrc)
+{
+    if (RT_LIKELY(    (   pGVM->pdm.s.IoApic.pDevInsR0
+                       || !pGVM->pdm.s.IoApic.pDevInsR3)
+                  &&  (   pGVM->pdm.s.Pic.pDevInsR0
+                       || !pGVM->pdm.s.Pic.pDevInsR3)))
     {
-        if (pVM->pdm.s.Pic.pDevInsR0)
-            pVM->pdm.s.Pic.pfnSetIrqR0(pVM->pdm.s.Pic.pDevInsR0, iIrq, iLevel, uTagSrc);
-        if (pVM->pdm.s.IoApic.pDevInsR0)
-            pVM->pdm.s.IoApic.pfnSetIrqR0(pVM->pdm.s.IoApic.pDevInsR0, iIrq, iLevel, uTagSrc);
+        if (pGVM->pdm.s.Pic.pDevInsR0)
+            pGVM->pdm.s.Pic.pfnSetIrqR0(pGVM->pdm.s.Pic.pDevInsR0, iIrq, iLevel, uTagSrc);
+        if (pGVM->pdm.s.IoApic.pDevInsR0)
+            pGVM->pdm.s.IoApic.pfnSetIrqR0(pGVM->pdm.s.IoApic.pDevInsR0, iIrq, iLevel, uTagSrc);
         return true;
     }
 
     /* queue for ring-3 execution. */
-    PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)PDMQueueAlloc(pVM->pdm.s.pDevHlpQueueR0);
+    PPDMDEVHLPTASK pTask = (PPDMDEVHLPTASK)PDMQueueAlloc(pGVM->pdm.s.pDevHlpQueueR0);
     AssertReturn(pTask, false);
 
@@ -815 +815 @@
     pTask->u.IsaSetIRQ.uTagSrc = uTagSrc;
 
-    PDMQueueInsertEx(pVM->pdm.s.pDevHlpQueueR0, &pTask->Core, 0);
+    PDMQueueInsertEx(pGVM->pdm.s.pDevHlpQueueR0, &pTask->Core, 0);
     return false;
 }
@@ -825 +825 @@
  * @returns See PFNPDMDEVREQHANDLERR0.
  * @param   pGVM    The global (ring-0) VM structure. (For validation.)
- * @param   pVM     The cross context VM structure. (For validation.)
  * @param   pReq    Pointer to the request buffer.
  */
-VMMR0_INT_DECL(int) PDMR0DeviceCallReqHandler(PGVM pGVM, PVMCC pVM, PPDMDEVICECALLREQHANDLERREQ pReq)
+VMMR0_INT_DECL(int) PDMR0DeviceCallReqHandler(PGVM pGVM, PPDMDEVICECALLREQHANDLERREQ pReq)
 {
     /*
      * Validate input and make the call.
      */
-    int rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+    int rc = GVMMR0ValidateGVM(pGVM);
     if (RT_SUCCESS(rc))
     {
@@ -841 +840 @@
         PPDMDEVINS pDevIns = pReq->pDevInsR0;
         AssertPtrReturn(pDevIns, VERR_INVALID_POINTER);
-        AssertReturn(pDevIns->Internal.s.pVMR0 == pVM, VERR_INVALID_PARAMETER);
+        AssertReturn(pDevIns->Internal.s.pVMR0 == pGVM, VERR_INVALID_PARAMETER);
 
         PFNPDMDEVREQHANDLERR0 pfnReqHandlerR0 = pReq->pfnReqHandlerR0;

trunk/src/VBox/VMM/VMMR0/PDMR0Driver.cpp

@@ -37 +37 @@
  * @returns See PFNPDMDRVREQHANDLERR0.
  * @param   pGVM    The global (ring-0) VM structure. (For validation.)
- * @param   pVM     The cross context VM structure. (For validation.)
  * @param   pReq    Pointer to the request buffer.
  */
-VMMR0_INT_DECL(int) PDMR0DriverCallReqHandler(PGVM pGVM, PVMCC pVM, PPDMDRIVERCALLREQHANDLERREQ pReq)
+VMMR0_INT_DECL(int) PDMR0DriverCallReqHandler(PGVM pGVM, PPDMDRIVERCALLREQHANDLERREQ pReq)
 {
     /*
      * Validate input and make the call.
      */
-    int rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+    int rc = GVMMR0ValidateGVM(pGVM);
     if (RT_SUCCESS(rc))
     {
@@ -53 +52 @@
         PPDMDRVINS pDrvIns = pReq->pDrvInsR0;
         AssertPtrReturn(pDrvIns, VERR_INVALID_POINTER);
-        AssertReturn(pDrvIns->Internal.s.pVMR0 == pVM, VERR_INVALID_PARAMETER);
+        AssertReturn(pDrvIns->Internal.s.pVMR0 == pGVM, VERR_INVALID_PARAMETER);
 
         PFNPDMDRVREQHANDLERR0 pfnReqHandlerR0 = pDrvIns->Internal.s.pfnReqHandlerR0;

trunk/src/VBox/VMM/VMMR0/PGMR0.cpp

@@ -63 +63 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The ID of the calling EMT.
  *
@@ -71 +70 @@
  *          must clear the new pages.
  */
-VMMR0_INT_DECL(int) PGMR0PhysAllocateHandyPages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) PGMR0PhysAllocateHandyPages(PGVM pGVM, VMCPUID idCpu)
 {
     /*
@@ -78 +77 @@
     AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
     AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
-    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
+    PGM_LOCK_ASSERT_OWNER_EX(pGVM, &pGVM->aCpus[idCpu]);
 
     /*
      * Check for error injection.
      */
-    if (RT_UNLIKELY(pVM->pgm.s.fErrInjHandyPages))
+    if (RT_UNLIKELY(pGVM->pgm.s.fErrInjHandyPages))
         return VERR_NO_MEMORY;
 
@@ -89 +88 @@
      * Try allocate a full set of handy pages.
      */
-    uint32_t iFirst = pVM->pgm.s.cHandyPages;
-    AssertReturn(iFirst <= RT_ELEMENTS(pVM->pgm.s.aHandyPages), VERR_PGM_HANDY_PAGE_IPE);
-    uint32_t cPages = RT_ELEMENTS(pVM->pgm.s.aHandyPages) - iFirst;
+    uint32_t iFirst = pGVM->pgm.s.cHandyPages;
+    AssertReturn(iFirst <= RT_ELEMENTS(pGVM->pgm.s.aHandyPages), VERR_PGM_HANDY_PAGE_IPE);
+    uint32_t cPages = RT_ELEMENTS(pGVM->pgm.s.aHandyPages) - iFirst;
     if (!cPages)
         return VINF_SUCCESS;
-    int rc = GMMR0AllocateHandyPages(pGVM, pVM, idCpu, cPages, cPages, &pVM->pgm.s.aHandyPages[iFirst]);
+    int rc = GMMR0AllocateHandyPages(pGVM, idCpu, cPages, cPages, &pGVM->pgm.s.aHandyPages[iFirst]);
     if (RT_SUCCESS(rc))
     {
 #ifdef VBOX_STRICT
-        for (uint32_t i = 0; i < RT_ELEMENTS(pVM->pgm.s.aHandyPages); i++)
-        {
-            Assert(pVM->pgm.s.aHandyPages[i].idPage != NIL_GMM_PAGEID);
-            Assert(pVM->pgm.s.aHandyPages[i].idPage <= GMM_PAGEID_LAST);
-            Assert(pVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
-            Assert(pVM->pgm.s.aHandyPages[i].HCPhysGCPhys != NIL_RTHCPHYS);
-            Assert(!(pVM->pgm.s.aHandyPages[i].HCPhysGCPhys & ~X86_PTE_PAE_PG_MASK));
+        for (uint32_t i = 0; i < RT_ELEMENTS(pGVM->pgm.s.aHandyPages); i++)
+        {
+            Assert(pGVM->pgm.s.aHandyPages[i].idPage != NIL_GMM_PAGEID);
+            Assert(pGVM->pgm.s.aHandyPages[i].idPage <= GMM_PAGEID_LAST);
+            Assert(pGVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
+            Assert(pGVM->pgm.s.aHandyPages[i].HCPhysGCPhys != NIL_RTHCPHYS);
+            Assert(!(pGVM->pgm.s.aHandyPages[i].HCPhysGCPhys & ~X86_PTE_PAE_PG_MASK));
         }
 #endif
 
-        pVM->pgm.s.cHandyPages = RT_ELEMENTS(pVM->pgm.s.aHandyPages);
+        pGVM->pgm.s.cHandyPages = RT_ELEMENTS(pGVM->pgm.s.aHandyPages);
     }
     else if (rc != VERR_GMM_SEED_ME)
@@ -120 +119 @@
             /* We're ASSUMING that GMM has updated all the entires before failing us. */
             uint32_t i;
-            for (i = iFirst; i < RT_ELEMENTS(pVM->pgm.s.aHandyPages); i++)
+            for (i = iFirst; i < RT_ELEMENTS(pGVM->pgm.s.aHandyPages); i++)
             {
-                Assert(pVM->pgm.s.aHandyPages[i].idPage == NIL_GMM_PAGEID);
-                Assert(pVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
-                Assert(pVM->pgm.s.aHandyPages[i].HCPhysGCPhys == NIL_RTHCPHYS);
+                Assert(pGVM->pgm.s.aHandyPages[i].idPage == NIL_GMM_PAGEID);
+                Assert(pGVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
+                Assert(pGVM->pgm.s.aHandyPages[i].HCPhysGCPhys == NIL_RTHCPHYS);
             }
 #endif
@@ -136 +135 @@
                 if (cPages + iFirst < PGM_HANDY_PAGES_MIN)
                     cPages = PGM_HANDY_PAGES_MIN - iFirst;
-                rc = GMMR0AllocateHandyPages(pGVM, pVM, idCpu, 0, cPages, &pVM->pgm.s.aHandyPages[iFirst]);
+                rc = GMMR0AllocateHandyPages(pGVM, idCpu, 0, cPages, &pGVM->pgm.s.aHandyPages[iFirst]);
             } while (   (   rc == VERR_GMM_HIT_GLOBAL_LIMIT
                          || rc == VERR_GMM_HIT_VM_ACCOUNT_LIMIT)
@@ -146 +145 @@
                 while (i-- > 0)
                 {
-                    Assert(pVM->pgm.s.aHandyPages[i].idPage != NIL_GMM_PAGEID);
-                    Assert(pVM->pgm.s.aHandyPages[i].idPage <= GMM_PAGEID_LAST);
-                    Assert(pVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
-                    Assert(pVM->pgm.s.aHandyPages[i].HCPhysGCPhys != NIL_RTHCPHYS);
-                    Assert(!(pVM->pgm.s.aHandyPages[i].HCPhysGCPhys & ~X86_PTE_PAE_PG_MASK));
+                    Assert(pGVM->pgm.s.aHandyPages[i].idPage != NIL_GMM_PAGEID);
+                    Assert(pGVM->pgm.s.aHandyPages[i].idPage <= GMM_PAGEID_LAST);
+                    Assert(pGVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
+                    Assert(pGVM->pgm.s.aHandyPages[i].HCPhysGCPhys != NIL_RTHCPHYS);
+                    Assert(!(pGVM->pgm.s.aHandyPages[i].HCPhysGCPhys & ~X86_PTE_PAE_PG_MASK));
                 }
 
-                for (i = cPages + iFirst; i < RT_ELEMENTS(pVM->pgm.s.aHandyPages); i++)
+                for (i = cPages + iFirst; i < RT_ELEMENTS(pGVM->pgm.s.aHandyPages); i++)
                 {
-                    Assert(pVM->pgm.s.aHandyPages[i].idPage == NIL_GMM_PAGEID);
-                    Assert(pVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
-                    Assert(pVM->pgm.s.aHandyPages[i].HCPhysGCPhys == NIL_RTHCPHYS);
+                    Assert(pGVM->pgm.s.aHandyPages[i].idPage == NIL_GMM_PAGEID);
+                    Assert(pGVM->pgm.s.aHandyPages[i].idSharedPage == NIL_GMM_PAGEID);
+                    Assert(pGVM->pgm.s.aHandyPages[i].HCPhysGCPhys == NIL_RTHCPHYS);
                 }
 #endif
 
-                pVM->pgm.s.cHandyPages = iFirst + cPages;
+                pGVM->pgm.s.cHandyPages = iFirst + cPages;
             }
         }
@@ -168 +167 @@
         {
             LogRel(("PGMR0PhysAllocateHandyPages: rc=%Rrc iFirst=%d cPages=%d\n", rc, iFirst, cPages));
-            VM_FF_SET(pVM, VM_FF_PGM_NO_MEMORY);
+            VM_FF_SET(pGVM, VM_FF_PGM_NO_MEMORY);
         }
     }
@@ -187 +186 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The ID of the calling EMT.
  *
@@ -194 +192 @@
  * @remarks Must be called from within the PGM critical section.
  */
-VMMR0_INT_DECL(int) PGMR0PhysFlushHandyPages(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) PGMR0PhysFlushHandyPages(PGVM pGVM, VMCPUID idCpu)
 {
     /*
@@ -201 +199 @@
     AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
     AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
-    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
+    PGM_LOCK_ASSERT_OWNER_EX(pGVM, &pGVM->aCpus[idCpu]);
 
     /*
      * Try allocate a full set of handy pages.
      */
-    uint32_t iFirst = pVM->pgm.s.cHandyPages;
-    AssertReturn(iFirst <= RT_ELEMENTS(pVM->pgm.s.aHandyPages), VERR_PGM_HANDY_PAGE_IPE);
-    uint32_t cPages = RT_ELEMENTS(pVM->pgm.s.aHandyPages) - iFirst;
+    uint32_t iFirst = pGVM->pgm.s.cHandyPages;
+    AssertReturn(iFirst <= RT_ELEMENTS(pGVM->pgm.s.aHandyPages), VERR_PGM_HANDY_PAGE_IPE);
+    uint32_t cPages = RT_ELEMENTS(pGVM->pgm.s.aHandyPages) - iFirst;
     if (!cPages)
         return VINF_SUCCESS;
-    int rc = GMMR0AllocateHandyPages(pGVM, pVM, idCpu, cPages, 0, &pVM->pgm.s.aHandyPages[iFirst]);
+    int rc = GMMR0AllocateHandyPages(pGVM, idCpu, cPages, 0, &pGVM->pgm.s.aHandyPages[iFirst]);
 
     LogFlow(("PGMR0PhysFlushHandyPages: cPages=%d rc=%Rrc\n", cPages, rc));
@@ -226 +224 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The ID of the calling EMT.
  *
@@ -234 +231 @@
  *          must clear the new pages.
  */
-VMMR0_INT_DECL(int) PGMR0PhysAllocateLargeHandyPage(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) PGMR0PhysAllocateLargeHandyPage(PGVM pGVM, VMCPUID idCpu)
 {
     /*
@@ -241 +238 @@
     AssertReturn(idCpu < pGVM->cCpus, VERR_INVALID_CPU_ID); /* caller already checked this, but just to be sure. */
     AssertReturn(pGVM->aCpus[idCpu].hEMT == RTThreadNativeSelf(), VERR_NOT_OWNER);
-    PGM_LOCK_ASSERT_OWNER_EX(pVM, &pGVM->aCpus[idCpu]);
-    Assert(!pVM->pgm.s.cLargeHandyPages);
+    PGM_LOCK_ASSERT_OWNER_EX(pGVM, &pGVM->aCpus[idCpu]);
+    Assert(!pGVM->pgm.s.cLargeHandyPages);
 
     /*
      * Do the job.
      */
-    int rc = GMMR0AllocateLargePage(pGVM, pVM, idCpu, _2M,
-                                    &pVM->pgm.s.aLargeHandyPage[0].idPage,
-                                    &pVM->pgm.s.aLargeHandyPage[0].HCPhysGCPhys);
+    int rc = GMMR0AllocateLargePage(pGVM, idCpu, _2M,
+                                    &pGVM->pgm.s.aLargeHandyPage[0].idPage,
+                                    &pGVM->pgm.s.aLargeHandyPage[0].HCPhysGCPhys);
     if (RT_SUCCESS(rc))
-        pVM->pgm.s.cLargeHandyPages = 1;
+        pGVM->pgm.s.cLargeHandyPages = 1;
 
     return rc;
@@ -383 +380 @@
  *
  * @param   pGVM                The global (ring-0) VM structure.
- * @param   pVM                 The cross context VM structure.
- */
-VMMR0_INT_DECL(int) PGMR0PhysSetupIoMmu(PGVM pGVM, PVMCC pVM)
-{
-    int rc = GVMMR0ValidateGVMandVM(pGVM, pVM);
+ */
+VMMR0_INT_DECL(int) PGMR0PhysSetupIoMmu(PGVM pGVM)
+{
+    int rc = GVMMR0ValidateGVM(pGVM);
     if (RT_FAILURE(rc))
         return rc;
 
 #ifdef VBOX_WITH_PCI_PASSTHROUGH
-    if (pVM->pgm.s.fPciPassthrough)
+    if (pGVM->pgm.s.fPciPassthrough)
     {
         /*
@@ -398 +394 @@
          * IOMMU about each of them.
          */
-        pgmLock(pVM);
+        pgmLock(pGVM);
         rc = GPciRawR0GuestPageBeginAssignments(pGVM);
         if (RT_SUCCESS(rc))
         {
-            for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesXR0; RT_SUCCESS(rc) && pRam; pRam = pRam->pNextR0)
+            for (PPGMRAMRANGE pRam = pGVM->pgm.s.pRamRangesXR0; RT_SUCCESS(rc) && pRam; pRam = pRam->pNextR0)
             {
                 PPGMPAGE    pPage  = &pRam->aPages[0];
@@ -427 +423 @@
                 rc = rc2;
         }
-        pgmUnlock(pVM);
+        pgmUnlock(pGVM);
     }
     else
@@ -440 +436 @@
  *
  * @returns VBox status code (appropriate for trap handling and GC return).
- * @param   pVM                 The cross context VM structure.
- * @param   pVCpu               The cross context virtual CPU structure.
+ * @param   pGVM                The global (ring-0) VM structure.
+ * @param   pGVCpu              The global (ring-0) CPU structure of the calling
+ *                              EMT.
  * @param   enmShwPagingMode    Paging mode for the nested page tables.
  * @param   uErr                The trap error code.
@@ -447 +444 @@
  * @param   GCPhysFault         The fault address.
  */
-VMMR0DECL(int) PGMR0Trap0eHandlerNestedPaging(PVMCC pVM, PVMCPUCC pVCpu, PGMMODE enmShwPagingMode, RTGCUINT uErr,
+VMMR0DECL(int) PGMR0Trap0eHandlerNestedPaging(PGVM pGVM, PGVMCPU pGVCpu, PGMMODE enmShwPagingMode, RTGCUINT uErr,
                                               PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault)
 {
@@ -453 +450 @@
 
     LogFlow(("PGMTrap0eHandler: uErr=%RGx GCPhysFault=%RGp eip=%RGv\n", uErr, GCPhysFault, (RTGCPTR)pRegFrame->rip));
-    STAM_PROFILE_START(&pVCpu->pgm.s.StatRZTrap0e, a);
-    STAM_STATS({ pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = NULL; } );
+    STAM_PROFILE_START(&pGVCpu->pgm.s.StatRZTrap0e, a);
+    STAM_STATS({ pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = NULL; } );
 
     /* AMD uses the host's paging mode; Intel has a single mode (EPT). */
@@ -473 +470 @@
         {
             if (uErr & X86_TRAP_PF_RW)
-                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentWrite);
+                STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentWrite);
             else
-                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentRead);
+                STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNotPresentRead);
         }
         else if (uErr & X86_TRAP_PF_RW)
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSWrite);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSWrite);
         else if (uErr & X86_TRAP_PF_RSVD)
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSReserved);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSReserved);
         else if (uErr & X86_TRAP_PF_ID)
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNXE);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSNXE);
         else
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSRead);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eUSRead);
     }
     else
@@ -491 +488 @@
         {
             if (uErr & X86_TRAP_PF_RW)
-                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentWrite);
+                STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentWrite);
             else
-                STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentRead);
+                STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVNotPresentRead);
         }
         else if (uErr & X86_TRAP_PF_RW)
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVWrite);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVWrite);
         else if (uErr & X86_TRAP_PF_ID)
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSNXE);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSNXE);
         else if (uErr & X86_TRAP_PF_RSVD)
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVReserved);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eSVReserved);
     }
 #endif
@@ -515 +512 @@
     {
         case PGMMODE_32_BIT:
-            rc = PGM_BTH_NAME_32BIT_PROT(Trap0eHandler)(pVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
+            rc = PGM_BTH_NAME_32BIT_PROT(Trap0eHandler)(pGVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
             break;
         case PGMMODE_PAE:
         case PGMMODE_PAE_NX:
-            rc = PGM_BTH_NAME_PAE_PROT(Trap0eHandler)(pVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
+            rc = PGM_BTH_NAME_PAE_PROT(Trap0eHandler)(pGVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
             break;
         case PGMMODE_AMD64:
         case PGMMODE_AMD64_NX:
-            rc = PGM_BTH_NAME_AMD64_PROT(Trap0eHandler)(pVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
+            rc = PGM_BTH_NAME_AMD64_PROT(Trap0eHandler)(pGVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
             break;
         case PGMMODE_EPT:
-            rc = PGM_BTH_NAME_EPT_PROT(Trap0eHandler)(pVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
+            rc = PGM_BTH_NAME_EPT_PROT(Trap0eHandler)(pGVCpu, uErr, pRegFrame, GCPhysFault, &fLockTaken);
             break;
         default:
@@ -535 +532 @@
     if (fLockTaken)
     {
-        PGM_LOCK_ASSERT_OWNER(pVM);
-        pgmUnlock(pVM);
+        PGM_LOCK_ASSERT_OWNER(pGVM);
+        pgmUnlock(pGVM);
     }
 
@@ -556 +553 @@
     }
 
-    STAM_STATS({ if (!pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
-                    pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Misc; });
-    STAM_PROFILE_STOP_EX(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0e, pVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
+    STAM_STATS({ if (!pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution))
+                    pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution) = &pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0eTime2Misc; });
+    STAM_PROFILE_STOP_EX(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatRZTrap0e, pGVCpu->pgm.s.CTX_SUFF(pStatTrap0eAttribution), a);
     return rc;
 }
@@ -568 +565 @@
  *
  * @returns VBox status code (appropriate for trap handling and GC return).
- * @param   pVM                 The cross context VM structure.
- * @param   pVCpu               The cross context virtual CPU structure.
+ * @param   pGVM                The global (ring-0) VM structure.
+ * @param   pGVCpu              The global (ring-0) CPU structure of the calling
+ *                              EMT.
  * @param   enmShwPagingMode    Paging mode for the nested page tables.
  * @param   pRegFrame           Trap register frame.
@@ -576 +574 @@
  *                              (VT-x).
  */
-VMMR0DECL(VBOXSTRICTRC) PGMR0Trap0eHandlerNPMisconfig(PVMCC pVM, PVMCPUCC pVCpu, PGMMODE enmShwPagingMode,
+VMMR0DECL(VBOXSTRICTRC) PGMR0Trap0eHandlerNPMisconfig(PGVM pGVM, PGVMCPU pGVCpu, PGMMODE enmShwPagingMode,
                                                       PCPUMCTXCORE pRegFrame, RTGCPHYS GCPhysFault, uint32_t uErr)
 {
 #ifdef PGM_WITH_MMIO_OPTIMIZATIONS
-    STAM_PROFILE_START(&pVCpu->CTX_SUFF(pStats)->StatR0NpMiscfg, a);
+    STAM_PROFILE_START(&pGVCpu->CTX_SUFF(pStats)->StatR0NpMiscfg, a);
     VBOXSTRICTRC rc;
 
@@ -586 +584 @@
      * Try lookup the all access physical handler for the address.
      */
-    pgmLock(pVM);
-    PPGMPHYSHANDLER         pHandler     = pgmHandlerPhysicalLookup(pVM, GCPhysFault);
-    PPGMPHYSHANDLERTYPEINT  pHandlerType = RT_LIKELY(pHandler) ? PGMPHYSHANDLER_GET_TYPE(pVM, pHandler) : NULL;
+    pgmLock(pGVM);
+    PPGMPHYSHANDLER         pHandler     = pgmHandlerPhysicalLookup(pGVM, GCPhysFault);
+    PPGMPHYSHANDLERTYPEINT  pHandlerType = RT_LIKELY(pHandler) ? PGMPHYSHANDLER_GET_TYPE(pGVM, pHandler) : NULL;
     if (RT_LIKELY(pHandler && pHandlerType->enmKind != PGMPHYSHANDLERKIND_WRITE))
     {
@@ -599 +597 @@
         if (   (   pHandler->cAliasedPages
                 || pHandler->cTmpOffPages)
-            && (   (pPage = pgmPhysGetPage(pVM, GCPhysFault)) == NULL
+            && (   (pPage = pgmPhysGetPage(pGVM, GCPhysFault)) == NULL
                 || PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) == PGM_PAGE_HNDL_PHYS_STATE_DISABLED)
            )
         {
             Log(("PGMR0Trap0eHandlerNPMisconfig: Resyncing aliases / tmp-off page at %RGp (uErr=%#x) %R[pgmpage]\n", GCPhysFault, uErr, pPage));
-            STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
-            rc = pgmShwSyncNestedPageLocked(pVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
-            pgmUnlock(pVM);
+            STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
+            rc = pgmShwSyncNestedPageLocked(pGVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
+            pgmUnlock(pGVM);
         }
         else
@@ -614 +612 @@
                 void *pvUser = pHandler->CTX_SUFF(pvUser);
                 STAM_PROFILE_START(&pHandler->Stat, h);
-                pgmUnlock(pVM);
+                pgmUnlock(pGVM);
 
                 Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pHandlerType->CTX_SUFF(pfnPfHandler), uErr, GCPhysFault, pvUser));
-                rc = pHandlerType->CTX_SUFF(pfnPfHandler)(pVM, pVCpu, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame,
+                rc = pHandlerType->CTX_SUFF(pfnPfHandler)(pGVM, pGVCpu, uErr == UINT32_MAX ? RTGCPTR_MAX : uErr, pRegFrame,
                                                           GCPhysFault, GCPhysFault, pvUser);
 
 #ifdef VBOX_WITH_STATISTICS
-                pgmLock(pVM);
-                pHandler = pgmHandlerPhysicalLookup(pVM, GCPhysFault);
+                pgmLock(pGVM);
+                pHandler = pgmHandlerPhysicalLookup(pGVM, GCPhysFault);
                 if (pHandler)
                     STAM_PROFILE_STOP(&pHandler->Stat, h);
-                pgmUnlock(pVM);
+                pgmUnlock(pGVM);
 #endif
             }
             else
             {
-                pgmUnlock(pVM);
+                pgmUnlock(pGVM);
                 Log(("PGMR0Trap0eHandlerNPMisconfig: %RGp (uErr=%#x) -> R3\n", GCPhysFault, uErr));
                 rc = VINF_EM_RAW_EMULATE_INSTR;
@@ -645 +643 @@
          */
         Log(("PGMR0Trap0eHandlerNPMisconfig: Out of sync page at %RGp (uErr=%#x)\n", GCPhysFault, uErr));
-        STAM_COUNTER_INC(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
-        rc = pgmShwSyncNestedPageLocked(pVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
-        pgmUnlock(pVM);
-    }
-
-    STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfg, a);
+        STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
+        rc = pgmShwSyncNestedPageLocked(pGVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
+        pgmUnlock(pGVM);
+    }
+
+    STAM_PROFILE_STOP(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfg, a);
     return rc;
 

trunk/src/VBox/VMM/VMMR0/VMMR0.cpp

@@ -103 +103 @@
         } \
     } while (0)
-# define VMM_CHECK_SMAP_CHECK2(a_pVM, a_BadExpr) \
+# define VMM_CHECK_SMAP_CHECK2(a_pGVM, a_BadExpr) \
     do { \
         if (fKernelFeatures & SUPKERNELFEATURES_SMAP) \
@@ -110 +110 @@
             if (RT_LIKELY(fEflCheck & X86_EFL_AC)) \
             { /* likely */ } \
+            else if (a_pGVM) \
+            { \
+                SUPR0BadContext((a_pGVM)->pSession, __FILE__, __LINE__, "EFLAGS.AC is zero!"); \
+                RTStrPrintf((a_pGVM)->vmm.s.szRing0AssertMsg1, sizeof((a_pGVM)->vmm.s.szRing0AssertMsg1), \
+                            "%s, line %d: EFLAGS.AC is clear! (%#x)\n", __FUNCTION__, __LINE__, (uint32_t)fEflCheck); \
+                a_BadExpr; \
+            } \
             else \
             { \
-                SUPR0BadContext((a_pVM) ? (a_pVM)->pSession : NULL, __FILE__, __LINE__, "EFLAGS.AC is zero!"); \
-                RTStrPrintf(pVM->vmm.s.szRing0AssertMsg1, sizeof(pVM->vmm.s.szRing0AssertMsg1), \
-                            "%s, line %d: EFLAGS.AC is clear! (%#x)\n", __FUNCTION__, __LINE__, (uint32_t)fEflCheck); \
+                SUPR0Printf("%s, line %d: EFLAGS.AC is clear! (%#x)\n", __FUNCTION__, __LINE__, (uint32_t)fEflCheck); \
                 a_BadExpr; \
             } \
@@ -120 +125 @@
     } while (0)
 #else
-# define VMM_CHECK_SMAP_SETUP()            uint32_t const fKernelFeatures = 0
-# define VMM_CHECK_SMAP_CHECK(a_BadExpr)            NOREF(fKernelFeatures)
-# define VMM_CHECK_SMAP_CHECK2(a_pVM, a_BadExpr)    NOREF(fKernelFeatures)
+# define VMM_CHECK_SMAP_SETUP()                         uint32_t const fKernelFeatures = 0
+# define VMM_CHECK_SMAP_CHECK(a_BadExpr)                NOREF(fKernelFeatures)
+# define VMM_CHECK_SMAP_CHECK2(a_pGVM, a_BadExpr)       NOREF(fKernelFeatures)
 #endif
 
@@ -361 +366 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   uSvnRev     The SVN revision of the ring-3 part.
  * @param   uBuildType  Build type indicator.
  * @thread  EMT(0)
  */
-static int vmmR0InitVM(PGVM pGVM, PVMCC pVM, uint32_t uSvnRev, uint32_t uBuildType)
+static int vmmR0InitVM(PGVM pGVM, uint32_t uSvnRev, uint32_t uBuildType)
 {
     VMM_CHECK_SMAP_SETUP();
@@ -387 +391 @@
     }
 
-    int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, 0 /*idCpu*/);
+    int rc = GVMMR0ValidateGVMandEMT(pGVM, 0 /*idCpu*/);
     if (RT_FAILURE(rc))
         return rc;
@@ -395 +399 @@
      * Register the EMT R0 logger instance for VCPU 0.
      */
-    PVMCPUCC pVCpu = VMCC_GET_CPU_0(pVM);
+    PVMCPUCC pVCpu = VMCC_GET_CPU_0(pGVM);
 
     PVMMR0LOGGER pR0Logger = pVCpu->vmm.s.pR0LoggerR0;
@@ -406 +410 @@
         LogCom(("vmmR0InitVM: offScratch=%d fFlags=%#x fDestFlags=%#x\n", pR0Logger->Logger.offScratch, pR0Logger->Logger.fFlags, pR0Logger->Logger.fDestFlags));
 
-        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
+        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pGVM->pSession);
         LogCom(("vmmR0InitVM: after %p reg\n", RTLogDefaultInstance()));
-        RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
+        RTLogSetDefaultInstanceThread(NULL, pGVM->pSession);
         LogCom(("vmmR0InitVM: after %p dereg\n", RTLogDefaultInstance()));
 
@@ -416 +420 @@
         LogCom(("vmmR0InitVM: returned successfully from direct flush call.\n"));
 
-        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
+        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pGVM->pSession);
         LogCom(("vmmR0InitVM: after %p reg2\n", RTLogDefaultInstance()));
         pR0Logger->Logger.pfnLogger("hello ring-0 logger\n");
         LogCom(("vmmR0InitVM: returned successfully from direct logger call (2). offScratch=%d\n", pR0Logger->Logger.offScratch));
-        RTLogSetDefaultInstanceThread(NULL, pVM->pSession);
+        RTLogSetDefaultInstanceThread(NULL, pGVM->pSession);
         LogCom(("vmmR0InitVM: after %p dereg2\n", RTLogDefaultInstance()));
 
@@ -426 +430 @@
         LogCom(("vmmR0InitVM: RTLogLoggerEx returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
 
-        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
+        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pGVM->pSession);
         RTLogPrintf("hello ring-0 logger (RTLogPrintf)\n");
         LogCom(("vmmR0InitVM: RTLogPrintf returned fine offScratch=%d\n", pR0Logger->Logger.offScratch));
 # endif
-        Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pVM->pSession));
-        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
+        Log(("Switching to per-thread logging instance %p (key=%p)\n", &pR0Logger->Logger, pGVM->pSession));
+        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pGVM->pSession);
         pR0Logger->fRegistered = true;
     }
@@ -439 +443 @@
      * Check if the host supports high resolution timers or not.
      */
-    if (   pVM->vmm.s.fUsePeriodicPreemptionTimers
+    if (   pGVM->vmm.s.fUsePeriodicPreemptionTimers
         && !RTTimerCanDoHighResolution())
-        pVM->vmm.s.fUsePeriodicPreemptionTimers = false;
+        pGVM->vmm.s.fUsePeriodicPreemptionTimers = false;
 
     /*
      * Initialize the per VM data for GVMM and GMM.
      */
-    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
     rc = GVMMR0InitVM(pGVM);
-//    if (RT_SUCCESS(rc))
-//        rc = GMMR0InitPerVMData(pVM);
     if (RT_SUCCESS(rc))
     {
@@ -455 +457 @@
          * Init HM, CPUM and PGM (Darwin only).
          */
-        VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-        rc = HMR0InitVM(pVM);
+        VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+        rc = HMR0InitVM(pGVM);
         if (RT_SUCCESS(rc))
-            VMM_CHECK_SMAP_CHECK2(pVM, rc = VERR_VMM_RING0_ASSERTION); /* CPUR0InitVM will otherwise panic the host */
+            VMM_CHECK_SMAP_CHECK2(pGVM, rc = VERR_VMM_RING0_ASSERTION); /* CPUR0InitVM will otherwise panic the host */
         if (RT_SUCCESS(rc))
         {
-            rc = CPUMR0InitVM(pVM);
+            rc = CPUMR0InitVM(pGVM);
             if (RT_SUCCESS(rc))
             {
-                VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 #ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
-                rc = PGMR0DynMapInitVM(pVM);
+                rc = PGMR0DynMapInitVM(pGVM);
 #endif
                 if (RT_SUCCESS(rc))
                 {
-                    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                    VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
                     rc = EMR0InitVM(pGVM);
                     if (RT_SUCCESS(rc))
                     {
-                        VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                        VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 #ifdef VBOX_WITH_PCI_PASSTHROUGH
-                        rc = PciRawR0InitVM(pGVM, pVM);
+                        rc = PciRawR0InitVM(pGVM);
 #endif
                         if (RT_SUCCESS(rc))
                         {
-                            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-                            rc = GIMR0InitVM(pVM);
+                            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+                            rc = GIMR0InitVM(pGVM);
                             if (RT_SUCCESS(rc))
                             {
-                                VMM_CHECK_SMAP_CHECK2(pVM, rc = VERR_VMM_RING0_ASSERTION);
+                                VMM_CHECK_SMAP_CHECK2(pGVM, rc = VERR_VMM_RING0_ASSERTION);
                                 if (RT_SUCCESS(rc))
                                 {
@@ -492 +494 @@
                                      * Collect a bit of info for the VM release log.
                                      */
-                                    pVM->vmm.s.fIsPreemptPendingApiTrusty = RTThreadPreemptIsPendingTrusty();
-                                    pVM->vmm.s.fIsPreemptPossible         = RTThreadPreemptIsPossible();;
-
-                                    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                                    pGVM->vmm.s.fIsPreemptPendingApiTrusty = RTThreadPreemptIsPendingTrusty();
+                                    pGVM->vmm.s.fIsPreemptPossible         = RTThreadPreemptIsPossible();;
+
+                                    VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
                                     return rc;
                                 }
 
                                 /* bail out*/
-                                GIMR0TermVM(pVM);
+                                GIMR0TermVM(pGVM);
                             }
 #ifdef VBOX_WITH_PCI_PASSTHROUGH
-                            PciRawR0TermVM(pGVM, pVM);
+                            PciRawR0TermVM(pGVM);
 #endif
                         }
@@ -509 +511 @@
                 }
             }
-            HMR0TermVM(pVM);
+            HMR0TermVM(pGVM);
         }
     }
 
-    RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
+    RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pGVM->pSession);
     return rc;
 }
@@ -523 +525 @@
  * @returns VBox status code.
  * @param   pGVM        The ring-0 VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       The EMT that's calling.
  */
-static int vmmR0InitVMEmt(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+static int vmmR0InitVMEmt(PGVM pGVM, VMCPUID idCpu)
 {
     /* Paranoia (caller checked these already). */
@@ -541 +542 @@
         && !pR0Logger->fRegistered)
     {
-        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pVM->pSession);
+        RTLogSetDefaultInstanceThread(&pR0Logger->Logger, (uintptr_t)pGVM->pSession);
         pR0Logger->fRegistered = true;
     }
 #endif
-    RT_NOREF(pVM);
 
     return VINF_SUCCESS;
@@ -562 +562 @@
  *
  * @param   pGVM        The global (ring-0) VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   idCpu       Set to 0 if EMT(0) or NIL_VMCPUID if session cleanup
  *                      thread.
  * @thread  EMT(0) or session clean up thread.
  */
-VMMR0_INT_DECL(int) VMMR0TermVM(PGVM pGVM, PVMCC pVM, VMCPUID idCpu)
+VMMR0_INT_DECL(int) VMMR0TermVM(PGVM pGVM, VMCPUID idCpu)
 {
     /*
@@ -575 +574 @@
     {
         AssertReturn(idCpu == 0, VERR_INVALID_CPU_ID);
-        int rc = GVMMR0ValidateGVMandVMandEMT(pGVM, pVM, idCpu);
+        int rc = GVMMR0ValidateGVMandEMT(pGVM, idCpu);
         if (RT_FAILURE(rc))
             return rc;
@@ -581 +580 @@
 
 #ifdef VBOX_WITH_PCI_PASSTHROUGH
-    PciRawR0TermVM(pGVM, pVM);
+    PciRawR0TermVM(pGVM);
 #endif
 
@@ -589 +588 @@
     if (GVMMR0DoingTermVM(pGVM))
     {
-        GIMR0TermVM(pVM);
-
-        /** @todo I wish to call PGMR0PhysFlushHandyPages(pVM, &pVM->aCpus[idCpu])
+        GIMR0TermVM(pGVM);
+
+        /** @todo I wish to call PGMR0PhysFlushHandyPages(pGVM, &pGVM->aCpus[idCpu])
          *        here to make sure we don't leak any shared pages if we crash... */
 #ifdef VBOX_WITH_2X_4GB_ADDR_SPACE
-        PGMR0DynMapTermVM(pVM);
-#endif
-        HMR0TermVM(pVM);
+        PGMR0DynMapTermVM(pGVM);
+#endif
+        HMR0TermVM(pGVM);
     }
 
@@ -602 +601 @@
      * Deregister the logger.
      */
-    RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pVM->pSession);
+    RTLogSetDefaultInstanceThread(NULL, (uintptr_t)pGVM->pSession);
     return VINF_SUCCESS;
 }
@@ -707 +706 @@
  * @returns VINF_SUCCESS or VINF_EM_HALT.
  * @param   pGVM        The ring-0 VM structure.
- * @param   pVM         The cross context VM structure.
  * @param   pGVCpu      The ring-0 virtual CPU structure.
- * @param   pVCpu       The cross context virtual CPU structure.
  *
  * @todo r=bird: All the blocking/waiting and EMT managment should move out of
@@ -715 +712 @@
  *       parameters and statistics.
  */
-static int vmmR0DoHalt(PGVM pGVM, PVMCC pVM, PGVMCPU pGVCpu, PVMCPUCC pVCpu)
-{
-    Assert(pVCpu == pGVCpu);
-
+static int vmmR0DoHalt(PGVM pGVM, PGVMCPU pGVCpu)
+{
     /*
      * Do spin stat historization.
      */
-    if (++pVCpu->vmm.s.cR0Halts & 0xff)
+    if (++pGVCpu->vmm.s.cR0Halts & 0xff)
     { /* likely */ }
-    else if (pVCpu->vmm.s.cR0HaltsSucceeded > pVCpu->vmm.s.cR0HaltsToRing3)
-    {
-        pVCpu->vmm.s.cR0HaltsSucceeded = 2;
-        pVCpu->vmm.s.cR0HaltsToRing3   = 0;
+    else if (pGVCpu->vmm.s.cR0HaltsSucceeded > pGVCpu->vmm.s.cR0HaltsToRing3)
+    {
+        pGVCpu->vmm.s.cR0HaltsSucceeded = 2;
+        pGVCpu->vmm.s.cR0HaltsToRing3   = 0;
     }
     else
     {
-        pVCpu->vmm.s.cR0HaltsSucceeded = 0;
-        pVCpu->vmm.s.cR0HaltsToRing3   = 2;
+        pGVCpu->vmm.s.cR0HaltsSucceeded = 0;
+        pGVCpu->vmm.s.cR0HaltsToRing3   = 2;
     }
 
@@ -750 +745 @@
      * Check preconditions.
      */
-    unsigned const             uMWait              = EMMonitorWaitIsActive(pVCpu);
-    CPUMINTERRUPTIBILITY const enmInterruptibility = CPUMGetGuestInterruptibility(pVCpu);
-    if (   pVCpu->vmm.s.fMayHaltInRing0
-        && !TRPMHasTrap(pVCpu)
+    unsigned const             uMWait              = EMMonitorWaitIsActive(pGVCpu);
+    CPUMINTERRUPTIBILITY const enmInterruptibility = CPUMGetGuestInterruptibility(pGVCpu);
+    if (   pGVCpu->vmm.s.fMayHaltInRing0
+        && !TRPMHasTrap(pGVCpu)
         && (   enmInterruptibility == CPUMINTERRUPTIBILITY_UNRESTRAINED
             || uMWait > 1))
     {
-        if (   !VM_FF_IS_ANY_SET(pVM, fVmFFs)
-            && !VMCPU_FF_IS_ANY_SET(pVCpu, fCpuFFs))
+        if (   !VM_FF_IS_ANY_SET(pGVM, fVmFFs)
+            && !VMCPU_FF_IS_ANY_SET(pGVCpu, fCpuFFs))
         {
             /*
              * Interrupts pending already?
              */
-            if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
-                APICUpdatePendingInterrupts(pVCpu);
+            if (VMCPU_FF_TEST_AND_CLEAR(pGVCpu, VMCPU_FF_UPDATE_APIC))
+                APICUpdatePendingInterrupts(pGVCpu);
 
             /*
@@ -772 +767 @@
                                     | VMCPU_FF_INTERRUPT_NMI  | VMCPU_FF_INTERRUPT_SMI | VMCPU_FF_UNHALT;
 
-            if (VMCPU_FF_IS_ANY_SET(pVCpu, fIntMask))
-                return vmmR0DoHaltInterrupt(pVCpu, uMWait, enmInterruptibility);
+            if (VMCPU_FF_IS_ANY_SET(pGVCpu, fIntMask))
+                return vmmR0DoHaltInterrupt(pGVCpu, uMWait, enmInterruptibility);
             ASMNopPause();
 
@@ -780 +775 @@
              */
             uint64_t u64Delta;
-            uint64_t u64GipTime = TMTimerPollGIP(pVM, pVCpu, &u64Delta);
-
-            if (   !VM_FF_IS_ANY_SET(pVM, fVmFFs)
-                && !VMCPU_FF_IS_ANY_SET(pVCpu, fCpuFFs))
+            uint64_t u64GipTime = TMTimerPollGIP(pGVM, pGVCpu, &u64Delta);
+
+            if (   !VM_FF_IS_ANY_SET(pGVM, fVmFFs)
+                && !VMCPU_FF_IS_ANY_SET(pGVCpu, fCpuFFs))
             {
-                if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
-                    APICUpdatePendingInterrupts(pVCpu);
-
-                if (VMCPU_FF_IS_ANY_SET(pVCpu, fIntMask))
-                    return vmmR0DoHaltInterrupt(pVCpu, uMWait, enmInterruptibility);
+                if (VMCPU_FF_TEST_AND_CLEAR(pGVCpu, VMCPU_FF_UPDATE_APIC))
+                    APICUpdatePendingInterrupts(pGVCpu);
+
+                if (VMCPU_FF_IS_ANY_SET(pGVCpu, fIntMask))
+                    return vmmR0DoHaltInterrupt(pGVCpu, uMWait, enmInterruptibility);
 
                 /*
                  * Wait if there is enough time to the next timer event.
                  */
-                if (u64Delta >= pVCpu->vmm.s.cNsSpinBlockThreshold)
+                if (u64Delta >= pGVCpu->vmm.s.cNsSpinBlockThreshold)
                 {
                     /* If there are few other CPU cores around, we will procrastinate a
@@ -801 +796 @@
                        dynamically adjust the spin count according to its usfulness or
                        something... */
-                    if (   pVCpu->vmm.s.cR0HaltsSucceeded > pVCpu->vmm.s.cR0HaltsToRing3
+                    if (   pGVCpu->vmm.s.cR0HaltsSucceeded > pGVCpu->vmm.s.cR0HaltsToRing3
                         && RTMpGetOnlineCount() >= 4)
                     {
@@ -810 +805 @@
                         {
                             ASMNopPause();
-                            if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
-                                APICUpdatePendingInterrupts(pVCpu);
+                            if (VMCPU_FF_TEST_AND_CLEAR(pGVCpu, VMCPU_FF_UPDATE_APIC))
+                                APICUpdatePendingInterrupts(pGVCpu);
                             ASMNopPause();
-                            if (VM_FF_IS_ANY_SET(pVM, fVmFFs))
+                            if (VM_FF_IS_ANY_SET(pGVM, fVmFFs))
                             {
-                                STAM_REL_COUNTER_INC(&pVCpu->vmm.s.StatR0HaltToR3FromSpin);
+                                STAM_REL_COUNTER_INC(&pGVCpu->vmm.s.StatR0HaltToR3FromSpin);
                                 return VINF_EM_HALT;
                             }
                             ASMNopPause();
-                            if (VMCPU_FF_IS_ANY_SET(pVCpu, fCpuFFs))
+                            if (VMCPU_FF_IS_ANY_SET(pGVCpu, fCpuFFs))
                             {
-                                STAM_REL_COUNTER_INC(&pVCpu->vmm.s.StatR0HaltToR3FromSpin);
+                                STAM_REL_COUNTER_INC(&pGVCpu->vmm.s.StatR0HaltToR3FromSpin);
                                 return VINF_EM_HALT;
                             }
                             ASMNopPause();
-                            if (VMCPU_FF_IS_ANY_SET(pVCpu, fIntMask))
+                            if (VMCPU_FF_IS_ANY_SET(pGVCpu, fIntMask))
                             {
-                                STAM_REL_COUNTER_INC(&pVCpu->vmm.s.StatR0HaltExecFromSpin);
-                                return vmmR0DoHaltInterrupt(pVCpu, uMWait, enmInterruptibility);
+                                STAM_REL_COUNTER_INC(&pGVCpu->vmm.s.StatR0HaltExecFromSpin);
+                                return vmmR0DoHaltInterrupt(pGVCpu, uMWait, enmInterruptibility);
                             }
                             ASMNopPause();
@@ -836 +831 @@
                     /* Block.  We have to set the state to VMCPUSTATE_STARTED_HALTED here so ring-3
                        knows when to notify us (cannot access VMINTUSERPERVMCPU::fWait from here). */
-                    VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED_HALTED, VMCPUSTATE_STARTED);
+                    VMCPU_CMPXCHG_STATE(pGVCpu, VMCPUSTATE_STARTED_HALTED, VMCPUSTATE_STARTED);
                     uint64_t const u64StartSchedHalt   = RTTimeNanoTS();
-                    int rc = GVMMR0SchedHalt(pGVM, pVM, pGVCpu, u64GipTime);
+                    int rc = GVMMR0SchedHalt(pGVM, pGVCpu, u64GipTime);
                     uint64_t const u64EndSchedHalt     = RTTimeNanoTS();
                     uint64_t const cNsElapsedSchedHalt = u64EndSchedHalt - u64StartSchedHalt;
-                    VMCPU_CMPXCHG_STATE(pVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_HALTED);
-                    STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->vmm.s.StatR0HaltBlock, cNsElapsedSchedHalt);
+                    VMCPU_CMPXCHG_STATE(pGVCpu, VMCPUSTATE_STARTED, VMCPUSTATE_STARTED_HALTED);
+                    STAM_REL_PROFILE_ADD_PERIOD(&pGVCpu->vmm.s.StatR0HaltBlock, cNsElapsedSchedHalt);
                     if (   rc == VINF_SUCCESS
                         || rc == VERR_INTERRUPTED)
@@ -850 +845 @@
                         int64_t const cNsOverslept = u64EndSchedHalt - u64GipTime;
                         if (cNsOverslept > 50000)
-                            STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->vmm.s.StatR0HaltBlockOverslept, cNsOverslept);
+                            STAM_REL_PROFILE_ADD_PERIOD(&pGVCpu->vmm.s.StatR0HaltBlockOverslept, cNsOverslept);
                         else if (cNsOverslept < -50000)
-                            STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->vmm.s.StatR0HaltBlockInsomnia,  cNsElapsedSchedHalt);
+                            STAM_REL_PROFILE_ADD_PERIOD(&pGVCpu->vmm.s.StatR0HaltBlockInsomnia,  cNsElapsedSchedHalt);
                         else
-                            STAM_REL_PROFILE_ADD_PERIOD(&pVCpu->vmm.s.StatR0HaltBlockOnTime,    cNsElapsedSchedHalt);
+                            STAM_REL_PROFILE_ADD_PERIOD(&pGVCpu->vmm.s.StatR0HaltBlockOnTime,    cNsElapsedSchedHalt);
 
                         /*
                          * Recheck whether we can resume execution or have to go to ring-3.
                          */
-                        if (   !VM_FF_IS_ANY_SET(pVM, fVmFFs)
-                            && !VMCPU_FF_IS_ANY_SET(pVCpu, fCpuFFs))
+                        if (   !VM_FF_IS_ANY_SET(pGVM, fVmFFs)
+                            && !VMCPU_FF_IS_ANY_SET(pGVCpu, fCpuFFs))
                         {
-                            if (VMCPU_FF_TEST_AND_CLEAR(pVCpu, VMCPU_FF_UPDATE_APIC))
-                                APICUpdatePendingInterrupts(pVCpu);
-                            if (VMCPU_FF_IS_ANY_SET(pVCpu, fIntMask))
+                            if (VMCPU_FF_TEST_AND_CLEAR(pGVCpu, VMCPU_FF_UPDATE_APIC))
+                                APICUpdatePendingInterrupts(pGVCpu);
+                            if (VMCPU_FF_IS_ANY_SET(pGVCpu, fIntMask))
                             {
-                                STAM_REL_COUNTER_INC(&pVCpu->vmm.s.StatR0HaltExecFromBlock);
-                                return vmmR0DoHaltInterrupt(pVCpu, uMWait, enmInterruptibility);
+                                STAM_REL_COUNTER_INC(&pGVCpu->vmm.s.StatR0HaltExecFromBlock);
+                                return vmmR0DoHaltInterrupt(pGVCpu, uMWait, enmInterruptibility);
                             }
                         }
@@ -1068 +1063 @@
 /**
  * Record return code statistics
- * @param   pVM         The cross context VM structure.
+ * @param   pGVM        The cross context VM structure.
  * @param   pVCpu       The cross context virtual CPU structure.
  * @param   rc          The status code.
@@ -1273 +1268 @@
  *
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
- *                          The return code is stored in pVM->vmm.s.iLastGZRc.
+ * @param   pVMIgnored      The cross context VM structure. The return code is
+ *                          stored in pVM->vmm.s.iLastGZRc.
  * @param   idCpu           The Virtual CPU ID of the calling EMT.
  * @param   enmOperation    Which operation to execute.
  * @remarks Assume called with interrupts _enabled_.
  */
-VMMR0DECL(void) VMMR0EntryFast(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation)
-{
+VMMR0DECL(void) VMMR0EntryFast(PGVM pGVM, PVMCC pVMIgnored, VMCPUID idCpu, VMMR0OPERATION enmOperation)
+{
+    RT_NOREF(pVMIgnored);
+
     /*
      * Validation.
      */
     if (   idCpu < pGVM->cCpus
-        && pGVM->cCpus == pVM->cCpus)
+        && pGVM->cCpus == pGVM->cCpusUnsafe)
     { /*likely*/ }
     else
     {
-        SUPR0Printf("VMMR0EntryFast: Bad idCpu=%#x cCpus=%#x/%#x\n", idCpu, pGVM->cCpus, pVM->cCpus);
+        SUPR0Printf("VMMR0EntryFast: Bad idCpu=%#x cCpus=%#x cCpusUnsafe=%#x\n", idCpu, pGVM->cCpus, pGVM->cCpusUnsafe);
         return;
     }
 
-    PGVMCPU   pGVCpu = &pGVM->aCpus[idCpu];
-    PVMCPUCC  pVCpu  = pGVCpu;
+    PGVMCPU pGVCpu = &pGVM->aCpus[idCpu];
     RTNATIVETHREAD const hNativeThread = RTThreadNativeSelf();
-    if (RT_LIKELY(   pGVCpu->hEMT           == hNativeThread
-                  && pVCpu->hNativeThreadR0 == hNativeThread))
+    if (RT_LIKELY(   pGVCpu->hEMT            == hNativeThread
+                  && pGVCpu->hNativeThreadR0 == hNativeThread))
     { /* likely */ }
     else
     {
-        SUPR0Printf("VMMR0EntryFast: Bad thread idCpu=%#x hNativeSelf=%p pGVCpu->hEmt=%p pVCpu->hNativeThreadR0=%p\n",
-                    idCpu, hNativeThread, pGVCpu->hEMT, pVCpu->hNativeThreadR0);
+        SUPR0Printf("VMMR0EntryFast: Bad thread idCpu=%#x hNativeSelf=%p pGVCpu->hEmt=%p pGVCpu->hNativeThreadR0=%p\n",
+                    idCpu, hNativeThread, pGVCpu->hEMT, pGVCpu->hNativeThreadR0);
         return;
     }
@@ -1310 +1306 @@
      */
     VMM_CHECK_SMAP_SETUP();
-    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+    VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
     /*
@@ -1327 +1323 @@
                  * Disable preemption.
                  */
-                Assert(!vmmR0ThreadCtxHookIsEnabled(pVCpu));
+                Assert(!vmmR0ThreadCtxHookIsEnabled(pGVCpu));
                 RTTHREADPREEMPTSTATE PreemptState = RTTHREADPREEMPTSTATE_INITIALIZER;
                 RTThreadPreemptDisable(&PreemptState);
@@ -1340 +1336 @@
                               && SUPIsTscDeltaAvailableForCpuSetIndex(iHostCpuSet)))
                 {
-                    pVCpu->iHostCpuSet = iHostCpuSet;
-                    ASMAtomicWriteU32(&pVCpu->idHostCpu, idHostCpu);
+                    pGVCpu->iHostCpuSet = iHostCpuSet;
+                    ASMAtomicWriteU32(&pGVCpu->idHostCpu, idHostCpu);
 
                     /*
                      * Update the periodic preemption timer if it's active.
                      */
-                    if (pVM->vmm.s.fUsePeriodicPreemptionTimers)
-                        GVMMR0SchedUpdatePeriodicPreemptionTimer(pVM, pVCpu->idHostCpu, TMCalcHostTimerFrequency(pVM, pVCpu));
-                    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                    if (pGVM->vmm.s.fUsePeriodicPreemptionTimers)
+                        GVMMR0SchedUpdatePeriodicPreemptionTimer(pGVM, pGVCpu->idHostCpu, TMCalcHostTimerFrequency(pGVM, pGVCpu));
+                    VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
 #ifdef VMM_R0_TOUCH_FPU
@@ -1365 +1361 @@
                          * Enable the context switching hook.
                          */
-                        if (pVCpu->vmm.s.hCtxHook != NIL_RTTHREADCTXHOOK)
+                        if (pGVCpu->vmm.s.hCtxHook != NIL_RTTHREADCTXHOOK)
                         {
-                            Assert(!RTThreadCtxHookIsEnabled(pVCpu->vmm.s.hCtxHook));
-                            int rc2 = RTThreadCtxHookEnable(pVCpu->vmm.s.hCtxHook); AssertRC(rc2);
+                            Assert(!RTThreadCtxHookIsEnabled(pGVCpu->vmm.s.hCtxHook));
+                            int rc2 = RTThreadCtxHookEnable(pGVCpu->vmm.s.hCtxHook); AssertRC(rc2);
                         }
 
@@ -1374 +1370 @@
                          * Enter HM context.
                          */
-                        rc = HMR0Enter(pVCpu);
+                        rc = HMR0Enter(pGVCpu);
                         if (RT_SUCCESS(rc))
                         {
-                            VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED_HM);
+                            VMCPU_SET_STATE(pGVCpu, VMCPUSTATE_STARTED_HM);
 
                             /*
@@ -1383 +1379 @@
                              * we're in HM context.
                              */
-                            if (vmmR0ThreadCtxHookIsEnabled(pVCpu))
+                            if (vmmR0ThreadCtxHookIsEnabled(pGVCpu))
                             {
                                 fPreemptRestored = true;
@@ -1392 +1388 @@
                              * Setup the longjmp machinery and execute guest code (calls HMR0RunGuestCode).
                              */
-                            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-                            rc = vmmR0CallRing3SetJmp(&pVCpu->vmm.s.CallRing3JmpBufR0, HMR0RunGuestCode, pVM, pVCpu);
-                            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+                            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+                            rc = vmmR0CallRing3SetJmp(&pGVCpu->vmm.s.CallRing3JmpBufR0, HMR0RunGuestCode, pGVM, pGVCpu);
+                            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 
                             /*
@@ -1400 +1396 @@
                              * assertions are going to panic the host since we're outside the setjmp/longjmp zone.
                              */
-                            if (RT_UNLIKELY(   VMCPU_GET_STATE(pVCpu) != VMCPUSTATE_STARTED_HM
+                            if (RT_UNLIKELY(   VMCPU_GET_STATE(pGVCpu) != VMCPUSTATE_STARTED_HM
                                             && RT_SUCCESS_NP(rc)  && rc !=  VINF_VMM_CALL_HOST ))
                             {
-                                pVM->vmm.s.szRing0AssertMsg1[0] = '\0';
-                                RTStrPrintf(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2),
-                                            "Got VMCPU state %d expected %d.\n", VMCPU_GET_STATE(pVCpu), VMCPUSTATE_STARTED_HM);
+                                pGVM->vmm.s.szRing0AssertMsg1[0] = '\0';
+                                RTStrPrintf(pGVM->vmm.s.szRing0AssertMsg2, sizeof(pGVM->vmm.s.szRing0AssertMsg2),
+                                            "Got VMCPU state %d expected %d.\n", VMCPU_GET_STATE(pGVCpu), VMCPUSTATE_STARTED_HM);
                                 rc = VERR_VMM_WRONG_HM_VMCPU_STATE;
                             }
                             /** @todo Get rid of this. HM shouldn't disable the context hook. */
-                            else if (RT_UNLIKELY(vmmR0ThreadCtxHookIsEnabled(pVCpu)))
+                            else if (RT_UNLIKELY(vmmR0ThreadCtxHookIsEnabled(pGVCpu)))
                             {
-                                pVM->vmm.s.szRing0AssertMsg1[0] = '\0';
-                                RTStrPrintf(pVM->vmm.s.szRing0AssertMsg2, sizeof(pVM->vmm.s.szRing0AssertMsg2),
-                                            "Thread-context hooks still enabled! VCPU=%p Id=%u rc=%d.\n", pVCpu, pVCpu->idCpu, rc);
+                                pGVM->vmm.s.szRing0AssertMsg1[0] = '\0';
+                                RTStrPrintf(pGVM->vmm.s.szRing0AssertMsg2, sizeof(pGVM->vmm.s.szRing0AssertMsg2),
+                                            "Thread-context hooks still enabled! VCPU=%p Id=%u rc=%d.\n", pGVCpu, pGVCpu->idCpu, rc);
                                 rc = VERR_INVALID_STATE;
                             }
 
-                            VMCPU_SET_STATE(pVCpu, VMCPUSTATE_STARTED);
+                            VMCPU_SET_STATE(pGVCpu, VMCPUSTATE_STARTED);
                         }
-                        STAM_COUNTER_INC(&pVM->vmm.s.StatRunGC);
+                        STAM_COUNTER_INC(&pGVM->vmm.s.StatRunGC);
 
                         /*
@@ -1425 +1421 @@
                          * hook / restore preemption.
                          */
-                        pVCpu->iHostCpuSet = UINT32_MAX;
-                        ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
+                        pGVCpu->iHostCpuSet = UINT32_MAX;
+                        ASMAtomicWriteU32(&pGVCpu->idHostCpu, NIL_RTCPUID);
 
                         /*
@@ -1435 +1431 @@
                          *       when we get here, but the IPRT API handles that.
                          */
-                        if (pVCpu->vmm.s.hCtxHook != NIL_RTTHREADCTXHOOK)
+                        if (pGVCpu->vmm.s.hCtxHook != NIL_RTTHREADCTXHOOK)
                         {
-                            ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
-                            RTThreadCtxHookDisable(pVCpu->vmm.s.hCtxHook);
+                            ASMAtomicWriteU32(&pGVCpu->idHostCpu, NIL_RTCPUID);
+                            RTThreadCtxHookDisable(pGVCpu->vmm.s.hCtxHook);
                         }
                     }
@@ -1447 +1443 @@
                     {
                         rc = VINF_EM_RAW_INTERRUPT;
-                        pVCpu->iHostCpuSet = UINT32_MAX;
-                        ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
+                        pGVCpu->iHostCpuSet = UINT32_MAX;
+                        ASMAtomicWriteU32(&pGVCpu->idHostCpu, NIL_RTCPUID);
                     }
 
@@ -1456 +1452 @@
                         RTThreadPreemptRestore(&PreemptState);
 
-                    pVCpu->vmm.s.iLastGZRc = rc;
+                    pGVCpu->vmm.s.iLastGZRc = rc;
 
                     /* Fire dtrace probe and collect statistics. */
-                    VBOXVMM_R0_VMM_RETURN_TO_RING3_HM(pVCpu, CPUMQueryGuestCtxPtr(pVCpu), rc);
+                    VBOXVMM_R0_VMM_RETURN_TO_RING3_HM(pGVCpu, CPUMQueryGuestCtxPtr(pGVCpu), rc);
 #ifdef VBOX_WITH_STATISTICS
-                    vmmR0RecordRC(pVM, pVCpu, rc);
+                    vmmR0RecordRC(pGVM, pGVCpu, rc);
 #endif
 #if 1
@@ -1471 +1467 @@
                     else
                     {
-                        pVCpu->vmm.s.iLastGZRc = rc = vmmR0DoHalt(pGVM, pVM, pGVCpu, pVCpu);
+                        pGVCpu->vmm.s.iLastGZRc = rc = vmmR0DoHalt(pGVM, pGVCpu);
                         if (rc == VINF_SUCCESS)
                         {
-                            pVCpu->vmm.s.cR0HaltsSucceeded++;
+                            pGVCpu->vmm.s.cR0HaltsSucceeded++;
                             continue;
                         }
-                        pVCpu->vmm.s.cR0HaltsToRing3++;
+                        pGVCpu->vmm.s.cR0HaltsToRing3++;
                     }
 #endif
@@ -1486 +1482 @@
                 else
                 {
-                    pVCpu->iHostCpuSet = UINT32_MAX;
-                    ASMAtomicWriteU32(&pVCpu->idHostCpu, NIL_RTCPUID);
+                    pGVCpu->iHostCpuSet = UINT32_MAX;
+                    ASMAtomicWriteU32(&pGVCpu->idHostCpu, NIL_RTCPUID);
                     RTThreadPreemptRestore(&PreemptState);
                     if (iHostCpuSet < RTCPUSET_MAX_CPUS)
                     {
-                        int rc = SUPR0TscDeltaMeasureBySetIndex(pVM->pSession, iHostCpuSet, 0 /*fFlags*/,
+                        int rc = SUPR0TscDeltaMeasureBySetIndex(pGVM->pSession, iHostCpuSet, 0 /*fFlags*/,
                                                                 2 /*cMsWaitRetry*/, 5*RT_MS_1SEC /*cMsWaitThread*/,
                                                                 0 /*default cTries*/);
                         if (RT_SUCCESS(rc) || rc == VERR_CPU_OFFLINE)
-                            pVCpu->vmm.s.iLastGZRc = VINF_EM_RAW_TO_R3;
+                            pGVCpu->vmm.s.iLastGZRc = VINF_EM_RAW_TO_R3;
                         else
-                            pVCpu->vmm.s.iLastGZRc = rc;
+                            pGVCpu->vmm.s.iLastGZRc = rc;
                     }
                     else
-                        pVCpu->vmm.s.iLastGZRc = VERR_INVALID_CPU_INDEX;
+                        pGVCpu->vmm.s.iLastGZRc = VERR_INVALID_CPU_INDEX;
                 }
                 break;
@@ -1515 +1511 @@
              * Setup the longjmp machinery and execute guest code (calls NEMR0RunGuestCode).
              */
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-            int rc = vmmR0CallRing3SetJmp2(&pVCpu->vmm.s.CallRing3JmpBufR0, NEMR0RunGuestCode, pGVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-            STAM_COUNTER_INC(&pVM->vmm.s.StatRunGC);
-
-            pVCpu->vmm.s.iLastGZRc = rc;
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+#  ifdef VBOXSTRICTRC_STRICT_ENABLED
+            int rc = vmmR0CallRing3SetJmp2(&pGVCpu->vmm.s.CallRing3JmpBufR0, (PFNVMMR0SETJMP2)NEMR0RunGuestCode, pGVM, idCpu);
+#  else
+            int rc = vmmR0CallRing3SetJmp2(&pGVCpu->vmm.s.CallRing3JmpBufR0, NEMR0RunGuestCode, pGVM, idCpu);
+#  endif
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+            STAM_COUNTER_INC(&pGVM->vmm.s.StatRunGC);
+
+            pGVCpu->vmm.s.iLastGZRc = rc;
 
             /*
              * Fire dtrace probe and collect statistics.
              */
-            VBOXVMM_R0_VMM_RETURN_TO_RING3_NEM(pVCpu, CPUMQueryGuestCtxPtr(pVCpu), rc);
+            VBOXVMM_R0_VMM_RETURN_TO_RING3_NEM(pGVCpu, CPUMQueryGuestCtxPtr(pGVCpu), rc);
 #  ifdef VBOX_WITH_STATISTICS
-            vmmR0RecordRC(pVM, pVCpu, rc);
+            vmmR0RecordRC(pGVM, pGVCpu, rc);
 #  endif
             break;
@@ -1538 +1538 @@
          */
         case VMMR0_DO_NOP:
-            pVCpu->vmm.s.iLastGZRc = VINF_SUCCESS;
+            pGVCpu->vmm.s.iLastGZRc = VINF_SUCCESS;
             break;
 
@@ -1546 +1546 @@
         default:
             AssertMsgFailed(("%#x\n", enmOperation));
-            pVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
-            break;
-    }
-    VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            pGVCpu->vmm.s.iLastGZRc = VERR_NOT_SUPPORTED;
+            break;
+    }
+    VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
 }
 
@@ -1557 +1557 @@
  *
  * @returns true / false accordingly.
- * @param   pVM             The cross context VM structure.
+ * @param   pGVM            The global (ring-0) VM structure.
  * @param   pClaimedSession The session claim to validate.
  * @param   pSession        The session argument.
  */
-DECLINLINE(bool) vmmR0IsValidSession(PVMCC pVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
+DECLINLINE(bool) vmmR0IsValidSession(PGVM pGVM, PSUPDRVSESSION pClaimedSession, PSUPDRVSESSION pSession)
 {
     /* This must be set! */
@@ -1568 +1568 @@
 
     /* Only one out of the two. */
-    if (pVM && pClaimedSession)
+    if (pGVM && pClaimedSession)
         return false;
-    if (pVM)
-        pClaimedSession = pVM->pSession;
+    if (pGVM)
+        pClaimedSession = pGVM->pSession;
     return pClaimedSession == pSession;
 }
@@ -1582 +1582 @@
  * @returns VBox status code.
  * @param   pGVM            The global (ring-0) VM structure.
- * @param   pVM             The cross context VM structure.
  * @param   idCpu           Virtual CPU ID argument. Must be NIL_VMCPUID if pVM
  *                          is NIL_RTR0PTR, and may be NIL_VMCPUID if it isn't
@@ -1593 +1592 @@
  * @remarks Assume called with interrupts _enabled_.
  */
-static int vmmR0EntryExWorker(PGVM pGVM, PVMCC pVM, VMCPUID idCpu, VMMR0OPERATION enmOperation,
+static int vmmR0EntryExWorker(PGVM pGVM, VMCPUID idCpu, VMMR0OPERATION enmOperation,
                               PSUPVMMR0REQHDR pReqHdr, uint64_t u64Arg, PSUPDRVSESSION pSession)
 {
     /*
-     * Validate pGVM, pVM and idCpu for consistency and validity.
-     */
-    if (   pGVM != NULL
-        || pVM  != NULL)
-    {
-        if (RT_LIKELY(   RT_VALID_PTR(pGVM)
-                      && RT_VALID_PTR(pVM)
-                      && ((uintptr_t)pVM & PAGE_OFFSET_MASK) == 0))
+     * Validate pGVM and idCpu for consistency and validity.
+     */
+    if (pGVM != NULL)
+    {
+        if (RT_LIKELY(((uintptr_t)pGVM & PAGE_OFFSET_MASK) == 0))
         { /* likely */ }
         else
         {
-            SUPR0Printf("vmmR0EntryExWorker: Invalid pGVM=%p and/or pVM=%p! (op=%d)\n", pGVM, pVM, enmOperation);
+            SUPR0Printf("vmmR0EntryExWorker: Invalid pGVM=%p! (op=%d)\n", pGVM, enmOperation);
             return VERR_INVALID_POINTER;
-        }
-
-        if (RT_LIKELY(pGVM == pVM))
-        { /* likely */ }
-        else
-        {
-            SUPR0Printf("vmmR0EntryExWorker: pVM mismatch: got %p, pGVM/pVM=%p\n", pVM, pGVM);
-            return VERR_INVALID_PARAMETER;
         }
 
@@ -1628 +1616 @@
         }
 
-        if (RT_LIKELY(   pVM->enmVMState >= VMSTATE_CREATING
-                      && pVM->enmVMState <= VMSTATE_TERMINATED
-                      && pVM->cCpus      == pGVM->cCpus
-                      && pVM->pSession   == pSession
-                      && pVM->pSelf      == pVM))
+        if (RT_LIKELY(   pGVM->enmVMState >= VMSTATE_CREATING
+                      && pGVM->enmVMState <= VMSTATE_TERMINATED
+                      && pGVM->pSession   == pSession
+                      && pGVM->pSelf      == pGVM))
         { /* likely */ }
         else
         {
-            SUPR0Printf("vmmR0EntryExWorker: Invalid pVM=%p:{.enmVMState=%d, .cCpus=%#x(==%#x), .pSession=%p(==%p), .pSelf=%p(==%p)}! (op=%d)\n",
-                        pVM, pVM->enmVMState, pVM->cCpus, pGVM->cCpus, pVM->pSession, pSession, pVM->pSelf, pVM, enmOperation);
+            SUPR0Printf("vmmR0EntryExWorker: Invalid pGVM=%p:{.enmVMState=%d, .cCpus=%#x, .pSession=%p(==%p), .pSelf=%p(==%p)}! (op=%d)\n",
+                        pGVM, pGVM->enmVMState, pGVM->cCpus, pGVM->pSession, pSession, pGVM->pSelf, pGVM, enmOperation);
             return VERR_INVALID_POINTER;
         }
@@ -1665 +1652 @@
          */
         case VMMR0_DO_GVMM_CREATE_VM:
-            if (pGVM == NULL && pVM == NULL && u64Arg == 0 && idCpu == NIL_VMCPUID)
+            if (pGVM == NULL && u64Arg == 0 && idCpu == NIL_VMCPUID)
                 rc = GVMMR0CreateVMReq((PGVMMCREATEVMREQ)pReqHdr, pSession);
             else
@@ -1674 +1661 @@
         case VMMR0_DO_GVMM_DESTROY_VM:
             if (pReqHdr == NULL && u64Arg == 0)
-                rc = GVMMR0DestroyVM(pGVM, pVM);
+                rc = GVMMR0DestroyVM(pGVM);
             else
                 rc = VERR_INVALID_PARAMETER;
@@ -1681 +1668 @@
 
         case VMMR0_DO_GVMM_REGISTER_VMCPU:
-            if (pGVM != NULL && pVM != NULL)
-                rc = GVMMR0RegisterVCpu(pGVM, pVM, idCpu);
+            if (pGVM != NULL)
+                rc = GVMMR0RegisterVCpu(pGVM, idCpu);
             else
                 rc = VERR_INVALID_PARAMETER;
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_GVMM_DEREGISTER_VMCPU:
-            if (pGVM != NULL && pVM != NULL)
-                rc = GVMMR0DeregisterVCpu(pGVM, pVM, idCpu);
+            if (pGVM != NULL)
+                rc = GVMMR0DeregisterVCpu(pGVM, idCpu);
             else
                 rc = VERR_INVALID_PARAMETER;
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1699 +1686 @@
             if (pReqHdr)
                 return VERR_INVALID_PARAMETER;
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-            rc = GVMMR0SchedHaltReq(pGVM, pVM, idCpu, u64Arg);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+            rc = GVMMR0SchedHaltReq(pGVM, idCpu, u64Arg);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1707 +1694 @@
             if (pReqHdr || u64Arg)
                 return VERR_INVALID_PARAMETER;
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
-            rc = GVMMR0SchedWakeUp(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
+            rc = GVMMR0SchedWakeUp(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1715 +1702 @@
             if (pReqHdr || u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GVMMR0SchedPoke(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GVMMR0SchedPoke(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1722 +1709 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GVMMR0SchedWakeUpAndPokeCpusReq(pGVM, pVM, (PGVMMSCHEDWAKEUPANDPOKECPUSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GVMMR0SchedWakeUpAndPokeCpusReq(pGVM, (PGVMMSCHEDWAKEUPANDPOKECPUSREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1729 +1716 @@
             if (pReqHdr || u64Arg > 1)
                 return VERR_INVALID_PARAMETER;
-            rc = GVMMR0SchedPoll(pGVM, pVM, idCpu, !!u64Arg);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GVMMR0SchedPoll(pGVM, idCpu, !!u64Arg);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1736 +1723 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GVMMR0QueryStatisticsReq(pGVM, pVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr, pSession);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GVMMR0QueryStatisticsReq(pGVM, (PGVMMQUERYSTATISTICSSREQ)pReqHdr, pSession);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1743 +1730 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GVMMR0ResetStatisticsReq(pGVM, pVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr, pSession);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GVMMR0ResetStatisticsReq(pGVM, (PGVMMRESETSTATISTICSSREQ)pReqHdr, pSession);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1751 +1738 @@
          */
         case VMMR0_DO_VMMR0_INIT:
-            rc = vmmR0InitVM(pGVM, pVM, RT_LODWORD(u64Arg), RT_HIDWORD(u64Arg));
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = vmmR0InitVM(pGVM, RT_LODWORD(u64Arg), RT_HIDWORD(u64Arg));
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1759 +1746 @@
          */
         case VMMR0_DO_VMMR0_INIT_EMT:
-            rc = vmmR0InitVMEmt(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = vmmR0InitVMEmt(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1767 +1754 @@
          */
         case VMMR0_DO_VMMR0_TERM:
-            rc = VMMR0TermVM(pGVM, pVM, 0 /*idCpu*/);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = VMMR0TermVM(pGVM, 0 /*idCpu*/);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1775 +1762 @@
          */
         case VMMR0_DO_HM_ENABLE:
-            rc = HMR0EnableAllCpus(pVM);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = HMR0EnableAllCpus(pGVM);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1783 +1770 @@
          */
         case VMMR0_DO_HM_SETUP_VM:
-            rc = HMR0SetupVM(pVM);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = HMR0SetupVM(pGVM);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1793 +1780 @@
             if (idCpu == NIL_VMCPUID)
                 return VERR_INVALID_CPU_ID;
-            rc = PGMR0PhysAllocateHandyPages(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = PGMR0PhysAllocateHandyPages(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1800 +1787 @@
             if (idCpu == NIL_VMCPUID)
                 return VERR_INVALID_CPU_ID;
-            rc = PGMR0PhysFlushHandyPages(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = PGMR0PhysFlushHandyPages(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1807 +1794 @@
             if (idCpu == NIL_VMCPUID)
                 return VERR_INVALID_CPU_ID;
-            rc = PGMR0PhysAllocateLargeHandyPage(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = PGMR0PhysAllocateLargeHandyPage(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1814 +1801 @@
             if (idCpu != 0)
                 return VERR_INVALID_CPU_ID;
-            rc = PGMR0PhysSetupIoMmu(pGVM, pVM);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = PGMR0PhysSetupIoMmu(pGVM);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1824 +1811 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0InitialReservationReq(pGVM, pVM, idCpu, (PGMMINITIALRESERVATIONREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0InitialReservationReq(pGVM, idCpu, (PGMMINITIALRESERVATIONREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1831 +1818 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0UpdateReservationReq(pGVM, pVM, idCpu, (PGMMUPDATERESERVATIONREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0UpdateReservationReq(pGVM, idCpu, (PGMMUPDATERESERVATIONREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1838 +1825 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0AllocatePagesReq(pGVM, pVM, idCpu, (PGMMALLOCATEPAGESREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0AllocatePagesReq(pGVM, idCpu, (PGMMALLOCATEPAGESREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1845 +1832 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0FreePagesReq(pGVM, pVM, idCpu, (PGMMFREEPAGESREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0FreePagesReq(pGVM, idCpu, (PGMMFREEPAGESREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1852 +1839 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0FreeLargePageReq(pGVM, pVM, idCpu, (PGMMFREELARGEPAGEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0FreeLargePageReq(pGVM, idCpu, (PGMMFREELARGEPAGEREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1860 +1847 @@
                 return VERR_INVALID_PARAMETER;
             rc = GMMR0QueryHypervisorMemoryStatsReq((PGMMMEMSTATSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1868 +1855 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0QueryMemoryStatsReq(pGVM, pVM, idCpu, (PGMMMEMSTATSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0QueryMemoryStatsReq(pGVM, idCpu, (PGMMMEMSTATSREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1875 +1862 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0BalloonedPagesReq(pGVM, pVM, idCpu, (PGMMBALLOONEDPAGESREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0BalloonedPagesReq(pGVM, idCpu, (PGMMBALLOONEDPAGESREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1882 +1869 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0MapUnmapChunkReq(pGVM, pVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0MapUnmapChunkReq(pGVM, (PGMMMAPUNMAPCHUNKREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1889 +1876 @@
             if (pReqHdr)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0SeedChunk(pGVM, pVM, idCpu, (RTR3PTR)u64Arg);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0SeedChunk(pGVM, idCpu, (RTR3PTR)u64Arg);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1898 +1885 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0RegisterSharedModuleReq(pGVM, pVM, idCpu, (PGMMREGISTERSHAREDMODULEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0RegisterSharedModuleReq(pGVM, idCpu, (PGMMREGISTERSHAREDMODULEREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1907 +1894 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0UnregisterSharedModuleReq(pGVM, pVM, idCpu, (PGMMUNREGISTERSHAREDMODULEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0UnregisterSharedModuleReq(pGVM, idCpu, (PGMMUNREGISTERSHAREDMODULEREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1917 +1904 @@
                 ||  pReqHdr)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0ResetSharedModules(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0ResetSharedModules(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1929 +1916 @@
                 ||  pReqHdr)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0CheckSharedModules(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0CheckSharedModules(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
         }
@@ -1939 +1926 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0FindDuplicatePageReq(pGVM, pVM, (PGMMFINDDUPLICATEPAGEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0FindDuplicatePageReq(pGVM, (PGMMFINDDUPLICATEPAGEREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 #endif
@@ -1947 +1934 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0QueryStatisticsReq(pGVM, pVM, (PGMMQUERYSTATISTICSSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0QueryStatisticsReq(pGVM, (PGMMQUERYSTATISTICSSREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1954 +1941 @@
             if (u64Arg)
                 return VERR_INVALID_PARAMETER;
-            rc = GMMR0ResetStatisticsReq(pGVM, pVM, (PGMMRESETSTATISTICSSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = GMMR0ResetStatisticsReq(pGVM, (PGMMRESETSTATISTICSSREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -1965 +1952 @@
         case VMMR0_DO_GCFGM_QUERY_VALUE:
         {
-            if (pGVM || pVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
+            if (pGVM || !pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             PGCFGMVALUEREQ pReq = (PGCFGMVALUEREQ)pReqHdr;
@@ -1982 +1969 @@
                 //    rc = GMMR0QueryConfig(pReq->pSession, &pReq->szName[0], &pReq->u64Value);
             }
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
         }
@@ -1993 +1980 @@
             if (!pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = PDMR0DriverCallReqHandler(pGVM, pVM, (PPDMDRIVERCALLREQHANDLERREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = PDMR0DriverCallReqHandler(pGVM, (PPDMDRIVERCALLREQHANDLERREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
         }
@@ -2002 +1989 @@
             if (!pReqHdr || u64Arg || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = PDMR0DeviceCallReqHandler(pGVM, pVM, (PPDMDEVICECALLREQHANDLERREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = PDMR0DeviceCallReqHandler(pGVM, (PPDMDEVICECALLREQHANDLERREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
         }
@@ -2013 +2000 @@
         {
             PINTNETOPENREQ pReq = (PINTNETOPENREQ)pReqHdr;
-            if (u64Arg || !pReq || !vmmR0IsValidSession(pVM, pReq->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReq || !vmmR0IsValidSession(pGVM, pReq->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0OpenReq(pSession, pReq);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
         }
 
         case VMMR0_DO_INTNET_IF_CLOSE:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFCLOSEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfCloseReq(pSession, (PINTNETIFCLOSEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
 
         case VMMR0_DO_INTNET_IF_GET_BUFFER_PTRS:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFGETBUFFERPTRSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFGETBUFFERPTRSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfGetBufferPtrsReq(pSession, (PINTNETIFGETBUFFERPTRSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_INTNET_IF_SET_PROMISCUOUS_MODE:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfSetPromiscuousModeReq(pSession, (PINTNETIFSETPROMISCUOUSMODEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_INTNET_IF_SET_MAC_ADDRESS:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFSETMACADDRESSREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfSetMacAddressReq(pSession, (PINTNETIFSETMACADDRESSREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_INTNET_IF_SET_ACTIVE:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFSETACTIVEREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfSetActiveReq(pSession, (PINTNETIFSETACTIVEREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_INTNET_IF_SEND:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfSendReq(pSession, (PINTNETIFSENDREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_INTNET_IF_WAIT:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfWaitReq(pSession, (PINTNETIFWAITREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
         case VMMR0_DO_INTNET_IF_ABORT_WAIT:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PINTNETIFWAITREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
             rc = IntNetR0IfAbortWaitReq(pSession, (PINTNETIFABORTWAITREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2082 +2069 @@
          */
         case VMMR0_DO_PCIRAW_REQ:
-            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pVM, ((PPCIRAWSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
-                return VERR_INVALID_PARAMETER;
-            rc = PciRawR0ProcessReq(pGVM, pVM, pSession, (PPCIRAWSENDREQ)pReqHdr);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            if (u64Arg || !pReqHdr || !vmmR0IsValidSession(pGVM, ((PPCIRAWSENDREQ)pReqHdr)->pSession, pSession) || idCpu != NIL_VMCPUID)
+                return VERR_INVALID_PARAMETER;
+            rc = PciRawR0ProcessReq(pGVM, pSession, (PPCIRAWSENDREQ)pReqHdr);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 #endif
@@ -2097 +2084 @@
             if (u64Arg || pReqHdr || idCpu != 0)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0InitVM(pGVM, pVM);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0InitVM(pGVM);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2104 +2091 @@
             if (u64Arg || pReqHdr || idCpu != 0)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0InitVMPart2(pGVM, pVM);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0InitVMPart2(pGVM);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2111 +2098 @@
             if (u64Arg || pReqHdr || idCpu == NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0MapPages(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0MapPages(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2118 +2105 @@
             if (u64Arg || pReqHdr || idCpu == NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0UnmapPages(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0UnmapPages(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2125 +2112 @@
             if (u64Arg || pReqHdr || idCpu == NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0ExportState(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0ExportState(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2132 +2119 @@
             if (pReqHdr || idCpu == NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0ImportState(pGVM, pVM, idCpu, u64Arg);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0ImportState(pGVM, idCpu, u64Arg);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2139 +2126 @@
             if (u64Arg || pReqHdr || idCpu == NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0QueryCpuTick(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0QueryCpuTick(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2146 +2133 @@
             if (pReqHdr || idCpu == NIL_VMCPUID)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0ResumeCpuTickOnAll(pGVM, pVM, idCpu, u64Arg);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0ResumeCpuTickOnAll(pGVM, idCpu, u64Arg);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2153 +2140 @@
             if (u64Arg || pReqHdr)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0UpdateStatistics(pGVM, pVM, idCpu);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0UpdateStatistics(pGVM, idCpu);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 
@@ -2161 +2148 @@
             if (pReqHdr)
                 return VERR_INVALID_PARAMETER;
-            rc = NEMR0DoExperiment(pGVM, pVM, idCpu, u64Arg);
-            VMM_CHECK_SMAP_CHECK2(pVM, RT_NOTHING);
+            rc = NEMR0DoExperiment(pGVM, idCpu, u64Arg);
+            VMM_CHECK_SMAP_CHECK2(pGVM, RT_NOTHING);
             break;
 #   endif
@@ -2200 +2187 @@
 {
     PGVM                pGVM;
-    PVMCC               pVM;
     VMCPUID             idCpu;
     VMMR0OPERATION      enmOperation;
@@ -2219 +2205 @@
 {
     return vmmR0EntryExWorker(((PVMMR0ENTRYEXARGS)pvArgs)->pGVM,
-                              ((PVMMR0ENTRYEXARGS)pvArgs)->pVM,
                               ((PVMMR0ENTRYEXARGS)pvArgs)->idCpu,
                               ((PVMMR0ENTRYEXARGS)pvArgs)->enmOperation,
@@ -2251 +2236 @@
     if (   pVM  != NULL
         && pGVM != NULL
+        && pVM  == pGVM /** @todo drop pGVM */
         && idCpu < pGVM->cCpus
-        && pVM->pSession == pSession
-        && pVM->pSelf != NULL)
+        && pGVM->pSession == pSession
+        && pGVM->pSelf    == pVM)
     {
         switch (enmOperation)
@@ -2279 +2265 @@
                     VMMR0ENTRYEXARGS Args;
                     Args.pGVM = pGVM;
-                    Args.pVM = pVM;
                     Args.idCpu = idCpu;
                     Args.enmOperation = enmOperation;
@@ -2294 +2279 @@
         }
     }
-    return vmmR0EntryExWorker(pGVM, pVM, idCpu, enmOperation, pReq, u64Arg, pSession);
+    return vmmR0EntryExWorker(pGVM, idCpu, enmOperation, pReq, u64Arg, pSession);
 }
 

trunk/src/VBox/VMM/VMMR3/NEMR3Native-win.cpp

@@ -1724 +1724 @@
     }
 #endif
-    return nemHCWinRunGC(pVM, pVCpu, NULL /*pGVM*/, NULL /*pGVCpu*/);
+    return nemHCWinRunGC(pVM, pVCpu);
 }