Changeset 90439 in vbox for trunk/src

Timestamp:

Jul 30, 2021 4:41:49 PM (4 years ago)

Author:

vboxsync

Message:

VMM/PGM: Check PGMCritSectEnter status code when we don't return it. bugref:6695

Location:

trunk/src/VBox/VMM

Files:

• VMMAll/PGMAll.cpp (modified) (25 diffs)
• VMMAll/PGMAllBth.h (modified) (22 diffs)
• VMMAll/PGMAllHandler.cpp (modified) (42 diffs)
• VMMAll/PGMAllMap.cpp (modified) (2 diffs)
• VMMAll/PGMAllPhys.cpp (modified) (45 diffs)
• VMMAll/PGMAllPool.cpp (modified) (30 diffs)
• VMMAll/PGMAllShw.h (modified) (3 diffs)
• VMMR0/PGMR0.cpp (modified) (8 diffs)
• VMMR3/PGM.cpp (modified) (10 diffs)
• VMMR3/PGMDbg.cpp (modified) (13 diffs)
• VMMR3/PGMHandler.cpp (modified) (2 diffs)
• VMMR3/PGMMap.cpp (modified) (4 diffs)
• VMMR3/PGMPhys.cpp (modified) (97 diffs)
• VMMR3/PGMPool.cpp (modified) (2 diffs)
• VMMR3/PGMSavedState.cpp (modified) (51 diffs)
• VMMR3/PGMSharedPage.cpp (modified) (7 diffs)
• include/PGMInternal.h (modified) (1 diff)

trunk/src/VBox/VMM/VMMAll/PGMAll.cpp

@@ -947 +947 @@
     {
         PGM_LOCK_ASSERT_OWNER(pVM);
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
     }
     LogFlow(("PGMTrap0eHandler: uErr=%RGx pvFault=%RGv rc=%Rrc\n", uErr, pvFault, rc));
@@ -1225 +1225 @@
      */
     STAM_PROFILE_START(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage), a);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     uintptr_t const idxBth = pVCpu->pgm.s.idxBothModeData;
-    AssertReturnStmt(idxBth < RT_ELEMENTS(g_aPgmBothModeData), pgmUnlock(pVM), VERR_PGM_MODE_IPE);
-    AssertReturnStmt(g_aPgmBothModeData[idxBth].pfnInvalidatePage, pgmUnlock(pVM), VERR_PGM_MODE_IPE);
+    AssertReturnStmt(idxBth < RT_ELEMENTS(g_aPgmBothModeData), PGM_UNLOCK(pVM), VERR_PGM_MODE_IPE);
+    AssertReturnStmt(g_aPgmBothModeData[idxBth].pfnInvalidatePage, PGM_UNLOCK(pVM), VERR_PGM_MODE_IPE);
     rc = g_aPgmBothModeData[idxBth].pfnInvalidatePage(pVCpu, GCPtrPage);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,InvalidatePage), a);
 
