Changeset 37354 in vbox for trunk/src/VBox/VMM/VMMR3

Timestamp:

Jun 7, 2011 3:05:32 PM (14 years ago)

Author:

vboxsync

Message:

PGM: Fixed locking issues in PGMR3PhysMMIORegister and PGMR3PhysMMIODeregister. Also addressed a harmless on in PGMR3PhysRomRegister (only used at init time, so no races). Fortified the code with assertions more lock assertion, replacing the incorrect PGMIsLocked() checks (we only care if the current thread is the lock owner). Cleaned up some ReturnStmt macros and adding more of them.

Location:

trunk/src/VBox/VMM/VMMR3

Files:

• PGM.cpp (modified) (1 diff)
• PGMPhys.cpp (modified) (49 diffs)
• PGMPool.cpp (modified) (2 diffs)
• PGMSavedState.cpp (modified) (9 diffs)

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

@@ -1327 +1327 @@
 
     PGMR3PhysChunkInvalidateTLB(pVM);
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
 
     /*

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

@@ -884 +884 @@
 static int pgmR3PhysFreePageRange(PVM pVM, PPGMRAMRANGE pRam, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast, uint8_t uType)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
     uint32_t            cPendingPages = 0;
     PGMMFREEPAGESREQ    pReq;
@@ -898 +898 @@
         AssertLogRelRCReturn(rc, rc); /* We're done for if this goes wrong. */
 
-        PGM_PAGE_SET_TYPE(pPageDst, uType);
+        PGM_PAGE_SET_TYPE(pVM, pPageDst, uType);
 
         GCPhys += PAGE_SIZE;
@@ -977 +977 @@
             }
             Assert(PGM_PAGE_IS_ZERO(pPage));
-            PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_BALLOONED);
+            PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_BALLOONED);
         }
 
@@ -1005 +1005 @@
 
             /* Change back to zero page. */
-            PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
+            PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ZERO);
         }
 
@@ -1153 +1153 @@
                         if (PGM_PAGE_IS_WRITTEN_TO(pPage))
                         {
-                            PGM_PAGE_CLEAR_WRITTEN_TO(pPage);
+                            PGM_PAGE_CLEAR_WRITTEN_TO(pVM, pPage);
                             /* Remember this dirty page for the next (memory) sync. */
                             PGM_PAGE_SET_FT_DIRTY(pPage);
@@ -1715 +1715 @@
         pgmR3PhysInitAndLinkRamRange(pVM, pNew, GCPhys, GCPhysLast, NIL_RTRCPTR, NIL_RTR0PTR, pszDesc, pPrev);
     }
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
     pgmUnlock(pVM);
 
@@ -1806 +1806 @@
 int pgmR3PhysRamReset(PVM pVM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
 
     /* Reset the memory balloon. */
@@ -1860 +1860 @@
                         {
                             /* Turn into a zero page; the balloon status is lost when the VM reboots. */
-                            PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
+                            PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ZERO);
                         }
                         else if (!PGM_PAGE_IS_ZERO(pPage))
@@ -1900 +1900 @@
                             case PGM_PAGE_STATE_BALLOONED:
                                 /* Turn into a zero page; the balloon status is lost when the VM reboots. */
-                                PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
+                                PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ZERO);
                                 break;
 
