儲存庫 vbox 的更動 18230

時間撮記:

2009-3-25 上午01:13:09 (16 年 以前)

作者:

vboxsync

訊息:

PGM,IOM: Implemented MMIO2 aliases for MMIO pages. This involved some forgotten changes to the MMIO implementation too - changing the page type to MMIO, freeing the backing RAM page.

位置:

trunk

檔案:

• include/VBox/err.h (修改) (1 筆差異)
• src/VBox/VMM/PGMInternal.h (修改) (1 筆差異)
• src/VBox/VMM/PGMPhys.cpp (修改) (10 筆差異)
• src/VBox/VMM/VMMAll/IOMAllMMIO.cpp (修改) (4 筆差異)
• src/VBox/VMM/VMMAll/PGMAllHandler.cpp (修改) (11 筆差異)
• src/VBox/VMM/VMMAll/PGMAllPhys.cpp (修改) (1 筆差異)

trunk/include/VBox/err.h

@@ -433 +433 @@
 /** No CR3 root shadow page table.. */
 #define VERR_PGM_NO_CR3_SHADOW_ROOT             (-1636)
+/** Trying to free a page with an invalid Page ID. */
+#define VERR_PGM_PHYS_INVALID_PAGE_ID           (-1637)
+/** PGMPhysWrite/Read hit a handler in Ring-0 or raw-mode context. */
+#define VERR_PGM_PHYS_WR_HIT_HANDLER            (-1638)
 /** Trying to free a page that isn't RAM. */
-#define VERR_PGM_PHYS_NOT_RAM                   (-1637)
-/** Trying to free a page with an invalid Page ID. */
-#define VERR_PGM_PHYS_INVALID_PAGE_ID           (-1638)
-/** PGMPhysWrite/Read hit a handler in Ring-0 or raw-mode context. */
-#define VERR_PGM_PHYS_WR_HIT_HANDLER            (-1639)
+#define VERR_PGM_PHYS_NOT_RAM                   (-1639)
+/** Not ROM page. */
+#define VERR_PGM_PHYS_NOT_ROM                   (-1640)
+/** Not MMIO page. */
+#define VERR_PGM_PHYS_NOT_MMIO                  (-1641)
+/** Not MMIO2 page. */
+#define VERR_PGM_PHYS_NOT_MMIO2                 (-1642)
+/** Already aliased to a different page. */
+#define VERR_PGM_HANDLER_ALREADY_ALIASED        (-1643)
+/** Already aliased to the same page. */
+#define VINF_PGM_HANDLER_ALREADY_ALIASED        (1643)
 /** @} */
 

trunk/src/VBox/VMM/PGMInternal.h

@@ -2867 +2867 @@
 void            pgmR3HandlerPhysicalUpdateAll(PVM pVM);
 bool            pgmHandlerPhysicalIsAll(PVM pVM, RTGCPHYS GCPhys);
+void            pgmHandlerPhysicalResetAliasedPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhysPage);
 int             pgmHandlerVirtualFindByPhysAddr(PVM pVM, RTGCPHYS GCPhys, PPGMVIRTHANDLER *ppVirt, unsigned *piPage);
 DECLCALLBACK(int) pgmHandlerVirtualResetOne(PAVLROGCPTRNODECORE pNode, void *pvUser);

trunk/src/VBox/VMM/PGMPhys.cpp