@@ -1293 +1293 @@
 {
     PVMCC pVM = pVCpu->CTX_SUFF(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     uintptr_t idxShw = pVCpu->pgm.s.idxShadowModeData;
@@ -1300 +1300 @@
     int rc = g_aPgmShadowModeData[idxShw].pfnGetPage(pVCpu, GCPtr, pfFlags, pHCPhys);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1327 +1327 @@
 
     PVMCC pVM = pVCpu->CTX_SUFF(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     uintptr_t idxShw = pVCpu->pgm.s.idxShadowModeData;
@@ -1334 +1334 @@
     int rc = g_aPgmShadowModeData[idxShw].pfnModifyPage(pVCpu, GCPtr, PAGE_SIZE, fFlags, fMask, fOpFlags);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -2197 +2197 @@
 {
     PVMCC       pVM = pVCpu->CTX_SUFF(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     Assert(!pVCpu->pgm.s.CTX_SUFF(pGst32BitPd));
@@ -2217 +2217 @@
             pVCpu->pgm.s.pGst32BitPdR0 = *ppPd;
 #  endif
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2231 +2231 @@
             *ppPd = (PX86PD)HCPtrGuestCR3;
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2237 +2237 @@
         AssertRC(rc);
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     *ppPd = NULL;
@@ -2256 +2256 @@
     Assert(!pVCpu->pgm.s.CTX_SUFF(pGstPaePdpt));
     PVMCC       pVM = pVCpu->CTX_SUFF(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     RTGCPHYS    GCPhysCR3 = pVCpu->pgm.s.GCPhysCR3 & X86_CR3_PAE_PAGE_MASK;
@@ -2274 +2274 @@
             pVCpu->pgm.s.pGstPaePdptR0 = *ppPdpt;
 #  endif
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2288 +2288 @@
             *ppPdpt = (PX86PDPT)HCPtrGuestCR3;
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2295 +2295 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     *ppPdpt = NULL;
     return rc;
@@ -2314 +2314 @@
 {
     PVMCC           pVM         = pVCpu->CTX_SUFF(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PX86PDPT        pGuestPDPT  = pVCpu->pgm.s.CTX_SUFF(pGstPaePdpt);
@@ -2340 +2340 @@
             if (fChanged)
                 pVCpu->pgm.s.aGCPhysGstPaePDs[iPdpt]   = GCPhys;
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2357 +2357 @@
 
             *ppPd = pVCpu->pgm.s.CTX_SUFF(apGstPaePDs)[iPdpt];
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2370 +2370 @@
 # endif
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -2387 +2387 @@
     Assert(!pVCpu->pgm.s.CTX_SUFF(pGstAmd64Pml4));
     PVMCC       pVM = pVCpu->CTX_SUFF(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     RTGCPHYS    GCPhysCR3 = pVCpu->pgm.s.GCPhysCR3 & X86_CR3_AMD64_PAGE_MASK;
@@ -2405 +2405 @@
             pVCpu->pgm.s.pGstAmd64Pml4R0 = *ppPml4;
 #  endif
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2419 +2419 @@
             *ppPml4 = (PX86PML4)HCPtrGuestCR3;
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -2425 +2425 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     *ppPml4 = NULL;
     return rc;
@@ -2582 +2582 @@
         if (pPool->cDirtyPages)
         {
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
             pgmPoolResetDirtyPages(pVM);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
         }
 #endif
@@ -3517 +3517 @@
  * @returns VBox status code
  * @param   pVM         The cross context VM structure.
+ * @param   fVoid       Set if the caller cannot handle failure returns.
  * @param   SRC_POS     The source position of the caller (RT_SRC_POS).
  */
-#if (defined(VBOX_STRICT) && defined(IN_RING3)) || defined(DOXYGEN_RUNNING)
-int pgmLockDebug(PVMCC pVM, RT_SRC_POS_DECL)
+#if defined(VBOX_STRICT) || defined(DOXYGEN_RUNNING)
+int pgmLockDebug(PVMCC pVM, bool fVoid, RT_SRC_POS_DECL)
 #else
-int pgmLock(PVMCC pVM)
+int pgmLock(PVMCC pVM, bool fVoid)
 #endif
 {
-#if defined(VBOX_STRICT) && defined(IN_RING3)
+#if defined(VBOX_STRICT)
     int rc = PDMCritSectEnterDebug(pVM, &pVM->pgm.s.CritSectX, VERR_SEM_BUSY, (uintptr_t)ASMReturnAddress(), RT_SRC_POS_ARGS);
 #else
     int rc = PDMCritSectEnter(pVM, &pVM->pgm.s.CritSectX, VERR_SEM_BUSY);
 #endif
+    if (RT_SUCCESS(rc))
+        return rc;
+
 #ifdef IN_RING0
     if (rc == VERR_SEM_BUSY)
+    {
         rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_LOCK, 0);
+        if (RT_SUCCESS(rc))
+            return rc;
+    }
 #endif
-    AssertMsg(rc == VINF_SUCCESS, ("%Rrc\n", rc));
+    if (fVoid)
+        PDM_CRITSECT_RELEASE_ASSERT_RC(pVM, &pVM->pgm.s.CritSectX, rc);
+    else
+        AssertRC(rc);
     return rc;
 }
@@ -3771 +3782 @@
     AssertReturn(g_aPgmBothModeData[idxBth].pfnAssertCR3, -VERR_PGM_MODE_IPE);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     unsigned cErrors = g_aPgmBothModeData[idxBth].pfnAssertCR3(pVCpu, cr3, cr4, 0, ~(RTGCPTR)0);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,SyncCR3), a);

trunk/src/VBox/VMM/VMMAll/PGMAllBth.h

@@ -114 +114 @@
     Assert(!pVM->pgm.s.fNestedPaging);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     /* Note: we only really need shadow paging in real and protected mode for VT-x and AMD-V (excluding nested paging/EPT modes),
      *       but any calls to GC need a proper shadow page setup as well.
@@ -160 +160 @@
 # endif
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 #else
@@ -346 +346 @@
                 if (pCur->hType != pPool->hAccessHandlerType)
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     *pfLockTaken = false;
                 }
@@ -353 +353 @@
 
 #  ifdef VBOX_WITH_STATISTICS
-                pgmLock(pVM);
+                PGM_LOCK_VOID(pVM);
                 pCur = pgmHandlerPhysicalLookup(pVM, GCPhysFault);
                 if (pCur)
                     STAM_PROFILE_STOP(&pCur->Stat, h);
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
 #  endif
             }
@@ -466 +466 @@
     /* Take the big lock now before we update flags. */
     *pfLockTaken = true;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -546 +546 @@
     /* Take the big lock now. */
     *pfLockTaken = true;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 #  endif /* !PGM_WITH_PAGING(PGM_GST_TYPE, PGM_SHW_TYPE) */
 
@@ -3185 +3185 @@
     {
         PVMCC pVM = pVCpu->CTX_SUFF(pVM);
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
 
 # if PGM_SHW_TYPE == PGM_TYPE_32BIT
@@ -3202 +3202 @@
         if (rc != VINF_SUCCESS)
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             AssertRC(rc);
             return rc;
@@ -3228 +3228 @@
         if (rc != VINF_SUCCESS)
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             AssertRC(rc);
             return rc;
@@ -3256 +3256 @@
             }
         }
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
     }
     return rc;
@@ -3336 +3336 @@
     int             rc = VINF_SUCCESS;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -3356 +3356 @@
     if (rc != VINF_SUCCESS)
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertRC(rc);
         return rc;
@@ -3380 +3380 @@
     if (rc != VINF_SUCCESS)
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertRC(rc);
         return rc;
@@ -3394 +3394 @@
         {
             PGM_DYNMAP_UNUSED_HINT(pVCpu, pPdeDst);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             AssertRC(rc);
             return rc;
@@ -3434 +3434 @@
     }
     PGM_DYNMAP_UNUSED_HINT(pVCpu, pPdeDst);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 
@@ -3468 +3468 @@
 #if !PGM_TYPE_IS_NESTED_OR_EPT(PGM_SHW_TYPE) && PGM_SHW_TYPE != PGM_TYPE_NONE
 # ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
     if (pPool->cDirtyPages)
         pgmPoolResetDirtyPages(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 # endif
 #endif /* !NESTED && !EPT */
@@ -4314 +4314 @@
      */
     RTHCPTR     HCPtrGuestCR3;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPAGE    pPageCR3 = pgmPhysGetPage(pVM, GCPhysCR3);
     AssertReturn(pPageCR3, VERR_PGM_INVALID_CR3_ADDR);
     /** @todo this needs some reworking wrt. locking?  */
     int rc = pgmPhysGCPhys2CCPtrInternalDepr(pVM, pPageCR3, GCPhysCR3 & GST_CR3_PAGE_MASK, (void **)&HCPtrGuestCR3); /** @todo r=bird: This GCPhysCR3 masking isn't necessary. */
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     if (RT_SUCCESS(rc))
     {
@@ -4365 +4365 @@
                 RTHCPTR     HCPtr;
                 RTGCPHYS    GCPhys = PGM_A20_APPLY(pVCpu, pGuestPDPT->a[i].u & X86_PDPE_PG_MASK);
-                pgmLock(pVM);
+                PGM_LOCK_VOID(pVM);
                 PPGMPAGE    pPage  = pgmPhysGetPage(pVM, GCPhys);
                 AssertReturn(pPage, VERR_PGM_INVALID_PDPE_ADDR);
                 int rc2 = pgmPhysGCPhys2CCPtrInternalDepr(pVM, pPage, GCPhys, (void **)&HCPtr);
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 if (RT_SUCCESS(rc2))
                 {
@@ -4442 +4442 @@
     PPGMPOOLPAGE pNewShwPageCR3;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
 # ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
@@ -4493 +4493 @@
         pgmPoolFreeByPage(pPool, pOldShwPageCR3, NIL_PGMPOOL_IDX, UINT32_MAX);
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 # else
     NOREF(GCPhysCR3);
@@ -4556 +4556 @@
     Assert(!pVM->pgm.s.fNestedPaging);
 # endif
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
 # ifndef PGM_WITHOUT_MAPPINGS
@@ -4581 +4581 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 #endif
 

trunk/src/VBox/VMM/VMMAll/PGMAllHandler.cpp

@@ -67 +67 @@
     if (cRefs == 0)
     {
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
         pType->u32Magic = PGMPHYSHANDLERTYPEINT_MAGIC_DEAD;
         RTListOff32NodeRemove(&pType->ListNode);
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         MMHyperFree(pVM, pType);
     }
@@ -279 +279 @@
     pPhysHandler->cPages       = (GCPhysLast - (GCPhys & X86_PTE_PAE_PG_MASK) + PAGE_SIZE) >> PAGE_SHIFT;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     if (RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, &pPhysHandler->Core))
     {
@@ -289 +289 @@
         NEMHCNotifyHandlerPhysicalRegister(pVM, pType->enmKind, GCPhys, GCPhysLast - GCPhys + 1);
 #endif
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
 
         if (rc != VINF_SUCCESS)
@@ -295 +295 @@
         return rc;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     pPhysHandler->Core.Key     = NIL_RTGCPHYS;
@@ -441 +441 @@
      * Remove the handler from the tree.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pRemoved = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers,
                                                                     pPhysHandler->Core.Key);
@@ -458 +458 @@
         pPhysHandler->Core.KeyLast = NIL_RTGCPHYS;
 
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
 
         return VINF_SUCCESS;
@@ -472 +472 @@
         RTAvlroGCPhysInsert(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, &pRemoved->Core);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     if (!pRemoved)
@@ -517 +517 @@
      * Find the handler.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pRemoved = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
     if (pRemoved)
@@ -533 +533 @@
         pVM->pgm.s.pLastPhysHandlerR3 = 0;
 
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
 
         pRemoved->Core.Key = NIL_RTGCPHYS;
@@ -540 +540 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     AssertMsgFailed(("Didn't find range starting at %RGp\n", GCPhys));
@@ -837 +837 @@
      */
     int rc;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysRemove(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhysCurrent);
     if (pCur)
@@ -880 +880 @@
                     NEMHCNotifyHandlerPhysicalModify(pVM, enmKind, GCPhysCurrent, GCPhys, cb, fRestoreAsRAM);
 
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
 
                     PGM_INVL_ALL_VCPU_TLBS(pVM);
@@ -919 +919 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -939 +939 @@
      */
     int rc = VINF_SUCCESS;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
     if (pCur)
@@ -955 +955 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -983 +983 @@
      * Get the handler.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
     if (RT_LIKELY(pCur))
@@ -1003 +1003 @@
                 LogFlow(("PGMHandlerPhysicalSplit: %RGp-%RGp and %RGp-%RGp\n",
                          pCur->Core.Key, pCur->Core.KeyLast, pNew->Core.Key, pNew->Core.KeyLast));
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 return VINF_SUCCESS;
             }
@@ -1020 +1020 @@
         rc = VERR_PGM_HANDLER_NOT_FOUND;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     MMHyperFree(pVM, pNew);
     return rc;
@@ -1040 +1040 @@
      */
     int rc;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pCur1 = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys1);
     if (RT_LIKELY(pCur1))
@@ -1065 +1065 @@
                         PGMHandlerPhysicalTypeRelease(pVM, pCur2->hType);
                         MMHyperFree(pVM, pCur2);
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
                         return VINF_SUCCESS;
                     }
@@ -1096 +1096 @@
         rc = VERR_PGM_HANDLER_NOT_FOUND;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 
@@ -1119 +1119 @@
 {
     LogFlow(("PGMHandlerPhysicalReset GCPhys=%RGp\n", GCPhys));
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -1205 +1205 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1232 +1232 @@
 {
     LogFlow(("PGMHandlerPhysicalPageTempOff GCPhysPage=%RGp\n", GCPhysPage));
-
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
+
     /*
      * Validate the range.
@@ -1249 +1249 @@
             AssertReturnStmt(   pCurType->enmKind == PGMPHYSHANDLERKIND_WRITE
                              || pCurType->enmKind == PGMPHYSHANDLERKIND_ALL,
-                             pgmUnlock(pVM), VERR_ACCESS_DENIED);
+                             PGM_UNLOCK(pVM), VERR_ACCESS_DENIED);
 
             /*
@@ -1256 +1256 @@
             PPGMPAGE pPage;
             int rc = pgmPhysGetPageEx(pVM, GCPhysPage, &pPage);
-            AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
+            AssertReturnStmt(RT_SUCCESS_NP(rc), PGM_UNLOCK(pVM), rc);
             if (PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) != PGM_PAGE_HNDL_PHYS_STATE_DISABLED)
             {
@@ -1272 +1272 @@
                 }
             }
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertMsgFailed(("The page %#x is outside the range %#x-%#x\n",
                          GCPhysPage, pCur->Core.Key, pCur->Core.KeyLast));
         return VERR_INVALID_PARAMETER;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     AssertMsgFailed(("Specified physical handler start address %#x is invalid.\n", GCPhys));
     return VERR_PGM_HANDLER_NOT_FOUND;
@@ -1381 +1381 @@
                                                PPDMDEVINS pDevIns, PGMMMIO2HANDLE hMmio2, RTGCPHYS offMmio2PageRemap)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -1390 +1390 @@
         AssertMsgReturnStmt(PGM_PAGE_GET_TYPE(pPageRemap) == PGMPAGETYPE_MMIO2,
                             ("hMmio2=%RU64 offMmio2PageRemap=%RGp %R[pgmpage]\n", hMmio2, offMmio2PageRemap, pPageRemap),
-                            pgmUnlock(pVM), VERR_PGM_PHYS_NOT_MMIO2);
+                            PGM_UNLOCK(pVM), VERR_PGM_PHYS_NOT_MMIO2);
     else
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return VERR_OUT_OF_RANGE;
     }
@@ -1407 +1407 @@
         {
             PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-            AssertReturnStmt(pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO, pgmUnlock(pVM), VERR_ACCESS_DENIED);
-            AssertReturnStmt(!(pCur->Core.Key & PAGE_OFFSET_MASK), pgmUnlock(pVM), VERR_INVALID_PARAMETER);
-            AssertReturnStmt((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, pgmUnlock(pVM), VERR_INVALID_PARAMETER);
+            AssertReturnStmt(pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO, PGM_UNLOCK(pVM), VERR_ACCESS_DENIED);
+            AssertReturnStmt(!(pCur->Core.Key & PAGE_OFFSET_MASK), PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
+            AssertReturnStmt((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
 
             /*
@@ -1416 +1416 @@
             PPGMPAGE pPage;
             int rc = pgmPhysGetPageEx(pVM, GCPhysPage, &pPage);
-            AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
+            AssertReturnStmt(RT_SUCCESS_NP(rc), PGM_UNLOCK(pVM), rc);
             if (PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO)
             {
@@ -1424 +1424 @@
                 if (PGM_PAGE_GET_HCPHYS(pPage) == PGM_PAGE_GET_HCPHYS(pPageRemap))
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return VINF_PGM_HANDLER_ALREADY_ALIASED;
                 }
@@ -1466 +1466 @@
             }
             LogFlow(("PGMHandlerPhysicalPageAliasMmio2: => %R[pgmpage]\n", pPage));
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
 
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertMsgFailed(("The page %#x is outside the range %#x-%#x\n",
                          GCPhysPage, pCur->Core.Key, pCur->Core.KeyLast));
@@ -1476 +1476 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     AssertMsgFailed(("Specified physical handler start address %#x is invalid.\n", GCPhys));
     return VERR_PGM_HANDLER_NOT_FOUND;
@@ -1516 +1516 @@
 {
 ///    Assert(!IOMIsLockOwner(pVM)); /* We mustn't own any other locks when calling this */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -1528 +1528 @@
         {
             PPGMPHYSHANDLERTYPEINT pCurType = PGMPHYSHANDLER_GET_TYPE(pVM, pCur);
-            AssertReturnStmt(pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO, pgmUnlock(pVM), VERR_ACCESS_DENIED);
-            AssertReturnStmt(!(pCur->Core.Key & PAGE_OFFSET_MASK), pgmUnlock(pVM), VERR_INVALID_PARAMETER);
-            AssertReturnStmt((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, pgmUnlock(pVM), VERR_INVALID_PARAMETER);
+            AssertReturnStmt(pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO, PGM_UNLOCK(pVM), VERR_ACCESS_DENIED);
+            AssertReturnStmt(!(pCur->Core.Key & PAGE_OFFSET_MASK), PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
+            AssertReturnStmt((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
 
             /*
@@ -1537 +1537 @@
             PPGMPAGE pPage;
             int rc = pgmPhysGetPageEx(pVM, GCPhysPage, &pPage);
-            AssertReturnStmt(RT_SUCCESS_NP(rc), pgmUnlock(pVM), rc);
+            AssertReturnStmt(RT_SUCCESS_NP(rc), PGM_UNLOCK(pVM), rc);
             if (PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO)
             {
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 AssertMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_SPECIAL_ALIAS_MMIO,
                                 ("GCPhysPage=%RGp %R[pgmpage]\n", GCPhysPage, pPage),
@@ -1576 +1576 @@
             }
             LogFlow(("PGMHandlerPhysicalPageAliasHC: => %R[pgmpage]\n", pPage));
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertMsgFailed(("The page %#x is outside the range %#x-%#x\n",
                          GCPhysPage, pCur->Core.Key, pCur->Core.KeyLast));
         return VERR_INVALID_PARAMETER;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     AssertMsgFailed(("Specified physical handler start address %#x is invalid.\n", GCPhys));
@@ -1605 +1605 @@
      * Find the handler.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
     if (pCur)
@@ -1616 +1616 @@
                || pCurType->enmKind == PGMPHYSHANDLERKIND_MMIO);
 #endif
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return true;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return false;
 }
@@ -1637 +1637 @@
 bool pgmHandlerPhysicalIsAll(PVMCC pVM, RTGCPHYS GCPhys)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPHYSHANDLER pCur = pgmHandlerPhysicalLookup(pVM, GCPhys);
     if (!pCur)
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertFailed();
         return true;
@@ -1654 +1654 @@
 
     bool bRet = pCurType->enmKind != PGMPHYSHANDLERKIND_WRITE;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return bRet;
 }

trunk/src/VBox/VMM/VMMAll/PGMAllMap.cpp

@@ -645 +645 @@
      * Iterate mappings.
      */
-    pgmLock(pVM);                           /* to avoid assertions */
+    PGM_LOCK_VOID(pVM);                     /* to avoid assertions */
     for (PPGMMAPPING pCur = pVM->pgm.s.CTX_SUFF(pMappings); pCur; pCur = pCur->CTX_SUFF(pNext))
     {
@@ -651 +651 @@
         pgmMapCheckShadowPDEs(pVM, pVCpu, pVCpu->pgm.s.CTX_SUFF(pShwPageCR3), pCur, iPDE);
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 

trunk/src/VBox/VMM/VMMAll/PGMAllPhys.cpp

@@ -276 +276 @@
                  * kind of screw things up...
                  */
-                int rc = pgmLock(pVM);
-                AssertRC(rc);
+                PGM_LOCK_VOID(pVM);
 
                 PPGMPAGE pShadowPage = &pRomPage->Shadow;
@@ -287 +286 @@
 
                 void *pvDstPage;
-                rc = pgmPhysPageMakeWritableAndMap(pVM, pShadowPage, GCPhys & X86_PTE_PG_MASK, &pvDstPage);
+                int rc = pgmPhysPageMakeWritableAndMap(pVM, pShadowPage, GCPhys & X86_PTE_PG_MASK, &pvDstPage);
                 if (RT_SUCCESS(rc))
                 {
@@ -300 +299 @@
                 }
 
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 return rc;
             }
@@ -320 +319 @@
 void pgmPhysInvalidRamRangeTlbs(PVMCC pVM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     RT_ZERO(pVM->pgm.s.apRamRangesTlbR3);
     RT_ZERO(pVM->pgm.s.apRamRangesTlbR0);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -549 +548 @@
 VMM_INT_DECL(int) PGMPhysGCPhys2HCPhys(PVMCC pVM, RTGCPHYS GCPhys, PRTHCPHYS pHCPhys)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPAGE pPage;
     int rc = pgmPhysGetPageEx(pVM, GCPhys, &pPage);
     if (RT_SUCCESS(rc))
         *pHCPhys = PGM_PAGE_GET_HCPHYS(pPage) | (GCPhys & PAGE_OFFSET_MASK);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -566 +565 @@
 void pgmPhysInvalidatePageMapTLB(PVMCC pVM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatPageMapTlbFlushes);
 
@@ -588 +587 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -1778 +1777 @@
 VMM_INT_DECL(int) PGMPhysGCPhys2CCPtr(PVMCC pVM, RTGCPHYS GCPhys, void **ppv, PPGMPAGEMAPLOCK pLock)
 {
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -1812 +1811 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1847 +1846 @@
 VMM_INT_DECL(int) PGMPhysGCPhys2CCPtrReadOnly(PVMCC pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock)
 {
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -1871 +1870 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1970 +1969 @@
     pLock->pvMap = NULL;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     if (fWriteLock)
     {
@@ -2012 +2011 @@
     }
 # endif
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -2040 +2039 @@
 #endif
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     if (fWriteLock)
     {
@@ -2076 +2075 @@
             if ((i & 1023) == 1023 && i + 1 < cPages)
             {
-                pgmUnlock(pVM);
-                pgmLock(pVM);
+                PGM_UNLOCK(pVM);
+                PGM_LOCK_VOID(pVM);
             }
         }
@@ -2111 +2110 @@
             if ((i & 1023) == 1023 && i + 1 < cPages)
             {
-                pgmUnlock(pVM);
-                pgmLock(pVM);
+                PGM_UNLOCK(pVM);
+                PGM_LOCK_VOID(pVM);
             }
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     RT_BZERO(paLocks, sizeof(paLocks[0]) * cPages);
@@ -2166 +2165 @@
 
     Log(("pgmPhysGCPhys2R3Ptr(,%RGp,): dont use this API!\n", GCPhys)); /** @todo eliminate this API! */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PPGMRAMRANGE pRam;
@@ -2174 +2173 @@
         rc = pgmPhysGCPhys2CCPtrInternalDepr(pVM, pPage, GCPhys, (void **)pR3Ptr);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     Assert(rc <= VINF_SUCCESS);
     return rc;
@@ -2323 +2322 @@
 
         /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         rcStrict = pfnHandler(pVM, pVCpu, GCPhys, (void *)pvSrc, pvBuf, cb, PGMACCESSTYPE_READ, enmOrigin, pvUser);
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
 
 #ifdef VBOX_WITH_STATISTICS
@@ -2399 +2398 @@
     STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysReadBytes), cbRead);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -2458 +2457 @@
                     {
                         memset(pvBuf, 0xff, cb);
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
                         return rcStrict2;
                     }
@@ -2466 +2465 @@
                 if (cb >= cbRead)
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return rcStrict;
                 }
@@ -2501 +2500 @@
     } /* Ram range walk */
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rcStrict;
 }
@@ -2563 +2562 @@
             /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
             PGM_LOCK_ASSERT_OWNER(pVM);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             rcStrict = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
 
 #ifdef VBOX_WITH_STATISTICS
@@ -2682 +2681 @@
             /* Release the PGM lock as MMIO handlers take the IOM lock. (deadlock prevention) */
             PGM_LOCK_ASSERT_OWNER(pVM);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             rcStrict2 = pfnHandler(pVM, pVCpu, GCPhys, pvDst, (void *)pvBuf, cbRange, PGMACCESSTYPE_WRITE, enmOrigin, pvUser);
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
 
 #ifdef VBOX_WITH_STATISTICS
@@ -2785 +2784 @@
     STAM_COUNTER_ADD(&pVM->pgm.s.CTX_SUFF(pStats)->CTX_MID_Z(Stat,PhysWriteBytes), cbWrite);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -2839 +2838 @@
                     else
                     {
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
                         return rcStrict2;
                     }
@@ -2847 +2846 @@
                 if (cb >= cbWrite)
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return rcStrict;
                 }
@@ -2878 +2877 @@
     } /* Ram range walk */
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rcStrict;
 }
@@ -3056 +3055 @@
      * when many VCPUs are fighting for the lock.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /* map the 1st page */
@@ -3064 +3063 @@
     if (RT_FAILURE(rc))
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return rc;
     }
@@ -3074 +3073 @@
         memcpy(pvDst, pvSrc, cb);
         PGMPhysReleasePageMappingLock(pVM, &Lock);
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return VINF_SUCCESS;
     }
@@ -3094 +3093 @@
         if (RT_FAILURE(rc))
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return rc;
         }
@@ -3103 +3102 @@
             memcpy(pvDst, pvSrc, cb);
             PGMPhysReleasePageMappingLock(pVM, &Lock);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
@@ -4069 +4068 @@
 VMM_INT_DECL(PGMPAGETYPE) PGMPhysGetPageType(PVMCC pVM, RTGCPHYS GCPhys)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPAGE pPage = pgmPhysGetPage(pVM, GCPhys);
     PGMPAGETYPE enmPgType = pPage ? (PGMPAGETYPE)PGM_PAGE_GET_TYPE(pPage) : PGMPAGETYPE_INVALID;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return enmPgType;
@@ -4107 +4106 @@
     Assert(!(GCPhys & X86_PAGE_OFFSET_MASK));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PPGMRAMRANGE pRam;
@@ -4204 +4203 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -4240 +4239 @@
     PGM_A20_APPLY_TO_VAR(pVCpu, GCPhys);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PPGMRAMRANGE pRam;
@@ -4310 +4309 @@
         rc = VERR_PGM_PHYS_TLB_UNASSIGNED;
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -4340 +4339 @@
 VMM_INT_DECL(int) PGMPhysIemQueryAccess(PVMCC pVM, RTGCPHYS GCPhys, bool fWritable, bool fByPassHandlers)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PGM_A20_ASSERT_MASKED(VMMGetCpu(pVM), GCPhys);
 
@@ -4370 +4369 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -4394 +4393 @@
                                             PFNPGMPHYSNEMCHECKPAGE pfnChecker, void *pvUser)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PPGMPAGE pPage;
@@ -4456 +4455 @@
 
         /* Done. */
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
     }
     else
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
 
         pInfo->HCPhys       = NIL_RTHCPHYS;
