Changeset 26616 in vbox

Timestamp:

Feb 17, 2010 3:44:15 PM (15 years ago)

Author:

vboxsync

Message:

More large page work (disabled)

Location:

trunk

Files:

• include/VBox/pgm.h (modified) (1 diff)
• src/VBox/VMM/PGMInternal.h (modified) (4 diffs)
• src/VBox/VMM/PGMPhys.cpp (modified) (5 diffs)
• src/VBox/VMM/VMM.cpp (modified) (1 diff)
• src/VBox/VMM/VMMAll/PGMAllBth.h (modified) (1 diff)
• src/VBox/VMM/VMMAll/PGMAllPhys.cpp (modified) (2 diffs)

trunk/include/VBox/pgm.h

@@ -534 +534 @@
 VMMR3DECL(void)     PGMR3PhysChunkInvalidateTLB(PVM pVM);
 VMMR3DECL(int)      PGMR3PhysAllocateHandyPages(PVM pVM);
-VMMR3DECL(int)      PGMR3PhysAllocateLargeHandyPage(PVM pVM);
+VMMR3DECL(int)      PGMR3PhysAllocateLargeHandyPage(PVM pVM, RTGCPHYS GCPhys);
 
 VMMR3DECL(void)     PGMR3ReleaseOwnedLocks(PVM pVM);

trunk/src/VBox/VMM/PGMInternal.h

@@ -612 +612 @@
      *  - [8-9]: u2HandlerVirtStateY - the virtual handler state
      *    (PGM_PAGE_HNDL_VIRT_STATE_*).
-     *  - [14]:  u1LargePage - flag indicating that it's part of a large (2 MB) page 
+     *  - [13-14]: u2PDEType  - paging structure needed to map the page (PGM_PAGE_PDE_TYPE_*)
      *  - [15]:  fWrittenToY - flag indicating that a write monitored page was
      *    written to when set.
@@ -832 +832 @@
 #define PGM_PAGE_IS_WRITTEN_TO(pPage)       ( !!((pPage)->u16MiscY.au8[1] & UINT8_C(0x80)) )
 
-/**
- * Marks the page as part of a large continuous page
+/** @name PT usage values (PGMPAGE::u2PDEType).
+ *
+ * @{ */
+/** Either as a PT or PDE. */
+#define PGM_PAGE_PDE_TYPE_DONTCARE             0
+/** Must use a page table to map the range. */
+#define PGM_PAGE_PDE_TYPE_PT                   1
+/** Can use a page directory entry to map the continous range. */
+#define PGM_PAGE_PDE_TYPE_PDE                  2
+/** @} */
+
+/**
+ * Set the PDE type of the page
  * @param   pPage       Pointer to the physical guest page tracking structure.
- */
-#define PGM_PAGE_SET_LARGE_PAGE(pPage)      do { (pPage)->u16MiscY.au8[1] |= UINT8_C(0x40); } while (0)
-
-/**
- * Clears the page as part of a large continuous page indicator.
- * @param   pPage       Pointer to the physical guest page tracking structure.
- */
-#define PGM_PAGE_CLEAR_LARGE_PAGE(pPage)    do { (pPage)->u16MiscY.au8[1] &= UINT8_C(0xbf); } while (0)
+ * @param   uType       PGM_PAGE_PDE_TYPE_*
+ */
+#define PGM_PAGE_SET_PDE_TYPE(pPage, uType) \
+    do { \
+        (pPage)->u16MiscY.au8[1] = ((pPage)->u16MiscY.au8[1] & UINT8_C(0x9f)) \
+                                 | (((uType)                 & UINT8_C(0x03)) << 5); \
+    } while (0)
 
 /**
@@ -849 +859 @@
  * @param   pPage       Pointer to the physical guest page tracking structure.
  */