@@ -660 +660 @@
 
 
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+/**
+ * Frees a range of pages, replacing them with ZERO pages of the specified type.
+ *
+ * @returns VBox status code.
+ * @param   pVM         The VM handle.
+ * @param   pRam        The RAM range in which the pages resides.
+ * @param   GCPhys      The address of the first page.
+ * @param   GCPhysLast  The address of the last page.
+ * @param   uType       The page type to replace then with.
+ */
+static int pgmR3PhysFreePageRange(PVM pVM, PPGMRAMRANGE pRam, RTGCPHYS GCPhys, RTGCPHYS GCPhysLast, uint8_t uType)
+{
+    uint32_t            cPendingPages = 0;
+    PGMMFREEPAGESREQ    pReq;
+    int rc = GMMR3FreePagesPrepare(pVM, &pReq, PGMPHYS_FREE_PAGE_BATCH_SIZE, GMMACCOUNT_BASE);
+    AssertLogRelRCReturn(rc, rc);
+
+    /* Itegerate the pages. */
+    PPGMPAGE pPageDst   = &pRam->aPages[(GCPhys - pRam->GCPhys) >> PAGE_SHIFT];
+    uint32_t cPagesLeft = ((GCPhysLast - GCPhys) >> PAGE_SHIFT) + 1;
+    while (cPagesLeft-- > 0)
+    {
+        rc = pgmPhysFreePage(pVM, pReq, &cPendingPages, pPageDst, GCPhys);
+        AssertLogRelRCReturn(rc, rc); /* We're done for if this goes wrong. */
+
+        PGM_PAGE_SET_TYPE(pPageDst, uType);
+
+        GCPhys += PAGE_SIZE;
+        pPageDst++;
+    }
+
+    if (cPendingPages)
+    {
+        rc = GMMR3FreePagesPerform(pVM, pReq, cPendingPages);
+        AssertLogRelRCReturn(rc, rc);
+    }
+    GMMR3FreePagesCleanup(pReq);
+
+    return rc;
+}
+#endif /* VBOX_WITH_NEW_PHYS_CODE */
+
+
 /**
  * Sets up a range RAM.
@@ -809 +853 @@
                             AssertLogRelRCReturn(rc, rc);
                         }
+                        break;
+
+                    case PGMPAGETYPE_MMIO2_ALIAS_MMIO:
+                        pgmHandlerPhysicalResetAliasedPage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
                         break;
 
@@ -871 +919 @@
 #endif /* VBOX_WITH_NEW_PHYS_CODE */
 
+                    case PGMPAGETYPE_MMIO2_ALIAS_MMIO:
+                        pgmHandlerPhysicalResetAliasedPage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT));
+                        break;
+
                     case PGMPAGETYPE_MMIO2:
                     case PGMPAGETYPE_ROM_SHADOW:
@@ -982 +1034 @@
     PPGMRAMRANGE pNew;
     if (fRamExists)
+    {
         pNew = NULL;
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+        /*
+         * Make all the pages in the range MMIO/ZERO pages, freeing any
+         * RAM pages currently mapped here. This might not be 100% correct
+         * 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);
+#endif
+    }
     else
     {
@@ -1067 +1135 @@
     if (RT_SUCCESS(rc))
     {
-        RTGCPHYS GCPhysLast = GCPhys + (cb - 1);
-        PPGMRAMRANGE pRamPrev = NULL;
-        PPGMRAMRANGE pRam = pVM->pgm.s.pRamRangesR3;
+        RTGCPHYS        GCPhysLast  = GCPhys + (cb - 1);
+        PPGMRAMRANGE    pRamPrev    = NULL;
+        PPGMRAMRANGE    pRam        = pVM->pgm.s.pRamRangesR3;
         while (pRam && GCPhysLast >= pRam->GCPhys)
         {
-            /*if (    GCPhysLast >= pRam->GCPhys
-                &&  GCPhys     <= pRam->GCPhysLast) - later */
+            /** @todo We're being a bit too careful here. rewrite. */
             if (    GCPhysLast == pRam->GCPhysLast
                 &&  GCPhys     == pRam->GCPhys)
@@ -1082 +1149 @@
                  * See if all the pages are dead MMIO pages.
                  */
+                uint32_t const  cPages   = cb >> PAGE_SHIFT;
                 bool            fAllMMIO = true;
-                PPGMPAGE        pPage    = &pRam->aPages[0];
-                uint32_t const  cPages   = cb >> PAGE_SHIFT;
+                uint32_t        iPage    = 0;
                 uint32_t        cLeft    = cPages;
                 while (cLeft-- > 0)
                 {
+                    PPGMPAGE    pPage    = &pRam->aPages[iPage];
                     if (    PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO
                         /*|| not-out-of-action later */)
                     {
                         fAllMMIO = false;
+#ifdef VBOX_WITH_NEW_PHYS_CODE
                         Assert(PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO2_ALIAS_MMIO);
+                        AssertMsgFailed(("%RGp %R[pgmpage]\n", pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), pPage));
+#endif
                         break;
                     }
@@ -1098 +1169 @@
                     pPage++;
                 }