@@ -4492 +4491 @@
      * Just brute force this problem.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     int rc = VINF_SUCCESS;
     for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangesX); pRam; pRam = pRam->CTX_SUFF(pNext))
@@ -4512 +4511 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return rc;

trunk/src/VBox/VMM/VMMAll/PGMAllPool.cpp

@@ -957 +957 @@
     LogFlow(("pgmRZPoolAccessPfHandler: pvFault=%RGv pPage=%p:{.idx=%d} GCPhysFault=%RGp\n", pvFault, pPage, pPage->idx, GCPhysFault));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     if (PHYS_PAGE_ADDRESS(GCPhysFault) != PHYS_PAGE_ADDRESS(pPage->GCPhys))
     {
@@ -963 +963 @@
         Log(("CPU%d: pgmRZPoolAccessPfHandler pgm pool page for %RGp changed (to %RGp) while waiting!\n", pVCpu->idCpu, PHYS_PAGE_ADDRESS(GCPhysFault), PHYS_PAGE_ADDRESS(pPage->GCPhys)));
         STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->StatMonitorPfRZ, &pPool->StatMonitorPfRZHandled, a);
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return VINF_SUCCESS;
     }
@@ -970 +970 @@
     {
         Assert(VMCPU_FF_IS_SET(pVCpu, VMCPU_FF_TLB_FLUSH));
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return VINF_SUCCESS;    /* SMP guest case where we were blocking on the pgm lock while the same page was being marked dirty. */
     }