-#define PGM_PAGE_IS_LARGE_PAGE(pPage)       ( !!((pPage)->u16MiscY.au8[1] & UINT8_C(0x40)) )
+#define PGM_PAGE_GET_PDE_TYPE(pPage)       ( ((pPage)->u16MiscY.au8[1] & UINT8_C(0x60)) >> 5)
 
 /** Enabled optimized access handler tests.
@@ -3308 +3318 @@
 
 int             pgmPhysAllocPage(PVM pVM, PPGMPAGE pPage, RTGCPHYS GCPhys);
+int             pgmPhysAllocLargePage(PVM pVM, RTGCPHYS GCPhys);
 int             pgmPhysPageLoadIntoTlb(PPGM pPGM, RTGCPHYS GCPhys);
 int             pgmPhysPageLoadIntoTlbWithPage(PPGM pPGM, PPGMPAGE pPage, RTGCPHYS GCPhys);

trunk/src/VBox/VMM/PGMPhys.cpp

@@ -1256 +1256 @@
                 {
                     case PGMPAGETYPE_RAM:
+                        /* @todo deal with large pages. */
+                        Assert(PGM_PAGE_GET_PDE_TYPE(pPage) != PGM_PAGE_PDE_TYPE_PDE);
+
                         if (!PGM_PAGE_IS_ZERO(pPage))
                         {
@@ -2062 +2065 @@
             PGM_PAGE_SET_STATE(pPageDst, PGM_PAGE_STATE_ZERO);
             PGM_PAGE_SET_PAGEID(pPageDst, NIL_GMM_PAGEID);
+            PGM_PAGE_SET_PDE_TYPE(pPageDst, PGM_PAGE_PDE_TYPE_DONTCARE);
 
             pVM->pgm.s.cZeroPages++;
@@ -3173 +3177 @@
  *
  * @param   pVM         The VM handle.
- */
-VMMR3DECL(int) PGMR3PhysAllocateLargeHandyPage(PVM pVM)
+ * @param   GCPhys      GC physical start address of the 2 MB range
+ */
+VMMR3DECL(int) PGMR3PhysAllocateLargeHandyPage(PVM pVM, RTGCPHYS GCPhys)
 {
     pgmLock(pVM);
@@ -3186 +3191 @@
         RTHCPHYS HCPhys = pVM->pgm.s.aLargeHandyPage[0].HCPhysGCPhys;
 
-        /*
-         * Clear the pages.
+        void *pv;
+
+        /* Map the large page into our address space.
+         *
+         * Note: assuming that within the 2 MB range:
+         * - GCPhys + PAGE_SIZE = HCPhys + PAGE_SIZE (whole point of this exercise)
+         * - user space mapping is continuous as well
+         * - page id (GCPhys) + 1 = page id (GCPhys + PAGE_SIZE)
          */
-        for (unsigned i = 0; i < _2M/PAGE_SIZE; i++)
-        {
-            void *pv;
-
-            /* Map the large page into our address space. Could only fail the first time */
-            rc = pgmPhysPageMapByPageID(pVM, idPage, HCPhys, &pv);
-            AssertLogRelMsgBreak(RT_SUCCESS(rc), ("idPage=%#x HCPhysGCPhys=%RHp rc=%Rrc", idPage, HCPhys, rc));
-            ASMMemZeroPage(pv);
-            idPage++;
-            HCPhys += PAGE_SIZE;
-            Log3(("PGMR3PhysAllocateLargePage: idPage=%#x HCPhys=%RGp\n", idPage, HCPhys));
-        }
+        rc = pgmPhysPageMapByPageID(pVM, idPage, HCPhys, &pv);
+        AssertLogRelMsg(RT_SUCCESS(rc), ("idPage=%#x HCPhysGCPhys=%RHp rc=%Rrc", idPage, HCPhys, rc));
+
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Clear the pages.
+             */
+            for (unsigned i = 0; i < _2M/PAGE_SIZE; i++)
+            {
+                ASMMemZeroPage(pv);
+
+                PPGMPAGE pPage;
+                rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
+                AssertRC(rc);
+
+                Assert(PGM_PAGE_IS_ZERO(pPage));
+                STAM_COUNTER_INC(&pVM->pgm.s.StatRZPageReplaceZero);
+                pVM->pgm.s.cZeroPages--;
+
+                /*
+                 * Do the PGMPAGE modifications.
+                 */
+                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);
+
+                /* Somewhat dirty assumption that page ids are increasing. */
+                idPage++;
+
+                HCPhys += PAGE_SIZE;
+                GCPhys += PAGE_SIZE;
+
+                pv = (void *)((uintptr_t)pv + PAGE_SIZE);
+
+                Log3(("PGMR3PhysAllocateLargePage: idPage=%#x HCPhys=%RGp\n", idPage, HCPhys));
+            }
+            /* Flush all TLBs. */
+            PGM_INVL_ALL_VCPU_TLBS(pVM);
+            PGMPhysInvalidatePageMapTLB(pVM);
+       }
         pVM->pgm.s.cLargeHandyPages = 0;
     }