-
-                /*
-                 * Unlink it and free if it's all MMIO.
-                 */
                 if (fAllMMIO)
                 {
+                    /*
+                     * Ad-hoc range, unlink and free it.
+                     */
                     Log(("PGMR3PhysMMIODeregister: Freeing ad-hoc MMIO range for %RGp-%RGp %s\n",
                          GCPhys, GCPhysLast, pRam->pszDesc));
@@ -1113 +1183 @@
                     pRam->cb = pRam->GCPhys = pRam->GCPhysLast = NIL_RTGCPHYS;
                     MMHyperFree(pVM, pRam);
+                    break;
+                }
+            }
+
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+            /*
+             * Range match? It will all be within one range (see PGMAllHandler.cpp).
+             */
+            if (    GCPhysLast >= pRam->GCPhys
+                &&  GCPhys     <= pRam->GCPhysLast)
+            {
+                Assert(GCPhys     >= pRam->GCPhys);
+                Assert(GCPhysLast <= pRam->GCPhysLast);
+
+                /*
+                 * Turn the pages back into RAM pages.
+                 */
+                uint32_t iPage = (GCPhys - pRam->GCPhys) >> PAGE_SHIFT;
+                uint32_t cLeft = cb >> PAGE_SHIFT;
+                while (cLeft--)
+                {
+                    PPGMPAGE pPage = &pRam->aPages[iPage];
+                    AssertMsg(PGM_PAGE_IS_MMIO(pPage), ("%RGp %R[pgmpage]\n", pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), pPage));
+                    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);
                 }
                 break;
             }
+#endif
 
             /* next */