@@ -995 +995 @@
     {
         AssertMsg(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT, ("Unexpected rc %d\n", rc));
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return rc;
     }
@@ -1090 +1090 @@
 
             STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->StatMonitorPfRZ, &pPool->StatMonitorPfRZHandled, a);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return rc;
         }
@@ -1132 +1132 @@
                 rc = pgmRZPoolAccessPfHandlerSTOSD(pVM, pPool, pPage, pDis, pRegFrame, GCPhysFault, pvFault);
                 STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->StatMonitorPfRZ, &pPool->StatMonitorPfRZRepStosd, a);
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 return rc;
             }
@@ -1210 +1210 @@
 
                 STAM_PROFILE_STOP(&pVM->pgm.s.CTX_SUFF(pPool)->StatMonitorPfRZ, a);
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 return rc;
             }
@@ -1236 +1236 @@
     }
     STAM_PROFILE_STOP_EX(&pVM->pgm.s.CTX_SUFF(pPool)->StatMonitorPfRZ, &pPool->StatMonitorPfRZFlushPage, a);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1260 +1260 @@
     NOREF(pvPhys); NOREF(pvBuf); NOREF(enmAccessType);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
 #ifdef VBOX_WITH_STATISTICS
@@ -1342 +1342 @@
     else
         Log(("CPU%d: PGM_ALL_CB_DECL pgm pool page for %RGp changed (to %RGp) while waiting!\n", pVCpu->idCpu, PHYS_PAGE_ADDRESS(GCPhys), PHYS_PAGE_ADDRESS(pPage->GCPhys)));
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_PGM_HANDLER_DO_DEFAULT;
 }
@@ -2670 +2670 @@
 static void pgmPoolMonitorModifiedClearAll(PVMCC pVM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
     LogFlow(("pgmPoolMonitorModifiedClearAll: cModifiedPages=%d\n", pPool->cModifiedPages));
@@ -2693 +2693 @@
     AssertMsg(cPages == pPool->cModifiedPages, ("%d != %d\n", cPages, pPool->cModifiedPages));
     pPool->cModifiedPages = 0;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -3461 +3461 @@
 {
     PVMCPUCC pVCpu = VMMGetCpu(pVM);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     int rc = VINF_SUCCESS;
 
@@ -3493 +3493 @@
 
             *pfFlushTLBs = true;
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return rc;
         }
@@ -3537 +3537 @@
         rc = VINF_PGM_SYNC_CR3;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -4041 +4041 @@
 uint16_t pgmPoolTrackPhysExtAddref(PVMCC pVM, PPGMPAGE pPhysPage, uint16_t u16, uint16_t iShwPT, uint16_t iPte)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     if (PGMPOOL_TD_GET_CREFS(u16) != PGMPOOL_TD_CREFS_PHYSEXT)
     {
@@ -4072 +4072 @@
     else
         STAM_COUNTER_INC(&pVM->pgm.s.CTX_SUFF(pStats)->StatTrackAliasedLots);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return u16;
 }
@@ -4094 +4094 @@
     if (iPhysExt != PGMPOOL_TD_IDX_OVERFLOWED)
     {
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
 
         uint16_t        iPhysExtPrev = NIL_PGMPOOL_PHYSEXT_INDEX;
@@ -4117 +4117 @@
                         {
                             Log2(("pgmPoolTrackPhysExtDerefGCPhys: pPhysPage=%R[pgmpage] idx=%d\n", pPhysPage, pPage->idx));
-                            pgmUnlock(pVM);
+                            PGM_UNLOCK(pVM);
                             return;
                         }
@@ -4146 +4146 @@
                     }
                     iPhysExt = iPhysExtNext;
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return;
                 }
@@ -4156 +4156 @@
         } while (iPhysExt != NIL_PGMPOOL_PHYSEXT_INDEX);
 
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertFatalMsgFailed(("not-found! cRefs=%d pPhysPage=%R[pgmpage] pPage=%p:{.idx=%d}\n", cRefs, pPhysPage, pPage, pPage->idx));
     }
@@ -4808 +4808 @@
                     VINF_SUCCESS);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -4827 +4827 @@
                   ("Can't free the shadow CR3! (%RHp vs %RHp kind=%d\n", PGMGetHyperCR3(VMMGetCpu(pVM)), pPage->Core.Key, pPage->enmKind));
         Log(("pgmPoolFlushPage: current active shadow CR3, rejected. enmKind=%s idx=%d\n", pgmPoolPoolKindToStr(pPage->enmKind), pPage->idx));
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return VINF_SUCCESS;
     }
@@ -4884 +4884 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     STAM_PROFILE_STOP(&pPool->StatFlushPage, f);
     return rc;
@@ -4912 +4912 @@
     AssertReturnVoid(pPage->idx >= PGMPOOL_IDX_FIRST); /* paranoia (#6349) */
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     if (iUser != NIL_PGMPOOL_IDX)
         pgmPoolTrackFreeUser(pPool, pPage, iUser, iUserTable);
     if (!pPage->fCached)
         pgmPoolFlushPage(pPool, pPage);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     STAM_PROFILE_STOP(&pPool->StatFree, a);
 }
@@ -4998 +4998 @@
      *  Assert(!(pVM->pgm.s.fGlobalSyncFlags & PGM_SYNC_CLEAR_PGM_POOL)); */
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     if (pPool->fCacheEnabled)
@@ -5007 +5007 @@
             if (fLockPage)
                 pgmPoolLockPage(pPool, *ppPage);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             STAM_PROFILE_ADV_STOP(&pPool->StatAlloc, a);
             LogFlow(("pgmPoolAlloc: cached returns %Rrc *ppPage=%p:{.Key=%RHp, .idx=%d}\n", rc2, *ppPage, (*ppPage)->Core.Key, (*ppPage)->idx));
@@ -5024 +5024 @@
         if (RT_FAILURE(rc))
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             Log(("pgmPoolAlloc: returns %Rrc (Free)\n", rc));
             STAM_PROFILE_ADV_STOP(&pPool->StatAlloc, a);
@@ -5077 +5077 @@
         pPage->iNext        = pPool->iFreeHead;
         pPool->iFreeHead    = pPage->idx;
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         STAM_PROFILE_ADV_STOP(&pPool->StatAlloc, a);
         Log(("pgmPoolAlloc: returns %Rrc (Insert)\n", rc3));
@@ -5102 +5102 @@
     if (fLockPage)
         pgmPoolLockPage(pPool, pPage);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     LogFlow(("pgmPoolAlloc: returns %Rrc *ppPage=%p:{.Key=%RHp, .idx=%d, .fCached=%RTbool, .fMonitored=%RTbool}\n",
              rc, pPage, pPage->Core.Key, pPage->idx, pPage->fCached, pPage->fMonitored));

trunk/src/VBox/VMM/VMMAll/PGMAllShw.h

@@ -238 +238 @@
     Assert(!pVCpu->pgm.s.pShwPageCR3R3);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     int rc = pgmPoolAlloc(pVM, GCPhysCR3, PGMPOOLKIND_ROOT_NESTED, PGMPOOLACCESS_DONTCARE, PGM_A20_IS_ENABLED(pVCpu),
                           NIL_PGMPOOL_IDX, UINT32_MAX, true /*fLockPage*/,
                           &pNewShwPageCR3);
-    AssertLogRelRCReturnStmt(rc, pgmUnlock(pVM), rc);
+    AssertLogRelRCReturnStmt(rc, PGM_UNLOCK(pVM), rc);
 
     pVCpu->pgm.s.pShwPageCR3R3 = (R3PTRTYPE(PPGMPOOLPAGE))MMHyperCCToR3(pVM, pNewShwPageCR3);
     pVCpu->pgm.s.pShwPageCR3R0 = (R0PTRTYPE(PPGMPOOLPAGE))MMHyperCCToR0(pVM, pNewShwPageCR3);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     Log(("Enter nested shadow paging mode: root %RHv phys %RHp\n", pVCpu->pgm.s.pShwPageCR3R3, pVCpu->pgm.s.CTX_SUFF(pShwPageCR3)->Core.Key));
@@ -272 +272 @@
         PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
 
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
 
         /* Do *not* unlock this page as we have two of them floating around in the 32-bit host & 64-bit guest case.
@@ -285 +285 @@
         pVCpu->pgm.s.pShwPageCR3R0 = 0;
 
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
 
         Log(("Leave nested shadow paging mode\n"));

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

@@ -544 +544 @@
          * IOMMU about each of them.
          */
-        pgmLock(pGVM);
+        PGM_LOCK_VOID(pGVM);
         rc = GPciRawR0GuestPageBeginAssignments(pGVM);
         if (RT_SUCCESS(rc))
@@ -573 +573 @@
                 rc = rc2;
         }
-        pgmUnlock(pGVM);
+        PGM_UNLOCK(pGVM);
     }
     else
@@ -683 +683 @@
     {
         PGM_LOCK_ASSERT_OWNER(pGVM);
-        pgmUnlock(pGVM);
+        PGM_UNLOCK(pGVM);
     }
 
@@ -734 +734 @@
      * Try lookup the all access physical handler for the address.
      */
-    pgmLock(pGVM);
+    PGM_LOCK_VOID(pGVM);
     PPGMPHYSHANDLER         pHandler     = pgmHandlerPhysicalLookup(pGVM, GCPhysFault);
     PPGMPHYSHANDLERTYPEINT  pHandlerType = RT_LIKELY(pHandler) ? PGMPHYSHANDLER_GET_TYPE(pGVM, pHandler) : NULL;
@@ -754 +754 @@
             STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
             rc = pgmShwSyncNestedPageLocked(pGVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
-            pgmUnlock(pGVM);
+            PGM_UNLOCK(pGVM);
         }
         else
@@ -762 +762 @@
                 void *pvUser = pHandler->CTX_SUFF(pvUser);
                 STAM_PROFILE_START(&pHandler->Stat, h);
-                pgmUnlock(pGVM);
+                PGM_UNLOCK(pGVM);
 
                 Log6(("PGMR0Trap0eHandlerNPMisconfig: calling %p(,%#x,,%RGp,%p)\n", pHandlerType->CTX_SUFF(pfnPfHandler), uErr, GCPhysFault, pvUser));
@@ -769 +769 @@
 
 #ifdef VBOX_WITH_STATISTICS
-                pgmLock(pGVM);
+                PGM_LOCK_VOID(pGVM);
                 pHandler = pgmHandlerPhysicalLookup(pGVM, GCPhysFault);
                 if (pHandler)
                     STAM_PROFILE_STOP(&pHandler->Stat, h);