@@ -3389 +3431 @@
     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);
 
     /* Flush physical page map TLB entry. */

trunk/src/VBox/VMM/VMM.cpp

@@ -2075 +2075 @@
         case VMMCALLRING3_PGM_ALLOCATE_LARGE_HANDY_PAGE:
         {
-            pVCpu->vmm.s.rcCallRing3 = PGMR3PhysAllocateLargeHandyPage(pVM);
+            pVCpu->vmm.s.rcCallRing3 = PGMR3PhysAllocateLargeHandyPage(pVM, pVCpu->vmm.s.u64CallRing3Arg);
             break;
         }

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

@@ -2937 +2937 @@
     Assert(!PdeDst.n.u1Present); /* We're only supposed to call SyncPT on PDE!P and conflicts.*/
 
-# if PGM_SHW_TYPE == PGM_TYPE_EPT
-
+# if (PGM_SHW_TYPE == PGM_TYPE_EPT) && (HC_ARCH_BITS == 64) && defined(RT_OS_WINDOWS) && defined(DEBUG_sandervl)
+    PPGMPAGE pPage;
+    rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPtrPage & SHW_PD_MASK, &pPage);
+    if (    RT_SUCCESS(rc)
+        &&  PGM_PAGE_GET_TYPE(pPage)  == PGMPAGETYPE_RAM)
+    {
+        RTHCPHYS HCPhys = NIL_RTHCPHYS;
+        unsigned uPDEType = PGM_PAGE_GET_PDE_TYPE(pPage);
+
+        if  (uPDEType == PGM_PAGE_PDE_TYPE_PDE)
+        {
+            /* Previously allocated 2 MB range can be reused. */
+            Assert(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED);
+            HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
+        }
+        else
+        if  (   uPDEType == PGM_PAGE_PDE_TYPE_DONTCARE
+             && PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ZERO)
+        {
+            RTGCPHYS GCPhysBase = GCPtrPage & SHW_PD_MASK;
+            RTGCPHYS GCPhys = GCPhysBase;
+            unsigned iPage;
+
+            /* Lazy approach: check all pages in the 2 MB range. 
+             * The whole range must be ram and unallocated
+             */
+            for (iPage = 0; iPage < _2M/PAGE_SIZE; iPage++)
+            {
+                rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhys, &pPage);
+                if  (   RT_FAILURE(rc)
+                     || PGM_PAGE_GET_TYPE(pPage)  != PGMPAGETYPE_RAM
+                     || PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED)
+                {
+                    break;
+                }
+                Assert(PGM_PAGE_GET_PDE_TYPE(pPage) == PGM_PAGE_PDE_TYPE_DONTCARE);
+                GCPhys += PAGE_SIZE;
+            }
+            /* Fetch the start page of the 2 MB range again. */
+            rc = pgmPhysGetPageEx(&pVM->pgm.s, GCPhysBase, &pPage);
+            AssertRC(rc);   /* can't fail */
+
+            if (iPage != _2M/PAGE_SIZE)
+            {
+                /* Failed. Mark as requiring a PT so we don't check the whole thing again in the future. */
+                PGM_PAGE_SET_PDE_TYPE(pPage, PGM_PAGE_PDE_TYPE_PT);
+            }
+            else
+            {
+                rc = pgmPhysAllocLargePage(pVM, GCPhysBase);
+                if (RT_SUCCESS(rc))
+                {   
+                    Assert(PGM_PAGE_GET_STATE(pPage) == PGM_PAGE_STATE_ALLOCATED);
+                    HCPhys = PGM_PAGE_GET_HCPHYS(pPage);
+                }
+            }
+        }
+
+        if (HCPhys != NIL_RTHCPHYS)
+        {
+            PdeDst.u &= X86_PDE_AVL_MASK;
+            PdeDst.u |= HCPhys;
+            PdeDst.n.u1Present   = 1;
+            PdeDst.n.u1Write     = 1;
+            PdeDst.n.u1Execute   = 1;
+            PdeDst.b.u1Size      = 1;
+            PdeDst.b.u1IgnorePAT = 1;
+            PdeDst.b.u3EMT       = VMX_EPT_MEMTYPE_WB;
+            ASMAtomicWriteSize(pPdeDst, PdeDst.u);
+
+            STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncPT), a);
+            return VINF_SUCCESS;
+        }
+    }
 # endif
 

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