@@ -1452 +1549 @@
     if (fRamExists)
     {
+/** @todo use pgmR3PhysFreePageRange here. */
         uint32_t            cPendingPages = 0;
         PGMMFREEPAGESREQ    pReq;
@@ -3088 +3186 @@
                     for (uint32_t iPage = 0; iPage < cPages; iPage++)
                         if (PGM_PAGE_GET_PAGEID(&pRam->aPages[iPage]) == idPage)
-                            LogRel(("PGM: Used by %RGp %R{pgmpage} (%s)\n",
+                            LogRel(("PGM: Used by %RGp %R[pgmpage] (%s)\n",
                                     pRam->GCPhys + ((RTGCPHYS)iPage << PAGE_SHIFT), &pRam->aPages[iPage], pRam->pszDesc));
                 }

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

@@ -1764 +1764 @@
 #ifndef IN_RC
 /**
- * Modify an existing MMIO region page; map to another guest physical region and change the access flags
+ * Mapping an MMIO2 page in place of an MMIO page for direct access.
+ *
+ * (This is a special optimization used by the VGA device.)
  *
  * @returns VBox status code.
  *
  * @param   pVM             The virtual machine.
- * @param   GCPhys          Physical address that's part of the MMIO region to be changed.
- * @param   GCPhysRemapped  Remapped address.
- * @param   fPageFlags      Page flags to set (typically X86_PTE_RW).
+ * @param   GCPhys          The address of the MMIO page to be changed.
+ * @param   GCPhysRemapped  The address of the MMIO2 page.
+ * @param   fPageFlags      Page flags to set. Must be (X86_PTE_RW | X86_PTE_P)
+ *                          for the time being.
  */
 VMMDECL(int) IOMMMIOModifyPage(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysRemapped, uint64_t fPageFlags)
 {
-    Assert(fPageFlags == (X86_PTE_RW | X86_PTE_P));
-
     Log(("IOMMMIOModifyPage %RGp -> %RGp flags=%RX64\n", GCPhys, GCPhysRemapped, fPageFlags));
+
+    AssertReturn(fPageFlags == (X86_PTE_RW | X86_PTE_P), VERR_INVALID_PARAMETER);
 
     /* This currently only works in real mode, protected mode without paging or with nested paging. */
@@ -1786 +1789 @@
 
     /*
-     * Lookup the current context range node and statistics.
+     * Lookup the context range node the page belongs to.
      */
     PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
     AssertMsgReturn(pRange,
                     ("Handlers and page tables are out of sync or something! GCPhys=%RGp\n", GCPhys),
-                    VERR_INTERNAL_ERROR);
-
-    GCPhys         &= ~(RTGCPHYS)0xfff;
-    GCPhysRemapped &= ~(RTGCPHYS)0xfff;
+                    VERR_IOM_MMIO_RANGE_NOT_FOUND);
+    Assert((pRange->GCPhys       & PAGE_OFFSET_MASK) == 0);
+    Assert((pRange->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
+
+    /*
+     * Do the aliasing; page align the addresses since PGM is picky.
+     */
+    GCPhys         &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
+    GCPhysRemapped &= ~(RTGCPHYS)PAGE_OFFSET_MASK;
 
     int rc = PGMHandlerPhysicalPageAlias(pVM, pRange->GCPhys, GCPhys, GCPhysRemapped);
     AssertRCReturn(rc, rc);
 
-#ifdef VBOX_STRICT
+    /*
+     * Modify the shadow page table. Since it's an MMIO page it won't be present and we
+     * can simply prefetch it.
+     *
+     * Note: This is a NOP in the EPT case; we'll just let it fault again to resync the page.
+     */
+#ifndef VBOX_WITH_NEW_PHYS_CODE /* The assertion is wrong for the PGM_SYNC_CLEAR_PGM_POOL and VINF_PGM_HANDLER_ALREADY_ALIASED cases. */
+# ifdef VBOX_STRICT
     uint64_t fFlags;
     RTHCPHYS HCPhys;
     rc = PGMShwGetPage(pVM, (RTGCPTR)GCPhys, &fFlags, &HCPhys);
     Assert(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT);
-#endif
-
-    /* @note this is a NOP in the EPT case; we'll just let it fault again to resync the page. */
+# endif
+#endif
     rc = PGMPrefetchPage(pVM, (RTGCPTR)GCPhys);
     Assert(rc == VINF_SUCCESS || rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT);
@@ -1821 +1835 @@
  * @param   GCPhys          Physical address that's part of the MMIO region to be reset.
  */
-VMMDECL(int)  IOMMMIOResetRegion(PVM pVM, RTGCPHYS GCPhys)
+VMMDECL(int) IOMMMIOResetRegion(PVM pVM, RTGCPHYS GCPhys)
 {
     Log(("IOMMMIOResetRegion %RGp\n", GCPhys));
@@ -1832 +1846 @@
 
     /*
-     * Lookup the current context range node and statistics.
+     * Lookup the context range node the page belongs to.
      */
     PIOMMMIORANGE pRange = iomMMIOGetRange(&pVM->iom.s, GCPhys);
     AssertMsgReturn(pRange,
                     ("Handlers and page tables are out of sync or something! GCPhys=%RGp\n", GCPhys),
-                    VERR_INTERNAL_ERROR);
-
-    /* Reset the entire range by clearing all shadow page table entries. */
+                    VERR_IOM_MMIO_RANGE_NOT_FOUND);
+
+    /*
+     * Call PGM to do the job work.
+     *
+     * After the call, all the pages should be non-present... unless there is
+     * a page pool flush pending (unlikely).
+     */
     int rc = PGMHandlerPhysicalReset(pVM, pRange->GCPhys);
     AssertRC(rc);
 
 #ifdef VBOX_STRICT
-    uint32_t cb = pRange->cb;
-
-    GCPhys = pRange->GCPhys;
-
-    while (cb)
-    {
-
-        uint64_t fFlags;
-        RTHCPHYS HCPhys;
-        rc = PGMShwGetPage(pVM, (RTGCPTR)GCPhys, &fFlags, &HCPhys);
-        Assert(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT);
-        cb     -= PAGE_SIZE;
-        GCPhys += PAGE_SIZE;
-    }
-#endif
-    return VINF_SUCCESS;
+    if (!VM_FF_ISSET(pVM, VM_FF_PGM_SYNC_CR3))
+    {
+        uint32_t cb = pRange->cb;
+        GCPhys = pRange->GCPhys;
+        while (cb)
+        {
+            uint64_t fFlags;
+            RTHCPHYS HCPhys;
+            rc = PGMShwGetPage(pVM, (RTGCPTR)GCPhys, &fFlags, &HCPhys);
+            Assert(rc == VERR_PAGE_NOT_PRESENT || rc == VERR_PAGE_TABLE_NOT_PRESENT);
+            cb     -= PAGE_SIZE;
+            GCPhys += PAGE_SIZE;
+        }
+    }
+#endif
+    return rc;
 }
 #endif /* !IN_RC */

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

@@ -216 +216 @@
      */
     bool            fFlushTLBs = false;
-    int             rc = VINF_SUCCESS;
-    const unsigned  uState = pgmHandlerPhysicalCalcState(pCur);
-    RTUINT          cPages = pCur->cPages;
-    RTUINT          i = (pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT;
+    int             rc         = VINF_SUCCESS;
+    const unsigned  uState     = pgmHandlerPhysicalCalcState(pCur);
+    uint32_t        cPages     = pCur->cPages;
+    uint32_t        i          = (pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT;
     for (;;)
     {
@@ -235 +235 @@
                 return rc2;
         }
+
 #endif /* !VBOX_WITH_NEW_PHYS_CODE */
+        PPGMPAGE pPage = &pRam->aPages[i];
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+        AssertMsg(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO || PGM_PAGE_IS_MMIO(pPage),
+                  ("%RGp %R[pgmpage]\n", pRam->GCPhys + (i << PAGE_SHIFT), pPage));
+#endif
 
         /* Only do upgrades. */
-        PPGMPAGE pPage = &pRam->aPages[i];
         if (PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) < uState)
         {
             PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, uState);
+#ifndef VBOX_WITH_NEW_PHYS_CODE
             Assert(PGM_PAGE_GET_HCPHYS(pPage));
+#endif
 
             int rc2 = pgmPoolTrackFlushGCPhys(pVM, pPage, &fFlushTLBs);
@@ -415 +422 @@
 
 
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+/**
+ * Resets an aliased page.
+ *
+ * @param   pVM         The VM.
+ * @param   pPage       The page.
+ * @param   GCPhysPage  The page address in case it comes in handy.
+ */
+void pgmHandlerPhysicalResetAliasedPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhysPage)
+{
+    Assert(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO);
+    Assert(PGM_PAGE_GET_HNDL_PHYS_STATE(pPage) == PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
+
+    /*
+     * Flush any shadow page table references *first*.
+     */
+    bool fFlushTLBs = false;
+    int rc = pgmPoolTrackFlushGCPhys(pVM, pPage, &fFlushTLBs);
+    AssertLogRelRCReturnVoid(rc);
+    if (rc == VINF_PGM_GCPHYS_ALIASED)
+    {
+        pVM->pgm.s.fSyncFlags |= PGM_SYNC_CLEAR_PGM_POOL;
+        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
+        rc = VINF_PGM_SYNC_CR3;
+    }
+# ifdef IN_RC
+    else if (fFlushTLBs)
+        PGM_INVL_GUEST_TLBS();
+# else
+    HWACCMFlushTLB(pVM);
+# endif
+    pVM->pgm.s.fPhysCacheFlushPending = true;
+
+    /*
+     * Make it an MMIO/Zero page.
+     */
+    PGM_PAGE_SET_HCPHYS(pPage, pVM->pgm.s.HCPhysZeroPg);
+    PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_MMIO);
+    PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ZERO);
+    PGM_PAGE_SET_PAGEID(pPage, NIL_GMM_PAGEID);
+    PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_ALL);
+
+    NOREF(GCPhysPage);
+}
+#endif
+
+
 /**
  * Resets ram range flags.
@@ -441 +495 @@
         int rc = pgmPhysGetPageWithHintEx(pPGM, GCPhys, &pPage, &pRamHint);
         if (RT_SUCCESS(rc))
+        {
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+            /* Reset MMIO2 for MMIO pages to MMIO, since this aliasing is our business.
+               (We don't flip MMIO to RAM though, that's PGMPhys.cpp's job.)  */
+            if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO)
+                pgmHandlerPhysicalResetAliasedPage(pVM, pPage, GCPhys);
+            AssertMsg(pCur->enmType != PGMPHYSHANDLERTYPE_MMIO || PGM_PAGE_IS_MMIO(pPage), ("%RGp %R[pgmpage]\n", GCPhys, pPage));
+#endif
             PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_NONE);