@@ -1962 +1962 @@
 int pgmR3PhysRamTerm(PVM pVM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
 
     /* Reset the memory balloon. */
@@ -2065 +2065 @@
     AssertReturn(*pszDesc, VERR_INVALID_PARAMETER);
 
+    int rc = pgmLock(pVM);
+    AssertRCReturn(rc, rc);
+
     /*
      * Make sure there's a RAM range structure for the region.
      */
-    int rc;
     RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
     bool fRamExists = false;
@@ -2079 +2081 @@
         {
             /* Simplification: all within the same range. */
-            AssertLogRelMsgReturn(   GCPhys     >= pRam->GCPhys
-                                  && GCPhysLast <= pRam->GCPhysLast,
-                                  ("%RGp-%RGp (MMIO/%s) falls partly outside %RGp-%RGp (%s)\n",
-                                   GCPhys, GCPhysLast, pszDesc,
-                                   pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
-                                  VERR_PGM_RAM_CONFLICT);
+            AssertLogRelMsgReturnStmt(   GCPhys     >= pRam->GCPhys
+                                      && GCPhysLast <= pRam->GCPhysLast,
+                                      ("%RGp-%RGp (MMIO/%s) falls partly outside %RGp-%RGp (%s)\n",
+                                       GCPhys, GCPhysLast, pszDesc,
+                                       pRam->GCPhys, pRam->GCPhysLast, pRam->pszDesc),
+                                      pgmUnlock(pVM),
+                                      VERR_PGM_RAM_CONFLICT);
 
             /* Check that it's all RAM or MMIO pages. */
@@ -2091 +2094 @@
             while (cLeft-- > 0)
             {
-                AssertLogRelMsgReturn(   PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM
-                                      || PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO,
-                                      ("%RGp-%RGp (MMIO/%s): %RGp is not a RAM or MMIO page - type=%d desc=%s\n",
-                                       GCPhys, GCPhysLast, pszDesc, PGM_PAGE_GET_TYPE(pPage), pRam->pszDesc),
-                                      VERR_PGM_RAM_CONFLICT);
+                AssertLogRelMsgReturnStmt(   PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM
+                                          || PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO,
+                                          ("%RGp-%RGp (MMIO/%s): %RGp is not a RAM or MMIO page - type=%d desc=%s\n",
+                                           GCPhys, GCPhysLast, pszDesc, PGM_PAGE_GET_TYPE(pPage), pRam->pszDesc),
+                                          pgmUnlock(pVM),
+                                          VERR_PGM_RAM_CONFLICT);
                 pPage++;
             }
@@ -2118 +2122 @@
          * for PCI memory, but we're doing the same thing for MMIO2 pages.
          */
-        rc = pgmLock(pVM);
-        if (RT_SUCCESS(rc))
-        {
-            rc = pgmR3PhysFreePageRange(pVM, pRam, GCPhys, GCPhysLast, PGMPAGETYPE_MMIO);
-            pgmUnlock(pVM);
-        }
-        AssertRCReturn(rc, rc);
+        rc = pgmR3PhysFreePageRange(pVM, pRam, GCPhys, GCPhysLast, PGMPAGETYPE_MMIO);
+        AssertRCReturnStmt(rc, pgmUnlock(pVM), rc);
 
         /* Force a PGM pool flush as guest ram references have been changed. */
-        /** todo; not entirely SMP safe; assuming for now the guest takes care of this internally (not touch mapped mmio while changing the mapping). */
+        /** @todo not entirely SMP safe; assuming for now the guest takes
+         *   care of this internally (not touch mapped mmio while changing the
+         *   mapping). */
         PVMCPU pVCpu = VMMGetCpu(pVM);
         pVCpu->pgm.s.fSyncFlags |= PGM_SYNC_CLEAR_PGM_POOL;
@@ -2134 +2135 @@
     else
     {
-        pgmLock(pVM);
 
         /*
@@ -2147 +2147 @@
         const size_t cbRamRange = RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]);
         rc = MMHyperAlloc(pVM, RT_OFFSETOF(PGMRAMRANGE, aPages[cPages]), 16, MM_TAG_PGM_PHYS, (void **)&pNew);
-        AssertLogRelMsgRCReturn(rc, ("cbRamRange=%zu\n", cbRamRange), rc);
+        AssertLogRelMsgRCReturnStmt(rc, ("cbRamRange=%zu\n", cbRamRange), pgmUnlock(pVM), rc);
 
         /* Initialize the range. */
@@ -2171 +2171 @@
         /* link it */
         pgmR3PhysLinkRamRange(pVM, pNew, pRamPrev);
-
-        pgmUnlock(pVM);
     }
 
@@ -2193 +2191 @@
         MMHyperFree(pVM, pRam);
     }
-    PGMPhysInvalidatePageMapTLB(pVM);
-
+    pgmPhysInvalidatePageMapTLB(pVM);
+
+    pgmUnlock(pVM);
     return rc;
 }
@@ -2214 +2213 @@
     VM_ASSERT_EMT(pVM);
 
-/** @todo this needs to own the PGM lock! */
+    int rc = pgmLock(pVM);
+    AssertRCReturn(rc, rc);
+
     /*
      * First deregister the handler, then check if we should remove the ram range.
      */
-    int rc = PGMHandlerPhysicalDeregister(pVM, GCPhys);
+    rc = PGMHandlerPhysicalDeregister(pVM, GCPhys);
     if (RT_SUCCESS(rc))
     {
@@ -2291 +2292 @@
                     AssertMsg(PGM_PAGE_IS_ZERO(pPage), ("%RGp %R[pgmpage]\n", pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), pPage));
                     if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO)
