Changeset 16182 in vbox

Timestamp:

Jan 22, 2009 5:30:28 PM (16 years ago)

Author:

vboxsync

Message:

VMM: VERR_PGM_MAPPING_CONFLICT fix: always relocate after ring-3 init.

Location:

trunk

Files:

• include/VBox/pgm.h (modified) (1 diff)
• src/VBox/VMM/PGMInternal.h (modified) (3 diffs)
• src/VBox/VMM/PGMMap.cpp (modified) (7 diffs)
• src/VBox/VMM/testcase/tstVMStructGC.cpp (modified) (1 diff)

trunk/include/VBox/pgm.h

@@ -541 +541 @@
 VMMR3DECL(int)      PGMR3MapPT(PVM pVM, RTGCPTR GCPtr, uint32_t cb, PFNPGMRELOCATE pfnRelocate, void *pvUser, const char *pszDesc);
 VMMR3DECL(int)      PGMR3UnmapPT(PVM pVM, RTGCPTR GCPtr);
+VMMR3DECL(int)      PGMR3FinalizeMappings(PVM pVM);
 VMMR3DECL(int)      PGMR3MappingsSize(PVM pVM, uint32_t *pcb);
 VMMR3DECL(int)      PGMR3MappingsFix(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb);

trunk/src/VBox/VMM/PGMInternal.h

@@ -371 +371 @@
     /** Pointer to next entry. */
     RCPTRTYPE(struct PGMMAPPING *)      pNextRC;
-#if GC_ARCH_BITS == 64
-    RTRCPTR                             padding0;
-#endif
+    /** Indicate whether this entry is finalized. */
+    bool                                fFinalized;
     /** Start Virtual address. */
     RTGCPTR                             GCPtr;
@@ -387 +386 @@
     R3PTRTYPE(const char *)             pszDesc;
     /** Number of page tables. */
-    RTUINT                              cPTs;
+    uint32_t                            cPTs;
 #if HC_ARCH_BITS != GC_ARCH_BITS || GC_ARCH_BITS == 64
-    RTUINT                              uPadding1; /**< Alignment padding. */
+    uint32_t                            uPadding1; /**< Alignment padding. */
 #endif
     /** Array of page table mapping data. Each entry
@@ -2454 +2453 @@
     R0PTRTYPE(PPGMMAPPING)          pMappingsR0;
 
+    /** Indicates that PGMR3FinalizeMappings has been called and that further
+     * PGMR3MapIntermediate calls will be rejected. */
+    bool                            fFinalizedMappings;
     /** If set no conflict checks are required.  (boolean) */
     bool                            fMappingsFixed;

trunk/src/VBox/VMM/PGMMap.cpp

@@ -114 +114 @@
      */
     const unsigned iPageDir = GCPtr >> X86_PD_SHIFT;
-    const unsigned cPTs = cb >> X86_PD_SHIFT;
-    unsigned    i;
-    for (i = 0; i < cPTs; i++)
-    {
-        if (pVM->pgm.s.pInterPD->a[iPageDir + i].n.u1Present)
-        {
-            AssertMsgFailed(("Address %#x is already in use by an intermediate mapping.\n", GCPtr + (i << PAGE_SHIFT)));
-            LogRel(("VERR_PGM_MAPPING_CONFLICT: Address %#x is already in use by an intermediate mapping.\n", GCPtr + (i << PAGE_SHIFT)));
-            return VERR_PGM_MAPPING_CONFLICT;
-        }
-    }
-    /** @todo AMD64: add check in PAE structures too, so we can remove all the 32-Bit paging stuff there. */
+    const unsigned cPTs     = cb >> X86_PD_SHIFT;
+    if (pVM->pgm.s.fFinalizedMappings)
+    {
+        for (unsigned i = 0; i < cPTs; i++)
+            if (pVM->pgm.s.pInterPD->a[iPageDir + i].n.u1Present)
+            {
+                AssertMsgFailed(("Address %#x is already in use by an intermediate mapping.\n", GCPtr + (i << PAGE_SHIFT)));
+                LogRel(("VERR_PGM_MAPPING_CONFLICT: Address %#x is already in use by an intermediate mapping.\n", GCPtr + (i << PAGE_SHIFT)));
+                return VERR_PGM_MAPPING_CONFLICT;
+            }
+        /** @todo AMD64: add check in PAE structures too, so we can remove all the 32-Bit paging stuff there. */
+    }
 
     /*
@@ -158 +158 @@
      */
     Log4(("PGMR3MapPT: GCPtr=%RGv cPTs=%u pbPTs=%p\n", GCPtr, cPTs, pbPTs));