+        }
         else
             AssertRC(rc);
@@ -767 +830 @@
  * page access handler region.
  *
- * This is used in pair with PGMHandlerPhysicalPageTempOff().
+ * This is used in pair with PGMHandlerPhysicalPageTempOff() or
+ * PGMHandlerPhysicalPageAlias().
  *
  * @returns VBox status code.
  * @param   pVM         VM Handle
- * @param   GCPhys      Start physical address earlier passed to PGMR3HandlerPhysicalRegister().
+ * @param   GCPhys      The start address of the handler regions, i.e. what you
+ *                      passed to PGMR3HandlerPhysicalRegister(),
+ *                      PGMHandlerPhysicalRegisterEx() or
+ *                      PGMHandlerPhysicalModify().
  */
 VMMDECL(int)  PGMHandlerPhysicalReset(PVM pVM, RTGCPHYS GCPhys)
@@ -791 +858 @@
             case PGMPHYSHANDLERTYPE_PHYSICAL_WRITE:
             case PGMPHYSHANDLERTYPE_PHYSICAL_ALL:
-            case PGMPHYSHANDLERTYPE_MMIO: /* @note Only use when clearing aliased mmio ranges! */
+            case PGMPHYSHANDLERTYPE_MMIO: /* NOTE: Only use when clearing MMIO ranges with aliased MMIO2 pages! */
             {
-                /*
-                 * Set the flags and flush shadow PT entries.
-                 */
-                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysHandlerReset));
+                STAM_COUNTER_INC(&pVM->pgm.s.CTX_MID_Z(Stat,PhysHandlerReset)); /**@Todo move out of switch */
                 PPGMRAMRANGE pRam = pgmPhysGetRange(&pVM->pgm.s, GCPhys);
                 Assert(pRam);