-                pgmUnlock(pGVM);
+                PGM_UNLOCK(pGVM);
 #endif
             }
             else
             {
-                pgmUnlock(pGVM);
+                PGM_UNLOCK(pGVM);
                 Log(("PGMR0Trap0eHandlerNPMisconfig: %RGp (uErr=%#x) -> R3\n", GCPhysFault, uErr));
                 rc = VINF_EM_RAW_EMULATE_INSTR;
@@ -795 +795 @@
         STAM_COUNTER_INC(&pGVCpu->pgm.s.CTX_SUFF(pStats)->StatR0NpMiscfgSyncPage);
         rc = pgmShwSyncNestedPageLocked(pGVCpu, GCPhysFault, 1 /*cPages*/, enmShwPagingMode);
-        pgmUnlock(pGVM);
+        PGM_UNLOCK(pGVM);
     }
 

trunk/src/VBox/VMM/VMMR3/PGM.cpp

@@ -1997 +1997 @@
     VM_ASSERT_EMT(pVM);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -2074 +2074 @@
 
     //pgmLogState(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -2089 +2089 @@
     if (fAtReset)
     {
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
 
         int rc = pgmR3PhysRamZeroAll(pVM);
@@ -2097 +2097 @@
         AssertReleaseRC(rc);
 
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
     }
 }
@@ -2133 +2133 @@
 {
     /* Must free shared pages here. */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     pgmR3PhysRamTerm(pVM);
     pgmR3PhysRomTerm(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     PGMDeregisterStringFormatTypes();
@@ -2278 +2278 @@
                     {
                         pszType = "MMIO";
-                        pgmLock(pVM);
+                        PGM_LOCK_VOID(pVM);
                         PPGMPHYSHANDLER pHandler = pgmHandlerPhysicalLookup(pVM, iFirstPage * X86_PAGE_SIZE);
                         if (pHandler)
                             pszMore = pHandler->pszDesc;
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
                         break;
                     }
@@ -2335 +2335 @@
      * Get page directory addresses.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PX86PD     pPDSrc = pgmGstGet32bitPDPtr(pVCpu);
     Assert(pPDSrc);
@@ -2361 +2361 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -2636 +2636 @@
     RT_ZERO(abZeroPg);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesXR3;
          pRam && pRam->GCPhys < GCPhysEnd && RT_SUCCESS(rc);
@@ -2710 +2710 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     RTFileClose(hFile);

trunk/src/VBox/VMM/VMMR3/PGMDbg.cpp

@@ -690 +690 @@
      * bother to match across ranges.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRangesX);
          pRam;
@@ -750 +750 @@
                         {
                             *pGCPhysHit = GCPhys + offHit;
-                            pgmUnlock(pVM);
+                            PGM_UNLOCK(pVM);
                             return VINF_SUCCESS;
                         }
@@ -764 +764 @@
                 if (GCPhys >= GCPhysLast) /* (may not always hit, but we're run out of ranges.) */
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return VERR_DBGF_MEM_NOT_FOUND;
                 }
@@ -774 +774 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VERR_DBGF_MEM_NOT_FOUND;
 }
@@ -872 +872 @@
     RT_ZERO(Walk);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (;; offPage = 0)
     {
@@ -918 +918 @@
                         {
                             *pGCPtrHit = GCPtr + offHit;
-                            pgmUnlock(pVM);
+                            PGM_UNLOCK(pVM);
                             return VINF_SUCCESS;
                         }
@@ -1005 +1005 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VERR_DBGF_MEM_NOT_FOUND;
 }
@@ -1163 +1163 @@
 static void pgmR3DumpHierarchyShwTablePageInfo(PPGMR3DUMPHIERARCHYSTATE pState, RTHCPHYS HCPhys)
 {
-    pgmLock(pState->pVM);
+    PGM_LOCK_VOID(pState->pVM);
     char            szPage[80];
     PPGMPOOLPAGE    pPage = pgmPoolQueryPageForDbg(pState->pVM->pgm.s.CTX_SUFF(pPool), HCPhys);
@@ -1192 +1192 @@
 #endif /* !PGM_WITHOUT_MAPPINGS */
     }
-    pgmUnlock(pState->pVM);
+    PGM_UNLOCK(pState->pVM);
     pState->pHlp->pfnPrintf(pState->pHlp, "%s", szPage);
 }
@@ -1211 +1211 @@
     if (RT_SUCCESS(rc))
     {
-        pgmLock(pState->pVM);
+        PGM_LOCK_VOID(pState->pVM);
         PCPGMPAGE pPage = pgmPhysGetPage(pState->pVM, GCPhys);
         if (pPage)
@@ -1217 +1217 @@
         else
             strcpy(szPage, "not found");
-        pgmUnlock(pState->pVM);
+        PGM_UNLOCK(pState->pVM);
         pState->pHlp->pfnPrintf(pState->pHlp, " -> %RGp %s", GCPhys, szPage);
     }
@@ -1920 +1920 @@
 {
     char szPage[80];
-    pgmLock(pState->pVM);
+    PGM_LOCK_VOID(pState->pVM);
     PCPGMPAGE pPage = pgmPhysGetPage(pState->pVM, GCPhys);
     if (pPage)
@@ -1926 +1926 @@
     else
         strcpy(szPage, " not found");
-    pgmUnlock(pState->pVM);
+    PGM_UNLOCK(pState->pVM);
     pState->pHlp->pfnPrintf(pState->pHlp, "%s", szPage);
     NOREF(cbPage);

trunk/src/VBox/VMM/VMMR3/PGMHandler.cpp

@@ -102 +102 @@
         pType->pszDesc          = pszDesc;
 
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
         RTListOff32Append(&pVM->pgm.s.CTX_SUFF(pTrees)->HeadPhysHandlerTypes, &pType->ListNode);
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
 
         *phType = MMHyperHeapPtrToOffset(pVM, pType);
@@ -223 +223 @@
      * (the right -> left on the setting pass is just bird speculating on cache hits)
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers,  true, pgmR3HandlerPhysicalOneClear, pVM);
     RTAvlroGCPhysDoWithAll(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, false, pgmR3HandlerPhysicalOneSet, pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 

trunk/src/VBox/VMM/VMMR3/PGMMap.cpp

@@ -954 +954 @@
     unsigned i     = pMap->cPTs;
     PVMCPU   pVCpu = VMMGetCpu(pVM);
-    pgmLock(pVM);                           /* to avoid assertions */
+    PGM_LOCK_VOID(pVM);                           /* to avoid assertions */
 
     pgmMapClearShadowPDEs(pVM, pVCpu->pgm.s.CTX_SUFF(pShwPageCR3), pMap, iOldPDE, false /*fDeactivateCR3*/);
@@ -979 +979 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -996 +996 @@
     PVMCPU pVCpu = VMMGetCpu(pVM);
 # endif
-    pgmLock(pVM);                           /* to avoid assertions */
+    PGM_LOCK_VOID(pVM);                           /* to avoid assertions */
 
     Assert(!pgmMapAreMappingsEnabled(pVM) || PGMGetGuestMode(pVCpu) <= PGMMODE_PAE_NX);
@@ -1034 +1034 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 

trunk/src/VBox/VMM/VMMR3/PGMPhys.cpp

@@ -118 +118 @@
     LogFlow(("PGMR3PhysReadExternal: %RGp %d\n", GCPhys, cbRead));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -145 +145 @@
                     || PGM_PAGE_IS_SPECIAL_ALIAS_MMIO(pPage))
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
 
                     return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysReadExternalEMT, 5,
@@ -176 +176 @@
                 if (cb >= cbRead)
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return VINF_SUCCESS;
                 }
@@ -210 +210 @@
     } /* Ram range walk */
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return VINF_SUCCESS;
@@ -254 +254 @@
     LogFlow(("PGMR3PhysWriteExternal: %RGp %d\n", GCPhys, cbWrite));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -290 +290 @@
                     else
                     {
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
 
                         return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysWriteExternalEMT, 5,
@@ -319 +319 @@
                 if (cb >= cbWrite)
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     return VINF_SUCCESS;
                 }
@@ -349 +349 @@
     } /* Ram range walk */
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -369 +369 @@
      * an access handler after it succeeds.
      */
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -400 +400 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -439 +439 @@
     Assert(VM_IS_EMT(pVM) || !PGMIsLockOwner(pVM));
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -476 +476 @@
                 else
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
 
                     return VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysGCPhys2CCPtrDelegated, 4,
@@ -511 +511 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -540 +540 @@
 VMMR3DECL(int) PGMR3PhysGCPhys2CCPtrReadOnlyExternal(PVM pVM, RTGCPHYS GCPhys, void const **ppv, PPGMPAGEMAPLOCK pLock)
 {
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -589 +589 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -636 +636 @@
     Assert(VM_IS_EMT(pVM) || !PGMIsLockOwner(pVM));
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -651 +651 @@
         else
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             ASMNopPause();
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
             cNextYield = 128;
         }
@@ -708 +708 @@
         {
             /* We could do this delegation in bulk, but considered too much work vs gain. */
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             rc = VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)pgmR3PhysGCPhys2CCPtrDelegated, 4,
                                          pVM, &paGCPhysPages[iPage], &papvPages[iPage], &paLocks[iPage]);
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
             if (RT_FAILURE(rc))
                 break;
@@ -744 +744 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     /*
@@ -794 +794 @@
     Assert(VM_IS_EMT(pVM) || !PGMIsLockOwner(pVM));
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -809 +809 @@
         else
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             ASMNopPause();
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
             cNextYield = 256;
         }
@@ -865 +865 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     /*
@@ -1069 +1069 @@
     Assert((pNew->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pNew->pSelfR0 == MMHyperCCToR0(pVM, pNew));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PPGMRAMRANGE pRam = pPrev ? pPrev->pNextR3 : pVM->pgm.s.pRamRangesXR3;
@@ -1088 +1088 @@
 
     pgmR3PhysRebuildRamRangeSearchTrees(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -1104 +1104 @@
     Assert((pRam->fFlags & PGM_RAM_RANGE_FLAGS_FLOATING) || pRam->pSelfR0 == MMHyperCCToR0(pVM, pRam));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     PPGMRAMRANGE pNext = pRam->pNextR3;
@@ -1121 +1121 @@
 
     pgmR3PhysRebuildRamRangeSearchTrees(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -1133 +1133 @@
 static void pgmR3PhysUnlinkRamRange(PVM pVM, PPGMRAMRANGE pRam)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /* find prev. */