-                        PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_RAM);
+                        PGM_PAGE_SET_TYPE(pVM, pPage, PGMPAGETYPE_RAM);
                 }
                 break;
@@ -2308 +2309 @@
     VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
 
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
     pgmPhysInvalidRamRangeTlbs(pVM);
+    pgmUnlock(pVM);
     return rc;
 }
@@ -2459 +2461 @@
                 *ppv = pvPages;
                 RTMemTmpFree(paPages);
-                PGMPhysInvalidatePageMapTLB(pVM);
+                pgmPhysInvalidatePageMapTLB(pVM);
                 return VINF_SUCCESS;
             }
@@ -2571 +2573 @@
         }
     }
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
     pgmUnlock(pVM);
     return !cFound && iRegion != UINT32_MAX ? VERR_NOT_FOUND : rc;
@@ -2681 +2683 @@
 
             RTHCPHYS const HCPhys = PGM_PAGE_GET_HCPHYS(pPageSrc);
-            PGM_PAGE_SET_HCPHYS(pPageDst, HCPhys);
-            PGM_PAGE_SET_TYPE(pPageDst, PGMPAGETYPE_MMIO2);
-            PGM_PAGE_SET_STATE(pPageDst, PGM_PAGE_STATE_ALLOCATED);
-            PGM_PAGE_SET_PDE_TYPE(pPageDst, PGM_PAGE_PDE_TYPE_DONTCARE);
-            PGM_PAGE_SET_PTE_INDEX(pPageDst, 0);
-            PGM_PAGE_SET_TRACKING(pPageDst, 0);
+            PGM_PAGE_SET_HCPHYS(pVM, pPageDst, HCPhys);
+            PGM_PAGE_SET_TYPE(pVM, pPageDst, PGMPAGETYPE_MMIO2);
+            PGM_PAGE_SET_STATE(pVM, pPageDst, PGM_PAGE_STATE_ALLOCATED);
+            PGM_PAGE_SET_PDE_TYPE(pVM, pPageDst, PGM_PAGE_PDE_TYPE_DONTCARE);
+            PGM_PAGE_SET_PTE_INDEX(pVM, pPageDst, 0);
+            PGM_PAGE_SET_TRACKING(pVM, pPageDst, 0);
 
             pVM->pgm.s.cZeroPages--;
@@ -2695 +2697 @@
 
         /* Flush physical page map TLB. */
-        PGMPhysInvalidatePageMapTLB(pVM);
+        pgmPhysInvalidatePageMapTLB(pVM);
 
         if (cPendingPages)
@@ -2721 +2723 @@
         while (cPagesLeft-- > 0)
         {
-            PGM_PAGE_SET_TRACKING(pPageSrc, 0);
-            PGM_PAGE_SET_PTE_INDEX(pPageSrc, 0);
+            PGM_PAGE_SET_TRACKING(pVM, pPageSrc, 0);
+            PGM_PAGE_SET_PTE_INDEX(pVM, pPageSrc, 0);
             pPageSrc++;
         }
@@ -2733 +2735 @@
     }
 
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
     return VINF_SUCCESS;
 }