-                rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
-                if (rc == VINF_PGM_GCPHYS_ALIASED)
+                Assert(pRam->GCPhys     <= pCur->Core.Key);
+                Assert(pRam->GCPhysLast >= pCur->Core.KeyLast);
+
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+                if (pCur->enmType == PGMPHYSHANDLERTYPE_MMIO)
                 {
-                    pVM->pgm.s.fSyncFlags |= PGM_SYNC_CLEAR_PGM_POOL;
-                    VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
+                    /*
+                     * Reset all the PGMPAGETYPE_MMIO2_ALIAS_MMIO pages first and that's it.
+                     * This could probably be optimized a bit wrt to flushing, but I'm too lazy
+                     * to do that now...
+                     */
+                    PPGMPAGE    pPage = &pRam->aPages[(pCur->Core.Key - pRam->GCPhys) >> PAGE_SHIFT];
+                    uint32_t    cLeft = pCur->cPages;
+                    while (cLeft-- > 0)
+                    {
+                        if (PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO)
+                            pgmHandlerPhysicalResetAliasedPage(pVM, pPage, pRam->GCPhys + ((RTGCPHYS)(uintptr_t)(pPage - &pRam->aPages[0]) << PAGE_SHIFT));
+                        Assert(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO);
+                        pPage++;
+                    }
                 }
-                pVM->pgm.s.fPhysCacheFlushPending = true;
-                HWACCMFlushTLB(pVM);
+                else
+#endif
+                {
+                    /*
+                     * Set the flags and flush shadow PT entries.
+                     */
+                    rc = pgmHandlerPhysicalSetRamFlagsAndFlushShadowPTs(pVM, pCur, pRam);
+                    if (rc == VINF_PGM_GCPHYS_ALIASED)
+                    {
+                        pVM->pgm.s.fSyncFlags |= PGM_SYNC_CLEAR_PGM_POOL;
+                        VM_FF_SET(pVM, VM_FF_PGM_SYNC_CR3);
+                    }
+                    pVM->pgm.s.fPhysCacheFlushPending = true;
+                    HWACCMFlushTLB(pVM);
+                }
 
                 rc = VINF_SUCCESS;
@@ -843 +935 @@
  *
  * @returns VBox status code.
- * @param   pVM         VM Handle
- * @param   GCPhys      Start physical address earlier passed to PGMR3HandlerPhysicalRegister().
- *                      This must be a fully page aligned range or we risk messing up other
- *                      handlers installed for the start and end pages.
- * @param   GCPhysPage  Physical address of the page to turn off access monitoring for.
+ * @param   pVM                 VM Handle
+ * @param   GCPhys              The start address of the access handler. This
+ *                              must be a fully page aligned range or we risk
+ *                              messing up other handlers installed for the
+ *                              start and end pages.
+ * @param   GCPhysPage          The physical address of the page to turn off
+ *                              access monitoring for.
  */
 VMMDECL(int)  PGMHandlerPhysicalPageTempOff(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage)