@@ -1146 +1146 @@
 
     pgmR3PhysUnlinkRamRange2(pVM, pRam, pPrev);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -1216 +1216 @@
 
     Log(("pgmR3PhysChangeMemBalloonRendezvous: %s %x pages\n", (fInflate) ? "inflate" : "deflate", cPages));
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     if (fInflate)
@@ -1227 +1227 @@
         if (RT_FAILURE(rc))
         {
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             AssertLogRelRC(rc);
             return rc;
@@ -1251 +1251 @@
             if (RT_FAILURE(rc))
             {
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 AssertLogRelRC(rc);
                 return rc;
@@ -1264 +1264 @@
             if (RT_FAILURE(rc))
             {
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 AssertLogRelRC(rc);
                 return rc;
@@ -1303 +1303 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     /* Flush the recompiler's TLB as well. */
@@ -1407 +1407 @@
     NOREF(pvUser); NOREF(pVCpu);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 #ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
     pgmPoolResetDirtyPages(pVM);
@@ -1457 +1457 @@
         CPUMSetChangedFlags(pVM->apCpusR3[idCpu], CPUM_CHANGED_GLOBAL_TLB_FLUSH);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1487 +1487 @@
     VM_ASSERT_VALID_EXT_RETURN(pVM, UINT32_MAX);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     uint32_t cRamRanges = 0;
     for (PPGMRAMRANGE pCur = pVM->pgm.s.CTX_SUFF(pRamRangesX); pCur; pCur = pCur->CTX_SUFF(pNext))
         cRamRanges++;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return cRamRanges;
 }
@@ -1514 +1514 @@
     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     uint32_t iCurRange = 0;
     for (PPGMRAMRANGE pCur = pVM->pgm.s.CTX_SUFF(pRamRangesX); pCur; pCur = pCur->CTX_SUFF(pNext), iCurRange++)
@@ -1528 +1528 @@
                 *pfIsMmio     = !!(pCur->fFlags & PGM_RAM_RANGE_FLAGS_AD_HOC_MMIO);
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return VINF_SUCCESS;
         }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VERR_OUT_OF_RANGE;
 }
@@ -1697 +1697 @@
              * Update myself, then relink all the ranges and flush the RC TLB.
              */
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
 
             pRam->pSelfRC = (RTRCPTR)(GCPtrNew + PAGE_SIZE);
@@ -1705 +1705 @@
                 pVM->pgm.s.apRamRangesTlbRC[i] = NIL_RTRCPTR;
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return true;
         }
@@ -1818 +1818 @@
     VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -1847 +1847 @@
     if (RT_FAILURE(rc))
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         return rc;
     }
@@ -1909 +1909 @@
      */
     rc = NEMR3NotifyPhysRamRegister(pVM, GCPhys, cb);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -1935 +1935 @@
     uint64_t cPages = 0;
     uint64_t NanoTS = RTTimeNanoTS();
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesXR3; pRam; pRam = pRam->pNextR3)
     {
@@ -1953 +1953 @@
                         {
                             LogRel(("PGM: RAM Pre-allocation failed at %RGp (in %s) with rc=%Rrc\n", GCPhys, pRam->pszDesc, rc));
-                            pgmUnlock(pVM);
+                            PGM_UNLOCK(pVM);
                             return rc;
                         }
@@ -1974 +1974 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     NanoTS = RTTimeNanoTS() - NanoTS;
 
@@ -1991 +1991 @@
 {
 #ifdef VBOX_STRICT
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     if (pVM->pgm.s.cSharedPages > 0)
@@ -2036 +2036 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 #endif /* VBOX_STRICT */
     NOREF(pVM);
@@ -2341 +2341 @@
     Assert(((PPGMPHYSHANDLERTYPEINT)MMHyperHeapOffsetToPtr(pVM, hType))->enmKind == PGMPHYSHANDLERKIND_MMIO);
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -2362 +2362 @@
                                        GCPhys, GCPhysLast, pszDesc,
                                        pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
-                                      pgmUnlock(pVM),
+                                      PGM_UNLOCK(pVM),
                                       VERR_PGM_RAM_CONFLICT);
 
@@ -2374 +2374 @@
                                           ("%RGp-%RGp (MMIO/%s): %RGp is not a RAM or MMIO page - type=%d desc=%s\n",
                                            GCPhys, GCPhysLast, pszDesc, pRam->GCPhys, PGM_PAGE_GET_TYPE(pPage), pRam->pszDesc),
-                                          pgmUnlock(pVM),
+                                          PGM_UNLOCK(pVM),
                                           VERR_PGM_RAM_CONFLICT);
                 pPage++;
@@ -2399 +2399 @@
          */
         rc = pgmR3PhysFreePageRange(pVM, pRam, GCPhys, GCPhysLast, PGMPAGETYPE_MMIO);
-        AssertRCReturnStmt(rc, pgmUnlock(pVM), rc);
+        AssertRCReturnStmt(rc, PGM_UNLOCK(pVM), rc);
 
         /* Force a PGM pool flush as guest ram references have been changed. */
@@ -2423 +2423 @@
         const size_t cbRamRange = RT_UOFFSETOF_DYN(PGMRAMRANGE, aPages[cPages]);
         rc = MMHyperAlloc(pVM, RT_UOFFSETOF_DYN(PGMRAMRANGE, aPages[cPages]), 16, MM_TAG_PGM_PHYS, (void **)&pNew);
-        AssertLogRelMsgRCReturnStmt(rc, ("cbRamRange=%zu\n", cbRamRange), pgmUnlock(pVM), rc);
+        AssertLogRelMsgRCReturnStmt(rc, ("cbRamRange=%zu\n", cbRamRange), PGM_UNLOCK(pVM), rc);
 
         /* Initialize the range. */
@@ -2465 +2465 @@
     pgmPhysInvalidatePageMapTLB(pVM);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -2485 +2485 @@
     VM_ASSERT_EMT(pVM);
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -2587 +2587 @@
     pgmPhysInvalidatePageMapTLB(pVM);
     pgmPhysInvalidRamRangeTlbs(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -2668 +2668 @@
              * Update myself, then relink all the ranges and flush the RC TLB.
              */
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
 
             pMmio->RamRange.pSelfRC = (RTRCPTR)(GCPtrNew + PAGE_SIZE + RT_UOFFSETOF(PGMREGMMIO2RANGE, RamRange));
@@ -2676 +2676 @@
                 pVM->pgm.s.apRamRangesTlbRC[i] = NIL_RTRCPTR;
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return true;
         }
@@ -2905 +2905 @@
     }
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /* Link in the chain of ranges at the head of the list. */
@@ -2932 +2932 @@
 
     pgmPhysInvalidatePageMapTLB(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -3015 +3015 @@
      */
     unsigned cChunks = pgmR3PhysMmio2CalcChunkCount(pVM, cb, NULL, NULL);
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     uint8_t  idMmio2 = pVM->pgm.s.cMmio2Regions + 1;
     unsigned cNewMmio2Regions = pVM->pgm.s.cMmio2Regions + cChunks;
     if (cNewMmio2Regions > PGM_MMIO2_MAX_RANGES)
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertLogRelFailedReturn(VERR_PGM_TOO_MANY_MMIO2_RANGES);
     }
     pVM->pgm.s.cMmio2Regions = cNewMmio2Regions;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     /*
@@ -3134 +3134 @@
      * get properly deregistered, though it's original purpose was the wildcard iRegion.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     int rc = VINF_SUCCESS;
     unsigned cFound = 0;
@@ -3248 +3248 @@
     }
     pgmPhysInvalidatePageMapTLB(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return !cFound && hMmio2 != NIL_PGMMMIO2HANDLE  ? VERR_NOT_FOUND : rc;
 }
@@ -3310 +3310 @@
      * ram ranges).
      */
-    pgmLock(pVM);
-
-    AssertReturnStmt(!(pFirstMmio->fFlags & PGMREGMMIO2RANGE_F_MAPPED), pgmUnlock(pVM), VERR_WRONG_ORDER);
+    PGM_LOCK_VOID(pVM);
+
+    AssertReturnStmt(!(pFirstMmio->fFlags & PGMREGMMIO2RANGE_F_MAPPED), PGM_UNLOCK(pVM), VERR_WRONG_ORDER);
 
     bool fRamExists = false;
@@ -3328 +3328 @@
                                        GCPhys, GCPhysLast, pFirstMmio->RamRange.pszDesc,
                                        pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
-                                      pgmUnlock(pVM),
+                                      PGM_UNLOCK(pVM),
                                       VERR_PGM_RAM_CONFLICT);
 
@@ -3339 +3339 @@
                                           ("%RGp isn't a RAM page (%d) - mapping %RGp-%RGp (MMIO2/%s).\n",
                                            GCPhys, PGM_PAGE_GET_TYPE(pPage), GCPhys, GCPhysLast, pFirstMmio->RamRange.pszDesc),
-                                          pgmUnlock(pVM),
+                                          PGM_UNLOCK(pVM),
                                           VERR_PGM_RAM_CONFLICT);
                 pPage++;
@@ -3348 +3348 @@
                                       ("%RGp-%RGp (MMIOEx/%s, flags %#X) consists of multiple chunks whereas the RAM somehow doesn't!\n",
                                        GCPhys, GCPhysLast, pFirstMmio->RamRange.pszDesc, pFirstMmio->fFlags),
-                                      pgmUnlock(pVM),
+                                      PGM_UNLOCK(pVM),
                                       VERR_PGM_PHYS_MMIO_EX_IPE);
 
@@ -3390 +3390 @@
 
         int rc = pgmR3PhysFreePageRange(pVM, pRam, GCPhys, GCPhysLast, PGMPAGETYPE_MMIO);
-        AssertRCReturnStmt(rc, pgmUnlock(pVM), rc);
+        AssertRCReturnStmt(rc, PGM_UNLOCK(pVM), rc);
 
         if (pFirstMmio->fFlags & PGMREGMMIO2RANGE_F_MMIO2)
@@ -3512 +3512 @@
             }
 
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             return rc;
         }
@@ -3539 +3539 @@
     int rc = NEMR3NotifyPhysMmioExMap(pVM, GCPhys, cbRange, fNemNotify, pFirstMmio->pvR3);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return rc;