@@ -2791 +2793 @@
 
         /* Flush physical page map TLB. */
-        PGMPhysInvalidatePageMapTLB(pVM);
+        pgmPhysInvalidatePageMapTLB(pVM);
 
         GCPhysRangeREM = NIL_RTGCPHYS;  /* shuts up gcc */
@@ -2817 +2819 @@
     VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
 
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
     pgmPhysInvalidRamRangeTlbs(pVM);
     pgmUnlock(pVM);
@@ -2939 +2941 @@
 
 /**
- * Registers a ROM image.
- *
- * Shadowed ROM images requires double the amount of backing memory, so,
- * don't use that unless you have to. Shadowing of ROM images is process
- * where we can select where the reads go and where the writes go. On real
- * hardware the chipset provides means to configure this. We provide
- * PGMR3PhysProtectROM() for this purpose.
- *
- * A read-only copy of the ROM image will always be kept around while we
- * will allocate RAM pages for the changes on demand (unless all memory
- * is configured to be preallocated).
+ * Worker for PGMR3PhysRomRegister.
+ *
+ * This is here to simplify lock management, i.e. the caller does all the
+ * locking and we can simply return without needing to remember to unlock
+ * anything first.
  *
  * @returns VBox status.
@@ -2964 +2960 @@
  *                              and/or PGMPHYS_ROM_FLAGS_PERMANENT_BINARY.
  * @param   pszDesc             Pointer to description string. This must not be freed.
- *
- * @remark  There is no way to remove the rom, automatically on device cleanup or
- *          manually from the device yet. This isn't difficult in any way, it's
- *          just not something we expect to be necessary for a while.
- */
-VMMR3DECL(int) PGMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cb,
-                                    const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc)
-{
-    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));
-
+ */
+static int pgmR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cb,
+                                const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc)
+{
     /*
      * Validate input.
@@ -3082 +3071 @@
     }
 
-    pgmLock(pVM);
     rc = GMMR3AllocatePagesPerform(pVM, pReq);
-    pgmUnlock(pVM);
     if (RT_FAILURE(rc))
     {
@@ -3103 +3090 @@
         if (RT_SUCCESS(rc))
         {
-            pgmLock(pVM);
-
             /*
              * Initialize and insert the RAM range (if required).
@@ -3141 +3126 @@
                 for (uint32_t iPage = 0; iPage < cPages; iPage++, pPage++, pRomPage++)
                 {
-                    PGM_PAGE_SET_TYPE(pPage,   PGMPAGETYPE_ROM);
-                    PGM_PAGE_SET_HCPHYS(pPage, pReq->aPages[iPage].HCPhysGCPhys);
-                    PGM_PAGE_SET_STATE(pPage,  PGM_PAGE_STATE_ALLOCATED);
-                    PGM_PAGE_SET_PAGEID(pPage, pReq->aPages[iPage].idPage);
-                    PGM_PAGE_SET_PDE_TYPE(pPage, PGM_PAGE_PDE_TYPE_DONTCARE);
-                    PGM_PAGE_SET_PTE_INDEX(pPage, 0);
-                    PGM_PAGE_SET_TRACKING(pPage, 0);
+                    PGM_PAGE_SET_TYPE(pVM, pPage,   PGMPAGETYPE_ROM);
+                    PGM_PAGE_SET_HCPHYS(pVM, pPage, pReq->aPages[iPage].HCPhysGCPhys);
+                    PGM_PAGE_SET_STATE(pVM, pPage,  PGM_PAGE_STATE_ALLOCATED);
+                    PGM_PAGE_SET_PAGEID(pVM, pPage, pReq->aPages[iPage].idPage);
+                    PGM_PAGE_SET_PDE_TYPE(pVM, pPage, PGM_PAGE_PDE_TYPE_DONTCARE);
+                    PGM_PAGE_SET_PTE_INDEX(pVM, pPage, 0);
+                    PGM_PAGE_SET_TRACKING(pVM, pPage, 0);
 
                     pRomPage->Virgin = *pPage;
@@ -3159 +3144 @@
 
             /* Flush physical page map TLB. */
-            PGMPhysInvalidatePageMapTLB(pVM);
-
-            pgmUnlock(pVM);
+            pgmPhysInvalidatePageMapTLB(pVM);
 
 
@@ -3199 +3182 @@
             if (RT_SUCCESS(rc))
             {
-                pgmLock(pVM);
-
                 /*
                  * Copy the image over to the virgin pages.
@@ -3285 +3266 @@
                     }
 
-                    PGMPhysInvalidatePageMapTLB(pVM);
+                    pgmPhysInvalidatePageMapTLB(pVM);
                     GMMR3AllocatePagesCleanup(pReq);
-                    pgmUnlock(pVM);
                     return VINF_SUCCESS;
                 }
@@ -3293 +3273 @@
                 /* bail out */
 
-                pgmUnlock(pVM);
                 int rc2 = PGMHandlerPhysicalDeregister(pVM, GCPhys);
                 AssertRC(rc2);
-                pgmLock(pVM);
             }
 
@@ -3311 +3289 @@
     GMMR3FreeAllocatedPages(pVM, pReq);
     GMMR3AllocatePagesCleanup(pReq);
+    return rc;
+}
+
+
+/**
+ * Registers a ROM image.
+ *
+ * Shadowed ROM images requires double the amount of backing memory, so,
+ * don't use that unless you have to. Shadowing of ROM images is process
+ * where we can select where the reads go and where the writes go. On real
+ * hardware the chipset provides means to configure this. We provide
+ * PGMR3PhysProtectROM() for this purpose.
+ *
+ * A read-only copy of the ROM image will always be kept around while we
+ * will allocate RAM pages for the changes on demand (unless all memory
+ * is configured to be preallocated).
+ *
+ * @returns VBox status.
+ * @param   pVM                 VM Handle.
+ * @param   pDevIns             The device instance owning the ROM.
+ * @param   GCPhys              First physical address in the range.
+ *                              Must be page aligned!
+ * @param   cb                  The size of the range (in bytes).
+ *                              Must be page aligned!
+ * @param   pvBinary            Pointer to the binary data backing the ROM image.
+ * @param   cbBinary            The size of the binary data pvBinary points to.
+ *                              This must be less or equal to @a cb.
+ * @param   fFlags              Mask of flags. PGMPHYS_ROM_FLAGS_SHADOWED
+ *                              and/or PGMPHYS_ROM_FLAGS_PERMANENT_BINARY.
+ * @param   pszDesc             Pointer to description string. This must not be freed.
+ *
+ * @remark  There is no way to remove the rom, automatically on device cleanup or
+ *          manually from the device yet. This isn't difficult in any way, it's
+ *          just not something we expect to be necessary for a while.
+ */
+VMMR3DECL(int) PGMR3PhysRomRegister(PVM pVM, PPDMDEVINS pDevIns, RTGCPHYS GCPhys, RTGCPHYS cb,
+                                    const void *pvBinary, uint32_t cbBinary, uint32_t fFlags, const char *pszDesc)
+{
+    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);
+    int rc = pgmR3PhysRomRegister(pVM, pDevIns, GCPhys, cb, pvBinary, cbBinary, fFlags, pszDesc);
     pgmUnlock(pVM);
     return rc;