@@ -436 +436 @@
     PGM_PAGE_SET_PAGEID(pPage, pVM->pgm.s.aHandyPages[iHandyPage].idPage);
     PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_ALLOCATED);
+    PGM_PAGE_SET_PDE_TYPE(pPage, PGM_PAGE_PDE_TYPE_PT);
     PGMPhysInvalidatePageMapTLBEntry(pVM, GCPhys);
 
@@ -444 +445 @@
 }
 
+/**
+ * Replace a 2 MB range of zero pages with new pages that we can write to.
+ *
+ * @returns The following VBox status codes.
+ * @retval  VINF_SUCCESS on success, pPage is modified.
+ * @retval  VINF_PGM_SYNC_CR3 on success and a page pool flush is pending.
+ * @retval  VERR_EM_NO_MEMORY if we're totally out of memory.
+ *
+ * @todo    Propagate VERR_EM_NO_MEMORY up the call tree.
+ *
+ * @param   pVM         The VM address.
+ * @param   GCPhys      The address of the page.
+ *
+ * @remarks Must be called from within the PGM critical section. It may
+ *          nip back to ring-3/0 in some cases.
+ *
+ * @remarks This function shouldn't really fail, however if it does
+ *          it probably means we've screwed up the size of handy pages and/or
+ *          the low-water mark. Or, that some device I/O is causing a lot of
+ *          pages to be allocated while while the host is in a low-memory
+ *          condition. This latter should be handled elsewhere and in a more
+ *          controlled manner, it's on the @bugref{3170} todo list...
+ */
+int pgmPhysAllocLargePage(PVM pVM, RTGCPHYS GCPhys)
+{
+    LogFlow(("pgmPhysAllocLargePage: %RGp\n", GCPhys));
+
+    /*
+     * Prereqs.
+     */
+    Assert(PGMIsLocked(pVM));
+    Assert((GCPhys & X86_PD_PAE_MASK) == 0);
+
+#ifdef IN_RING3
+    int rc = PGMR3PhysAllocateLargeHandyPage(pVM, GCPhys);
+#else
+    int rc = VMMRZCallRing3NoCpu(pVM, VMMCALLRING3_PGM_ALLOCATE_LARGE_HANDY_PAGE, GCPhys);
+#endif
+    return rc;
+}
 
 /**