@@ -891 +985 @@
 
 /**
- * Temporarily turns off the access monitoring of a page within an MMIO
- * access handler region and remaps it to another guest physical region.
- *
- * Use this when no further \#PFs are required for that page. Be aware that
- * a page directory sync might reset the flags, and turn on access monitoring
- * for the page.
- *
- * The caller must do required page table modifications.
+ * Replaces an MMIO page with an MMIO2 page.
+ *
+ * This is a worker for IOMMMIOModifyPage that works in a similar way to
+ * PGMHandlerPhysicalPageTempOff but for an MMIO page. Since an MMIO page has no
+ * backing, the caller must provide a replacement page. For various reasons the
+ * replacement page must be an MMIO2 page.
+ *
+ * The caller must do required page table modifications. You can get away
+ * without making any modifations since it's an MMIO page, the cost is an extra
+ * \#PF which will the resync the page.
+ *
+ * Call PGMHandlerPhysicalReset() to restore the MMIO page.
+ *
+ * The caller may still get handler callback even after this call and must be
+ * able to deal correctly with such calls. The reason for these callbacks are
+ * either that we're executing in the recompiler (which doesn't know about this
+ * arrangement) or that we've been restored from saved state (where we won't
+ * save the change).
  *
  * @returns VBox status code.
- * @param   pVM                 VM Handle
- * @param   GCPhys              Start physical address earlier passed to PGMR3HandlerPhysicalRegister().
- *                              This must be a fully page aligned range or we risk messing up other
- *                              handlers installed for the start and end pages.
- * @param   GCPhysPage          Physical address of the page to turn off access monitoring for.
- * @param   GCPhysPageRemap     Physical address of the page that serves as backing memory.
+ * @param   pVM                 The VM handle
+ * @param   GCPhys              The start address of the access handler. This
+ *                              must be a fully page aligned range or we risk
+ *                              messing up other handlers installed for the
+ *                              start and end pages.
+ * @param   GCPhysPage          The physical address of the page to turn off
+ *                              access monitoring for.
+ * @param   GCPhysPageRemap     The physical address of the MMIO2 page that
+ *                              serves as backing memory.
+ *
+ * @remark  May cause a page pool flush if used on a page that is already
+ *          aliased.
+ *
+ * @note    This trick does only work reliably if the two pages are never ever
+ *          mapped in the same page table. If they are the page pool code will
+ *          be confused should either of them be flushed. See the special case
+ *          of zero page aliasing mentioned in #3170.
+ *
  */
 VMMDECL(int)  PGMHandlerPhysicalPageAlias(PVM pVM, RTGCPHYS GCPhys, RTGCPHYS GCPhysPage, RTGCPHYS GCPhysPageRemap)
 {
     /*
-     * Validate the range.
+     * Lookup and validate the range.
      */
     PPGMPHYSHANDLER pCur = (PPGMPHYSHANDLER)RTAvlroGCPhysGet(&pVM->pgm.s.CTX_SUFF(pTrees)->PhysHandlers, GCPhys);
@@ -919 +1035 @@
                       &&  GCPhysPage <= pCur->Core.KeyLast))
         {
-            Assert(!(pCur->Core.Key & PAGE_OFFSET_MASK));
-            Assert((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK);
-
             AssertReturn(pCur->enmType == PGMPHYSHANDLERTYPE_MMIO, VERR_ACCESS_DENIED);
-            /** @todo r=bird: This totally breaks the new PGMPAGE management. Will probably
-             *        have to require that the current page is the zero page... Require
-             *        GCPhysPageRemap to be a MMIO2 page might help matters because those
-             *        pages aren't managed dynamically (at least not yet).
-             *        VBOX_WITH_NEW_PHYS_CODE TODO!
-             *
-             * A solution to this would be to temporarily change the page into a MMIO2 one
-             * and record that we've changed it. Only the physical page address would
-             * need to be copied over. The aliased page would have to be MMIO2 ofc, since
-             * RAM or ROM pages would require write sharing which is something we don't
-             * intend to implement just yet...
+            AssertReturn(!(pCur->Core.Key & PAGE_OFFSET_MASK), VERR_INVALID_PARAMETER);
+            AssertReturn((pCur->Core.KeyLast & PAGE_OFFSET_MASK) == PAGE_OFFSET_MASK, VERR_INVALID_PARAMETER);
+
+            /*
+             * Get and validate the two pages.
              */
-
-            /*
-             * Note! This trick does only work reliably if the two pages are never ever
-             *       mapped in the same page table. If they are the page pool code will
-             *       be confused should either of them be flushed. See the special case
-             *       of zero page aliasing mentioned in #3170.
-             */
-
             PPGMPAGE pPageRemap;
             int rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPageRemap, &pPageRemap);
             AssertRCReturn(rc, rc);
-
-            /*
-             * Change the page status.
-             */
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+            AssertMsgReturn(PGM_PAGE_GET_TYPE(pPageRemap) == PGMPAGETYPE_MMIO2,
+                            ("GCPhysPageRemap=%RGp %R[pgmpage]\n", GCPhysPageRemap, pPageRemap),
+                            VERR_PGM_PHYS_NOT_MMIO2);
+#endif
+
             PPGMPAGE pPage;
             rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysPage, &pPage);
             AssertRCReturn(rc, rc);