@@ -3428 +3448 @@
 int pgmR3PhysRomReset(PVM pVM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
     {
@@ -3671 +3691 @@
 static DECLCALLBACK(int) pgmR3PhysChunkAgeingRolloverCallback(PAVLU32NODECORE pNode, void *pvUser)
 {
-    Assert(PGMIsLockOwner((PVM)pvUser));
+    PGM_LOCK_ASSERT_OWNER(pVM);
+
     /* Age compression - ASSUMES iNow == 4. */
     PPGMCHUNKR3MAP pChunk = (PPGMCHUNKR3MAP)pNode;
@@ -3785 +3806 @@
 static int32_t pgmR3PhysChunkFindUnmapCandidate(PVM pVM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
 
     /*
@@ -3935 +3956 @@
     int rc;
 
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
+
     /*
      * Allocate a new tracking structure first.
@@ -4037 +4059 @@
     }
     /* The page map TLB references chunks, so invalidate that one too. */
-    PGMPhysInvalidatePageMapTLB(pVM);
+    pgmPhysInvalidatePageMapTLB(pVM);
     pgmUnlock(pVM);
 }
@@ -4106 +4128 @@
                  */
                 pVM->pgm.s.cPrivatePages++;
-                PGM_PAGE_SET_HCPHYS(pPage, HCPhys);
-                PGM_PAGE_SET_PAGEID(pPage, idPage);
-                PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
-                PGM_PAGE_SET_PDE_TYPE(pPage, PGM_PAGE_PDE_TYPE_PDE);
-                PGM_PAGE_SET_PTE_INDEX(pPage, 0);
-                PGM_PAGE_SET_TRACKING(pPage, 0);
+                PGM_PAGE_SET_HCPHYS(pVM, pPage, HCPhys);
+                PGM_PAGE_SET_PAGEID(pVM, pPage, idPage);
+                PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ALLOCATED);
+                PGM_PAGE_SET_PDE_TYPE(pVM, pPage, PGM_PAGE_PDE_TYPE_PDE);
+                PGM_PAGE_SET_PTE_INDEX(pVM, pPage, 0);
+                PGM_PAGE_SET_TRACKING(pVM, pPage, 0);
 
                 /* Somewhat dirty assumption that page ids are increasing. */
@@ -4127 +4149 @@
             /* Flush all TLBs. */
             PGM_INVL_ALL_VCPU_TLBS(pVM);
-            PGMPhysInvalidatePageMapTLB(pVM);
+            pgmPhysInvalidatePageMapTLB(pVM);
         }
         pVM->pgm.s.cLargeHandyPages = 0;
@@ -4323 +4345 @@
      * Assert sanity.
      */
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
     if (RT_UNLIKELY(    PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_RAM
                     &&  PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_ROM_SHADOW))
@@ -4359 +4381 @@
     if (PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED)
     {
-        PGM_PAGE_SET_WRITTEN_TO(pPage);
+        PGM_PAGE_SET_WRITTEN_TO(pVM, pPage);
         pVM->pgm.s.cWrittenToPages++;
     }
@@ -4366 +4388 @@
      * pPage = ZERO page.
      */
-    PGM_PAGE_SET_HCPHYS(pPage, pVM->pgm.s.HCPhysZeroPg);
-    PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
-    PGM_PAGE_SET_PAGEID(pPage, NIL_GMM_PAGEID);
-    PGM_PAGE_SET_PDE_TYPE(pPage, PGM_PAGE_PDE_TYPE_DONTCARE);
-    PGM_PAGE_SET_PTE_INDEX(pPage, 0);
-    PGM_PAGE_SET_TRACKING(pPage, 0);
+    PGM_PAGE_SET_HCPHYS(pVM, pPage, pVM->pgm.s.HCPhysZeroPg);
+    PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ZERO);
+    PGM_PAGE_SET_PAGEID(pVM, pPage, NIL_GMM_PAGEID);
+    PGM_PAGE_SET_PDE_TYPE(pVM, pPage, PGM_PAGE_PDE_TYPE_DONTCARE);
+    PGM_PAGE_SET_PTE_INDEX(pVM, pPage, 0);
+    PGM_PAGE_SET_TRACKING(pVM, pPage, 0);
 
     /* Flush physical page map TLB entry. */