@@ -3570 +3570 @@
     Assert(pFirstMmio->fFlags & PGMREGMMIO2RANGE_F_FIRST_CHUNK);
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -3577 +3577 @@
     for (;;)
     {
-        AssertReturnStmt(pLastMmio->fFlags & PGMREGMMIO2RANGE_F_MAPPED, pgmUnlock(pVM), VERR_WRONG_ORDER);
-        AssertReturnStmt(pLastMmio->RamRange.GCPhys == GCPhys + cbRange || GCPhys == NIL_RTGCPHYS, pgmUnlock(pVM), VERR_INVALID_PARAMETER);
+        AssertReturnStmt(pLastMmio->fFlags & PGMREGMMIO2RANGE_F_MAPPED, PGM_UNLOCK(pVM), VERR_WRONG_ORDER);
+        AssertReturnStmt(pLastMmio->RamRange.GCPhys == GCPhys + cbRange || GCPhys == NIL_RTGCPHYS, PGM_UNLOCK(pVM), VERR_INVALID_PARAMETER);
         Assert(pLastMmio->pDevInsR3 == pFirstMmio->pDevInsR3);
         Assert(pLastMmio->iSubDev   == pFirstMmio->iSubDev);
@@ -3592 +3592 @@
 
     uint16_t const fOldFlags = pFirstMmio->fFlags;
-    AssertReturnStmt(fOldFlags & PGMREGMMIO2RANGE_F_MAPPED, pgmUnlock(pVM), VERR_WRONG_ORDER);
+    AssertReturnStmt(fOldFlags & PGMREGMMIO2RANGE_F_MAPPED, PGM_UNLOCK(pVM), VERR_WRONG_ORDER);
 
     /*
@@ -3603 +3603 @@
         PPGMREGMMIO2RANGE pCurMmio = pFirstMmio;
         rc = pgmHandlerPhysicalExDeregister(pVM, pFirstMmio->pPhysHandlerR3, RT_BOOL(fOldFlags & PGMREGMMIO2RANGE_F_OVERLAPPING));
-        AssertRCReturnStmt(rc, pgmUnlock(pVM), rc);
+        AssertRCReturnStmt(rc, PGM_UNLOCK(pVM), rc);
         while (!(pCurMmio->fFlags & PGMREGMMIO2RANGE_F_LAST_CHUNK))
         {
             pCurMmio = pCurMmio->pNextR3;
             rc = pgmHandlerPhysicalExDeregister(pVM, pCurMmio->pPhysHandlerR3, RT_BOOL(fOldFlags & PGMREGMMIO2RANGE_F_OVERLAPPING));
-            AssertRCReturnStmt(rc, pgmUnlock(pVM), VERR_PGM_PHYS_MMIO_EX_IPE);
+            AssertRCReturnStmt(rc, PGM_UNLOCK(pVM), VERR_PGM_PHYS_MMIO_EX_IPE);
         }
     }
@@ -3686 +3686 @@
     rc = NEMR3NotifyPhysMmioExUnmap(pVM, GCPhysRangeNotify, cbRange, fNemFlags);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -3723 +3723 @@
                           VERR_VM_INVALID_VM_STATE);
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
@@ -3762 +3762 @@
         rc = VERR_NOT_FOUND;
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -3786 +3786 @@
      * Just do this the simple way.  No need for locking as this is only taken at
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMREGMMIO2RANGE pFirstMmio = pgmR3PhysMmio2Find(pVM, pDevIns, UINT32_MAX, UINT32_MAX, hMmio2);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     AssertReturn(pFirstMmio, VERR_INVALID_HANDLE);
     AssertReturn(pFirstMmio->fFlags & PGMREGMMIO2RANGE_F_MMIO2, VERR_INVALID_HANDLE);
@@ -3822 +3822 @@
     AssertReturn(iRegion <= UINT8_MAX, VERR_INVALID_PARAMETER);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PPGMREGMMIO2RANGE pCurMmio = pgmR3PhysMmio2Find(pVM, pDevIns, iSubDev, iRegion, NIL_PGMMMIO2HANDLE);
     AssertReturn(pCurMmio, VERR_NOT_FOUND);
@@ -3837 +3837 @@
     PCPGMPAGE pPage = &pCurMmio->RamRange.aPages[off >> PAGE_SHIFT];
     *pHCPhys = PGM_PAGE_GET_HCPHYS(pPage);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -3892 +3892 @@
     AssertReturn(pVM->enmVMState == VMSTATE_LOADING, VERR_INVALID_STATE);
 
-    int rc = pgmLock(pVM);
+    int rc = PGM_LOCK(pVM);
     AssertRCReturn(rc, rc);
 
     PPGMREGMMIO2RANGE pFirstRegMmio = pgmR3PhysMmio2Find(pVM, pDevIns, UINT32_MAX, UINT32_MAX, hMmio2);
-    AssertReturnStmt(pFirstRegMmio, pgmUnlock(pVM), VERR_NOT_FOUND);
+    AssertReturnStmt(pFirstRegMmio, PGM_UNLOCK(pVM), VERR_NOT_FOUND);
     AssertReturnStmt(pgmR3PhysMmio2Find(pVM, pDevIns, pFirstRegMmio->iSubDev, iNewRegion, NIL_PGMMMIO2HANDLE) == NULL,
-                     pgmUnlock(pVM), VERR_RESOURCE_IN_USE);
+                     PGM_UNLOCK(pVM), VERR_RESOURCE_IN_USE);
 
     /*
@@ -3905 +3905 @@
     pFirstRegMmio->iRegion = (uint8_t)iNewRegion;
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -4272 +4272 @@
     Log(("PGMR3PhysRomRegister: pDevIns=%p GCPhys=%RGp(-%RGp) cb=%RGp pvBinary=%p cbBinary=%#x fFlags=%#x pszDesc=%s\n",
          pDevIns, GCPhys, GCPhys + cb, cb, pvBinary, cbBinary, fFlags, pszDesc));
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     int rc = pgmR3PhysRomRegisterLocked(pVM, pDevIns, GCPhys, cb, pvBinary, cbBinary, fFlags, pszDesc);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -4456 +4456 @@
      * Process the request.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     int  rc = VINF_SUCCESS;
     bool fFlushTLB = false;
@@ -4517 +4517 @@
                 if (RT_FAILURE(rc2))
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     AssertRC(rc);
                     return rc2;
@@ -4527 +4527 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     if (fFlushTLB)
         PGM_INVL_ALL_VCPU_TLBS(pVM);
@@ -4704 +4704 @@
 {
     int rc = VINF_SUCCESS;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     NOREF(pVCpu); NOREF(pvUser);
 
@@ -4777 +4777 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -4933 +4933 @@
     int rc;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     rc = pgmR3PhysChunkMap(pVM, idChunk, &pChunk);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -4947 +4947 @@
 VMMR3DECL(void) PGMR3PhysChunkInvalidateTLB(PVM pVM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (unsigned i = 0; i < RT_ELEMENTS(pVM->pgm.s.ChunkR3Map.Tlb.aEntries); i++)
     {
@@ -4955 +4955 @@
     /* The page map TLB references chunks, so invalidate that one too. */
     pgmPhysInvalidatePageMapTLB(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -4975 +4975 @@
     uint64_t u64TimeStamp1, u64TimeStamp2;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     STAM_PROFILE_START(&pVM->pgm.s.CTX_SUFF(pStats)->StatAllocLargePage, a);
@@ -5072 +5072 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 #else
@@ -5102 +5102 @@
 VMMR3DECL(int) PGMR3PhysAllocateHandyPages(PVM pVM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     /*
@@ -5251 +5251 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -5406 +5406 @@
 VMMR3DECL(int) PGMR3PhysTlbGCPhys2Ptr(PVM pVM, RTGCPHYS GCPhys, bool fWritable, void **ppv)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     PGM_A20_ASSERT_MASKED(VMMGetCpu(pVM), GCPhys);
 
@@ -5482 +5482 @@
         rc = VERR_PGM_PHYS_TLB_UNASSIGNED;
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }

trunk/src/VBox/VMM/VMMR3/PGMPool.cpp

@@ -514 +514 @@
     NOREF(pVCpu);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     Log(("pgmR3PoolClearAllRendezvous: cUsedPages=%d fpvFlushRemTlb=%RTbool\n", pPool->cUsedPages, !!fpvFlushRemTlb));
 
@@ -729 +729 @@
     VM_FF_CLEAR(pVM, VM_FF_PGM_POOL_FLUSH_PENDING);
     pPool->cPresent = 0;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     PGM_INVL_ALL_VCPU_TLBS(pVM);

trunk/src/VBox/VMM/VMMR3/PGMSavedState.cpp

@@ -237 +237 @@
      * Initialize the live save tracking in the ROM page descriptors.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
     {
@@ -271 +271 @@
             pVM->pgm.s.LiveSave.Rom.cDirtyPages += cPages;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return VINF_SUCCESS;
@@ -286 +286 @@
 static int pgmR3SaveRomRanges(PVM pVM, PSSMHANDLE pSSM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     uint8_t id = 1;
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3, id++)
@@ -301 +301 @@
             break;
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return SSMR3PutU8(pSSM, UINT8_MAX);
 }
@@ -402 +402 @@
      * The shadow ROMs.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
     {
@@ -427 +427 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -444 +444 @@
 static int pgmR3SaveRomVirginPages(PVM pVM, PSSMHANDLE pSSM, bool fLiveSave)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
     {
@@ -473 +473 @@
             else
                 ASMMemZeroPage(abPage);
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
             AssertLogRelMsgRCReturn(rc, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys), rc);
 
@@ -491 +491 @@
 
             /* Update state. */
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
             pRom->aPages[iPage].LiveSave.u8Prot = (uint8_t)enmProt;
             if (fLiveSave)
@@ -501 +501 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -525 +525 @@
      * ASSUMES that all the ROM ranges are mapped.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
     {
@@ -565 +565 @@
                         pVM->pgm.s.LiveSave.cSavedPages++;
                     }
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     AssertLogRelMsgRCReturn(rc, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys), rc);
 
@@ -582 +582 @@
                         return rc;
 
-                    pgmLock(pVM);
+                    PGM_LOCK_VOID(pVM);
                     iPrevPage = iPage;
                 }
@@ -593 +593 @@
                     PGMROMPROT enmProt = pRomPage->enmProt;
                     pRomPage->LiveSave.u8Prot = (uint8_t)enmProt;
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
 
                     if (iPage - 1U == iPrevPage && iPage > 0)
@@ -607 +607 @@
                         return rc;
 
-                    pgmLock(pVM);
+                    PGM_LOCK_VOID(pVM);
                     iPrevPage = iPage;
                 }
@@ -613 +613 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -641 +641 @@
      * ASSUME nothing changes here.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMREGMMIO2RANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
     {
@@ -647 +647 @@
         {
             uint32_t const  cPages = pRegMmio->RamRange.cb >> PAGE_SHIFT;
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
 
             PPGMLIVESAVEMMIO2PAGE paLSPages = (PPGMLIVESAVEMMIO2PAGE)MMR3HeapAllocZ(pVM, MM_TAG_PGM, sizeof(PGMLIVESAVEMMIO2PAGE) * cPages);
@@ -662 +662 @@
             }
 
-            pgmLock(pVM);
+            PGM_LOCK_VOID(pVM);
             pRegMmio->paLSPages = paLSPages;
             pVM->pgm.s.LiveSave.Mmio2.cDirtyPages += cPages;
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return VINF_SUCCESS;
 }