-
-            /* Do the actual remapping here. This page now serves as an alias for the backing memory specified. */
 #ifdef VBOX_WITH_NEW_PHYS_CODE
-            AssertReleaseFailed(); /** @todo see todo above! */
+            if (PGM_PAGE_GET_TYPE(pPage) != PGMPAGETYPE_MMIO)
+            {
+                AssertMsgReturn(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_MMIO2_ALIAS_MMIO,
+                                ("GCPhysPage=%RGp %R[pgmpage]\n", GCPhysPage, pPage),
+                                VERR_PGM_PHYS_NOT_MMIO2);
+                if (PGM_PAGE_GET_HCPHYS(pPage) == PGM_PAGE_GET_HCPHYS(pPage))
+                    return VINF_PGM_HANDLER_ALREADY_ALIASED;
+
+                /*
+                 * The page is already mapped as some other page, reset it
+                 * to an MMIO/ZERO page before doing the new mapping.
+                 */
+                Log(("PGMHandlerPhysicalPageAlias: GCPhysPage=%RGp (%R[pgmpage]; %RHp -> %RHp\n",
+                     GCPhysPage, pPage, PGM_PAGE_GET_HCPHYS(pPage), PGM_PAGE_GET_HCPHYS(pPageRemap)));
+                pgmHandlerPhysicalResetAliasedPage(pVM, pPage, GCPhysPage);
+            }
+            Assert(PGM_PAGE_IS_ZERO(pPage));
+#endif
+
+            /*
+             * Do the actual remapping here.
+             * This page now serves as an alias for the backing memory specified.
+             */
+            LogFlow(("PGMHandlerPhysicalPageAlias: %RGp (%R[pgmpage]) alias for %RGp (%R[pgmpage])\n",
+                     GCPhysPage, pPage, GCPhysPageRemap, pPageRemap ));
+#ifdef VBOX_WITH_NEW_PHYS_CODE
+            PGM_PAGE_SET_HCPHYS(pPage, PGM_PAGE_GET_HCPHYS(pPageRemap));
+            PGM_PAGE_SET_TYPE(pPage, PGMPAGETYPE_MMIO2_ALIAS_MMIO);
+            PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
+            PGM_PAGE_SET_PAGEID(pPage, PGM_PAGE_GET_PAGEID(pPageRemap));
+            PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
+            LogFlow(("PGMHandlerPhysicalPageAlias: => %R[pgmpage]\n", pPage));
 #else
             pPage->HCPhys = pPageRemap->HCPhys;
             PGM_PAGE_SET_TRACKING(pPage, 0);
-#endif
-
-            LogFlow(("PGMHandlerPhysicalPageAlias %RGp alias for %RGp (%R[pgmpage]) -> %R[pgmpage]\n",
-                     GCPhysPage, GCPhysPageRemap, pPageRemap, pPage));
             PGM_PAGE_SET_HNDL_PHYS_STATE(pPage, PGM_PAGE_HNDL_PHYS_STATE_DISABLED);
+#endif
+
 #ifndef IN_RC
             HWACCMInvalidatePhysPage(pVM, GCPhysPage);
@@ -981 +1109 @@
 
 
+#if 0/**@todo delete this. */
 /**
  * Turns access monitoring of a page within a monitored
@@ -1035 +1164 @@
     return VERR_PGM_HANDLER_NOT_FOUND;
 }
+#endif
 
 

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

@@ -668 +668 @@
              * them, that would also avoid this mess. It would actually be kind of
              * elegant... */
-            AssertFailedReturn(VERR_INTERNAL_ERROR);
+            AssertLogRelMsgFailedReturn(("%RGp\n", GCPhys), VERR_INTERNAL_ERROR);
         }
         else