-    PGMPhysInvalidatePageMapTLBEntry(pVM, GCPhys);
+    pgmPhysInvalidatePageMapTLBEntry(pVM, GCPhys);
 
     /*

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

@@ -809 +809 @@
         iPage = pRam->cb >> PAGE_SHIFT;
         while (iPage-- > 0)
-            PGM_PAGE_SET_TRACKING(&pRam->aPages[iPage], 0);
+            PGM_PAGE_SET_TRACKING(pVM, &pRam->aPages[iPage], 0);
     }
 
@@ -906 +906 @@
 void pgmR3PoolWriteProtectPages(PVM pVM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
     PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
     unsigned cLeft = pPool->cUsedPages;

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

@@ -282 +282 @@
 static int pgmR3LoadRomRanges(PVM pVM, PSSMHANDLE pSSM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
 
     for (PPGMROMRANGE pRom = pVM->pgm.s.pRomRangesR3; pRom; pRom = pRom->pNextR3)
@@ -673 +673 @@
 static int pgmR3LoadMmio2Ranges(PVM pVM, PSSMHANDLE pSSM)
 {
-    Assert(PGMIsLockOwner(pVM));
+    PGM_LOCK_ASSERT_OWNER(pVM);
 
     for (PPGMMMIO2RANGE pMmio2 = pVM->pgm.s.pMmio2RangesR3; pMmio2; pMmio2 = pMmio2->pNextR3)
@@ -1344 +1344 @@
                                 {
                                     Assert(paLSPages[iPage].fWriteMonitored);
-                                    PGM_PAGE_CLEAR_WRITTEN_TO(&pCur->aPages[iPage]);
+                                    PGM_PAGE_CLEAR_WRITTEN_TO(pVM, &pCur->aPages[iPage]);
                                     Assert(pVM->pgm.s.cWrittenToPages > 0);
                                     pVM->pgm.s.cWrittenToPages--;
@@ -1472 +1472 @@
                             {
                                 AssertMsgFailed(("%R[pgmpage]", &pCur->aPages[iPage])); /* shouldn't happen. */