@@ -681 +681 @@
 static int pgmR3SaveMmio2Ranges(PVM pVM, PSSMHANDLE pSSM)
 {
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     uint8_t id = 1;
     for (PPGMREGMMIO2RANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
@@ -699 +699 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return SSMR3PutU8(pSSM, UINT8_MAX);
 }
@@ -883 +883 @@
         return;
 
-    pgmLock(pVM);                       /* paranoia */
+    PGM_LOCK_VOID(pVM);                 /* paranoia */
     for (PPGMREGMMIO2RANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
         if (pRegMmio->fFlags & PGMREGMMIO2RANGE_F_MMIO2)
@@ -889 +889 @@
             PPGMLIVESAVEMMIO2PAGE paLSPages = pRegMmio->paLSPages;
             uint32_t              cPages    = pRegMmio->RamRange.cb >> PAGE_SHIFT;
-            pgmUnlock(pVM);
+            PGM_UNLOCK(pVM);
 
             for (uint32_t iPage = 0; iPage < cPages; iPage++)
@@ -897 +897 @@
             }
 
-            pgmLock(pVM);
-        }
-    pgmUnlock(pVM);
+            PGM_LOCK_VOID(pVM);
+        }
+    PGM_UNLOCK(pVM);
 
 }
@@ -924 +924 @@
          * The mop up round.
          */
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
         for (PPGMREGMMIO2RANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3;
              pRegMmio && RT_SUCCESS(rc);
@@ -972 +972 @@
                 }
             }
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
     }
     /*
@@ -982 +982 @@
              || (uPass & 3) == 2)
     {
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
         for (PPGMREGMMIO2RANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3;
              pRegMmio && RT_SUCCESS(rc);
@@ -992 +992 @@
                 uint32_t              cPages    = pRegMmio->RamRange.cb >> PAGE_SHIFT;
                 uint32_t              iPageLast = cPages;
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
 
                 for (uint32_t iPage = 0; iPage < cPages; iPage++, pbPage += PAGE_SIZE)
@@ -1037 +1037 @@
                 }
 
-                pgmLock(pVM);
-            }
-        pgmUnlock(pVM);
+                PGM_LOCK_VOID(pVM);
+            }
+        PGM_UNLOCK(pVM);
     }
 
@@ -1057 +1057 @@
      * We do the freeing outside the lock in case the VM is running.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (PPGMREGMMIO2RANGE pRegMmio = pVM->pgm.s.pRegMmioRangesR3; pRegMmio; pRegMmio = pRegMmio->pNextR3)
         if (pRegMmio->fFlags & PGMREGMMIO2RANGE_F_MMIO2)
@@ -1065 +1065 @@
             {
                 pRegMmio->paLSPages = NULL;
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 MMR3HeapFree(pvMmio2ToFree);
-                pgmLock(pVM);
-            }
-        }
-    pgmUnlock(pVM);
+                PGM_LOCK_VOID(pVM);
+            }
+        }
+    PGM_UNLOCK(pVM);
 }
 
@@ -1094 +1094 @@
      */
     PPGMRAMRANGE pCur;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     do
     {
@@ -1104 +1104 @@
                 uint32_t const  idRamRangesGen = pVM->pgm.s.idRamRangesGen;
                 uint32_t const  cPages = pCur->cb >> PAGE_SHIFT;
-                pgmUnlock(pVM);
+                PGM_UNLOCK(pVM);
                 PPGMLIVESAVERAMPAGE paLSPages = (PPGMLIVESAVERAMPAGE)MMR3HeapAllocZ(pVM, MM_TAG_PGM, cPages * sizeof(PGMLIVESAVERAMPAGE));
                 if (!paLSPages)
                     return VERR_NO_MEMORY;
-                pgmLock(pVM);
+                PGM_LOCK_VOID(pVM);
                 if (pVM->pgm.s.idRamRangesGen != idRamRangesGen)
                 {
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     MMR3HeapFree(paLSPages);
-                    pgmLock(pVM);
+                    PGM_LOCK_VOID(pVM);
                     break;              /* try again */
                 }
@@ -1208 +1208 @@
         }
     } while (pCur);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return VINF_SUCCESS;
@@ -1359 +1359 @@
     RTGCPHYS GCPhysCur = 0;
     PPGMRAMRANGE pCur;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     do
     {
@@ -1549 +1549 @@
         } /* for each range */
     } while (pCur);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 }
 
@@ -1573 +1573 @@
     PPGMRAMRANGE pCur;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     do
     {
@@ -1668 +1668 @@
                             pgmPhysReleaseInternalPageMappingLock(pVM, &PgMpLck);
                         }
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
                         AssertLogRelMsgRCReturn(rc, ("rc=%Rrc GCPhys=%RGp\n", rc, GCPhys), rc);
 
@@ -1703 +1703 @@
                             pgmR3StateVerifyCrc32ForRamPage(pVM, pCur, paLSPages, iPage, "save#2");
 #endif
-                        pgmUnlock(pVM);
+                        PGM_UNLOCK(pVM);
 
                         uint8_t u8RecType = fBallooned ? PGM_STATE_REC_RAM_BALLOONED : PGM_STATE_REC_RAM_ZERO;
@@ -1717 +1717 @@
                         return rc;
 
-                    pgmLock(pVM);
+                    PGM_LOCK_VOID(pVM);
                     if (!fSkipped)
                         GCPhysLast = GCPhys;
@@ -1744 +1744 @@
     } while (pCur);
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return VINF_SUCCESS;
@@ -1768 +1768 @@
     PPGMRAMRANGE pCur;
     uint32_t cMonitoredPages = 0;
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     do
     {
@@ -1778 +1778 @@
                 {
                     uint32_t idRamRangesGen = pVM->pgm.s.idRamRangesGen;
-                    pgmUnlock(pVM);
+                    PGM_UNLOCK(pVM);
                     MMR3HeapFree(pvToFree);
                     pvToFree = NULL;
-                    pgmLock(pVM);
+                    PGM_LOCK_VOID(pVM);
                     if (idRamRangesGen != pVM->pgm.s.idRamRangesGen)
                         break;          /* start over again. */
@@ -1810 +1810 @@
         pVM->pgm.s.cMonitoredPages -= cMonitoredPages;
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     MMR3HeapFree(pvToFree);
@@ -1887 +1887 @@
 
     /* update history. */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     uint32_t const cWrittenToPages = pVM->pgm.s.cWrittenToPages;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     uint32_t const cDirtyNow = pVM->pgm.s.LiveSave.Rom.cDirtyPages
                              + pVM->pgm.s.LiveSave.Mmio2.cDirtyPages
@@ -1991 +1991 @@
      * Indicate that we will be using the write monitoring.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     /** @todo find a way of mediating this when more users are added. */
     if (pVM->pgm.s.fPhysWriteMonitoringEngaged)
     {
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         AssertLogRelFailedReturn(VERR_PGM_WRITE_MONITOR_ENGAGED);
     }
     pVM->pgm.s.fPhysWriteMonitoringEngaged = true;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     /*
@@ -2044 +2044 @@
      * Lock PGM and set the no-more-writes indicator.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     pVM->pgm.s.fNoMorePhysWrites = true;
 
@@ -2094 +2094 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -2117 +2117 @@
      * Clear the live save indicator and disengage write monitoring.
      */
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     pVM->pgm.s.LiveSave.fActive = false;
     /** @todo this is blindly assuming that we're the only user of write
      *        monitoring. Fix this when more users are added. */
     pVM->pgm.s.fPhysWriteMonitoringEngaged = false;
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     NOREF(pSSM);
@@ -3148 +3148 @@
     if (uPass != SSM_PASS_FINAL)
     {
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
         if (uPass != 0)
             rc = pgmR3LoadMemory(pVM, pSSM, uVersion, uPass);
@@ -3165 +3165 @@
                 rc = pgmR3LoadMemory(pVM, pSSM, uVersion, uPass);
         }
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
     }
     else
     {
-        pgmLock(pVM);
+        PGM_LOCK_VOID(pVM);
         rc = pgmR3LoadFinalLocked(pVM, pSSM, uVersion);
         pVM->pgm.s.LiveSave.fActive = false;
-        pgmUnlock(pVM);
+        PGM_UNLOCK(pVM);
         if (RT_SUCCESS(rc))
         {

trunk/src/VBox/VMM/VMMR3/PGMSharedPage.cpp

@@ -232 +232 @@
     LogFlow(("pgmR3SharedModuleRegRendezvous: start (%d)\n", pVM->pgm.s.cSharedPages));
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     pgmR3PhysAssertSharedPageChecksums(pVM);
     rc = GMMR3CheckSharedModules(pVM);
     pgmR3PhysAssertSharedPageChecksums(pVM);
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     AssertLogRelRC(rc);
 
@@ -291 +291 @@
     uint64_t fFlags;
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     int rc = PGMGstGetPage(VMMGetCpu(pVM), GCPtrPage, &fFlags, &GCPhys);
@@ -322 +322 @@
     }
 
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
     return rc;
 }
@@ -345 +345 @@
     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
 
     for (PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesXR3; pRam; pRam = pRam->pNextR3)
@@ -404 +404 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     pCmdHlp->pfnPrintf(pCmdHlp, NULL, "\nNumber of zero pages      %08x (%d MB)\n", cZero, cZero / 256);
@@ -425 +425 @@
     VM_ASSERT_VALID_EXT_RETURN(pVM, VERR_INVALID_VM_HANDLE);
 
-    pgmLock(pVM);
+    PGM_LOCK_VOID(pVM);
     for (unsigned i = 0; i < RT_ELEMENTS(g_apSharedModules); i++)
     {
@@ -435 +435 @@
         }
     }
-    pgmUnlock(pVM);
+    PGM_UNLOCK(pVM);
 
     return VINF_SUCCESS;

trunk/src/VBox/VMM/include/PGMInternal.h

@@ -3897 +3897 @@
 RT_C_DECLS_BEGIN
 
-#if defined(VBOX_STRICT) && defined(IN_RING3)
-int             pgmLockDebug(PVMCC pVM, RT_SRC_POS_DECL);
-# define pgmLock(a_pVM) pgmLockDebug(a_pVM, RT_SRC_POS)
+#if defined(VBOX_STRICT)
+int             pgmLockDebug(PVMCC pVM, bool fVoid, RT_SRC_POS_DECL);
+# define PGM_LOCK_VOID(a_pVM)       pgmLockDebug((a_pVM), true,  RT_SRC_POS)
+# define PGM_LOCK(a_pVM)            pgmLockDebug((a_pVM), false, RT_SRC_POS)
 #else
-int             pgmLock(PVMCC pVM);
+int             pgmLock(PVMCC pVM, bool fVoid);
+# define PGM_LOCK_VOID(a_pVM)       pgmLock((a_pVM), true)
+# define PGM_LOCK(a_pVM)            pgmLock((a_pVM), false)
 #endif
 void            pgmUnlock(PVMCC pVM);
+# define PGM_UNLOCK(a_pVM)          pgmUnlock((a_pVM))
 /**
  * Asserts that the caller owns the PDM lock.