-    for (i = 0; i < cPTs; i++)
+    for (unsigned i = 0; i < cPTs; i++)
     {
         /*
@@ -183 +183 @@
               i, pNew->aPTs[i].paPaePTsR3, pNew->aPTs[i].paPaePTsRC, pNew->aPTs[i].paPaePTsR0, pNew->aPTs[i].HCPhysPaePT0, pNew->aPTs[i].HCPhysPaePT1));
     }
-    pgmR3MapSetPDEs(pVM, pNew, iPageDir);
+    if (pVM->pgm.s.fFinalizedMappings)
+        pgmR3MapSetPDEs(pVM, pNew, iPageDir);
+    /* else PGMR3FinalizeMappings() */
 
     /*
@@ -219 +221 @@
 {
     LogFlow(("PGMR3UnmapPT: GCPtr=%#x\n", GCPtr));
+    AssertReturn(pVM->pgm.s.fFinalizedMappings, VERR_WRONG_ORDER);
 
     /*
@@ -272 +275 @@
 
 /**
+ * Checks whether a range of PDEs in the intermediate
+ * memory context are unused.
+ *
+ * We're talking 32-bit PDEs here.
+ *
+ * @returns true/false.
+ * @param   pVM         Pointer to the shared VM structure.
+ * @param   iPD         The first PDE in the range.
+ * @param   cPTs        The number of PDEs in the range.
+ */
+DECLINLINE(bool) pgmR3AreIntermediatePDEsUnused(PVM pVM, unsigned iPD, unsigned cPTs)
+{
+    if (pVM->pgm.s.pInterPD->a[iPD].n.u1Present)
+        return false;
+    while (cPTs > 1)
+    {
+        iPD++;
+        if (pVM->pgm.s.pInterPD->a[iPD].n.u1Present)
+            return false;
+        cPTs--;
+    }
+    return true;
+}
+
+
+/**
+ * Unlinks the mapping.
+ *
+ * The mapping *must* be in the list.
+ *
+ * @param   pVM             Pointer to the shared VM structure.
+ * @param   pMapping        The mapping to unlink.
+ */
+static void pgmR3MapUnlink(PVM pVM, PPGMMAPPING pMapping)
+{
+    PPGMMAPPING pAfterThis = pVM->pgm.s.pMappingsR3;
+    if (pAfterThis == pMapping)
+    {
+        /* head */
+        pVM->pgm.s.pMappingsR3 = pMapping->pNextR3;
+        pVM->pgm.s.pMappingsRC = pMapping->pNextRC;
+        pVM->pgm.s.pMappingsR0 = pMapping->pNextR0;
+    }
+    else
+    {
+        /* in the list */
+        while (pAfterThis->pNextR3 != pMapping)
+        {
+            pAfterThis = pAfterThis->pNextR3;
+            AssertReleaseReturnVoid(pAfterThis);
+        }
+
+        pAfterThis->pNextR3 = pMapping->pNextR3;
+        pAfterThis->pNextRC = pMapping->pNextRC;
+        pAfterThis->pNextR0 = pMapping->pNextR0;
+    }
+}
+
+
+/**
+ * Links the mapping.
+ *
+ * @param   pVM             Pointer to the shared VM structure.
+ * @param   pMapping        The mapping to linked.
+ */
+static void pgmR3MapLink(PVM pVM, PPGMMAPPING pMapping)
+{
+    /*
+     * Find the list location (it's sorted by GCPhys) and link it in.
+     */
+    if (    !pVM->pgm.s.pMappingsR3
+        ||  pVM->pgm.s.pMappingsR3->GCPtr > pMapping->GCPtr)
+    {
+        /* head */
+        pMapping->pNextR3 = pVM->pgm.s.pMappingsR3;
+        pMapping->pNextRC = pVM->pgm.s.pMappingsRC;
+        pMapping->pNextR0 = pVM->pgm.s.pMappingsR0;
+        pVM->pgm.s.pMappingsR3 = pMapping;
+        pVM->pgm.s.pMappingsRC = MMHyperR3ToRC(pVM, pMapping);
+        pVM->pgm.s.pMappingsR0 = MMHyperR3ToR0(pVM, pMapping);
+    }
+    else
+    {
+        /* in the list */
+        PPGMMAPPING pAfterThis  = pVM->pgm.s.pMappingsR3;
+        PPGMMAPPING pBeforeThis = pAfterThis->pNextR3;
+        while (pBeforeThis && pBeforeThis->GCPtr <= pMapping->GCPtr)
+        {
+            pAfterThis = pBeforeThis;
+            pBeforeThis = pBeforeThis->pNextR3;
+        }
+
+        pMapping->pNextR3 = pAfterThis->pNextR3;
+        pMapping->pNextRC = pAfterThis->pNextRC;
+        pMapping->pNextR0 = pAfterThis->pNextR0;
+        pAfterThis->pNextR3 = pMapping;
+        pAfterThis->pNextRC = MMHyperR3ToRC(pVM, pMapping);
+        pAfterThis->pNextR0 = MMHyperR3ToR0(pVM, pMapping);
+    }
+}
+
+
+/**
+ * Finalizes the intermediate context.
+ *
+ * This is called at the end of the ring-3 init and will construct the
+ * intermediate paging structures, relocating all the mappings in the process.
+ *
+ * @returns VBox status code.
+ * @param   pVM     Pointer to the shared VM structure.
+ * @thread  EMT(0)
+ */
+VMMR3DECL(int) PGMR3FinalizeMappings(PVM pVM)
+{
+    AssertReturn(!pVM->pgm.s.fFinalizedMappings, VERR_WRONG_ORDER);
+    pVM->pgm.s.fFinalizedMappings = true;
+
+    /*
+     * Loop until all mappings have been finalized.
+     */
+    /*unsigned    iPDNext = UINT32_C(0xc0000000) >> X86_PD_SHIFT;*/ /* makes CSAM/PATM freak out booting linux. :-/ */
+#if 0
+    unsigned    iPDNext = MM_HYPER_AREA_ADDRESS >> X86_PD_SHIFT;
+#else
+    unsigned    iPDNext = 1 << X86_PD_SHIFT; /* no hint, map them from the top. */
+#endif
+    PPGMMAPPING pCur;
+    do
+    {
+        pCur = pVM->pgm.s.pMappingsR3;
+        while (pCur)
+        {
+            if (!pCur->fFinalized)
+            {
+                /*
+                 * Find a suitable location.
+                 */
+                RTGCPTR const   GCPtrOld = pCur->GCPtr;
+                const unsigned  cPTs     = pCur->cPTs;
+                unsigned        iPDNew   = iPDNext;
+                if (    iPDNew + cPTs >= X86_PG_ENTRIES /* exclude the last PD */
+                    ||  !pgmR3AreIntermediatePDEsUnused(pVM, iPDNew, cPTs)
+                    ||  !pCur->pfnRelocate(pVM, GCPtrOld, (RTGCPTR)iPDNew << X86_PD_SHIFT, PGMRELOCATECALL_SUGGEST, pCur->pvUser))
+                {
+                    /* No luck, just scan down from 4GB-4MB, giving up at 4MB. */
+                    iPDNew = X86_PG_ENTRIES - cPTs - 1;
+                    while (     iPDNew > 0
+                           &&   (   !pgmR3AreIntermediatePDEsUnused(pVM, iPDNew, cPTs)
+                                 || !pCur->pfnRelocate(pVM, GCPtrOld, (RTGCPTR)iPDNew << X86_PD_SHIFT, PGMRELOCATECALL_SUGGEST, pCur->pvUser))
+                           )
+                        iPDNew--;
+                    AssertLogRelReturn(iPDNew != 0, VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
+                }
+
+                /*
+                 * Relocate it (something akin to pgmR3MapRelocate).
+                 */
+                pgmR3MapSetPDEs(pVM, pCur, iPDNew);
+
+                /* unlink the mapping, update the entry and relink it. */
+                pgmR3MapUnlink(pVM, pCur);
+
+                RTGCPTR const GCPtrNew = (RTGCPTR)iPDNew << X86_PD_SHIFT;
+                pCur->GCPtr      = GCPtrNew;
+                pCur->GCPtrLast  = GCPtrNew + pCur->cb - 1;
+                pCur->fFinalized = true;
+
+                pgmR3MapLink(pVM, pCur);
+
+                /* Finally work the callback. */
+                pCur->pfnRelocate(pVM, GCPtrOld, GCPtrNew, PGMRELOCATECALL_RELOCATE, pCur->pvUser);
+
+                /*
+                 * The list order might have changed, start from the beginning again.
+                 */
+                iPDNext = iPDNew + cPTs;
+                break;
+            }
+
+            /* next */
+            pCur = pCur->pNextR3;
+        }
+    } while (pCur);
+
+    return VINF_SUCCESS;
+}
+
+
+/**
  * Gets the size of the current guest mappings if they were to be
  * put next to oneanother.
@@ -526 +718 @@
     AssertMsg(cbPages <= (512 << PAGE_SHIFT), ("The mapping is too big %d bytes\n", cbPages));
     AssertMsg(HCPhys < _4G && HCPhys + cbPages < _4G, ("Addr=%RTptr HCPhys=%RHp cbPages=%d\n", Addr, HCPhys, cbPages));
+    AssertReturn(!pVM->pgm.s.fFinalizedMappings, VERR_WRONG_ORDER);
 
     /*
      * Check for internal conflicts between the virtual address and the physical address.
+     * A 1:1 mapping is fine, but partial overlapping is a no-no.
      */
     if (    uAddress != HCPhys
@@ -537 +731 @@
        )
         AssertLogRelMsgFailedReturn(("Addr=%RTptr HCPhys=%RHp cbPages=%d\n", Addr, HCPhys, cbPages),
-                                    VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
-
-    /* The intermediate mapping must not conflict with our default hypervisor address. */
-    size_t  cbHyper;
-    RTGCPTR pvHyperGC = MMHyperGetArea(pVM, &cbHyper);
-    if (uAddress < pvHyperGC
-        ? uAddress + cbPages > pvHyperGC
-        : pvHyperGC + cbHyper > uAddress
-       )
-        AssertLogRelMsgFailedReturn(("Addr=%RTptr HyperGC=%RGv cbPages=%zu\n", Addr, pvHyperGC, cbPages),
                                     VERR_PGM_INTERMEDIATE_PAGING_CONFLICT);
 

trunk/src/VBox/VMM/testcase/tstVMStructGC.cpp

@@ -499 +499 @@
     GEN_CHECK_OFF(PGM, pMappingsRC);
     GEN_CHECK_OFF(PGM, pMappingsR0);
+    GEN_CHECK_OFF(PGM, fFinalizedMappings);
     GEN_CHECK_OFF(PGM, fMappingsFixed);
     GEN_CHECK_OFF(PGM, GCPtrMappingFixed);