-                                PGM_PAGE_SET_STATE(&pCur->aPages[iPage], PGM_PAGE_STATE_ALLOCATED);
+                                PGM_PAGE_SET_STATE(pVM, &pCur->aPages[iPage], PGM_PAGE_STATE_ALLOCATED);
                                 Assert(pVM->pgm.s.cMonitoredPages > 0);
                                 pVM->pgm.s.cMonitoredPages--;
@@ -1478 +1478 @@
                             if (PGM_PAGE_IS_WRITTEN_TO(&pCur->aPages[iPage]))
                             {
-                                PGM_PAGE_CLEAR_WRITTEN_TO(&pCur->aPages[iPage]);
+                                PGM_PAGE_CLEAR_WRITTEN_TO(pVM, &pCur->aPages[iPage]);
                                 Assert(pVM->pgm.s.cWrittenToPages > 0);
                                 pVM->pgm.s.cWrittenToPages--;
@@ -1639 +1639 @@
                                     }
                                     rc = SSMR3PutMem(pSSM, abPage, PAGE_SIZE);
-                                    PGM_PAGE_CLEAR_WRITTEN_TO(pCurPage);
+                                    PGM_PAGE_CLEAR_WRITTEN_TO(pVM, pCurPage);
                                     PGM_PAGE_CLEAR_FT_DIRTY(pCurPage);
                                 }
@@ -1768 +1768 @@
                 {
                     PPGMPAGE pPage = &pCur->aPages[iPage];
-                    PGM_PAGE_CLEAR_WRITTEN_TO(pPage);
+                    PGM_PAGE_CLEAR_WRITTEN_TO(pVM, pPage);
                     if (PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_WRITE_MONITORED)
                     {
-                        PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
+                        PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ALLOCATED);
                         cMonitoredPages++;
                     }
@@ -2667 +2667 @@
                             if (uVersion == PGM_SAVED_STATE_VERSION_BALLOON_BROKEN)
                                 break;
-                            PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
+                            PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_ZERO);
                             break;
                         }
@@ -2714 +2714 @@
                         }
                         Assert(PGM_PAGE_IS_ZERO(pPage));
-                        PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_BALLOONED);
+                        PGM_PAGE_SET_STATE(pVM, pPage, PGM_PAGE_STATE_BALLOONED);
                         break;
                     }