Changeset 25935 in vbox

Timestamp:

Jan 20, 2010 2:43:56 PM (15 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

56774

Message:

PGM,CPUM: Be more careful and flexible with guest mappings on restore. (#4362)

Location:

trunk

Files:

• include/VBox/cpum.h (modified) (1 diff)
• include/VBox/pgm.h (modified) (2 diffs)
• src/VBox/VMM/CPUM.cpp (modified) (6 diffs)
• src/VBox/VMM/CPUMInternal.h (modified) (1 diff)
• src/VBox/VMM/CPUMInternal.mac (modified) (1 diff)
• src/VBox/VMM/PGM.cpp (modified) (4 diffs)
• src/VBox/VMM/PGMInternal.h (modified) (3 diffs)
• src/VBox/VMM/PGMMap.cpp (modified) (23 diffs)
• src/VBox/VMM/PGMSavedState.cpp (modified) (8 diffs)
• src/VBox/VMM/VM.cpp (modified) (1 diff)
• src/VBox/VMM/VMMAll/PGMAll.cpp (modified) (7 diffs)
• src/VBox/VMM/VMMAll/PGMAllBth.h (modified) (5 diffs)
• src/VBox/VMM/VMMAll/PGMAllMap.cpp (modified) (7 diffs)
• src/VBox/VMM/testcase/tstVMStructGC.cpp (modified) (1 diff)

trunk/include/VBox/cpum.h

@@ -930 +930 @@
 VMMR3DECL(void)         CPUMR3Reset(PVM pVM);
 VMMR3DECL(void)         CPUMR3ResetCpu(PVMCPU pVCpu);
+VMMDECL(bool)           CPUMR3IsStateRestorePending(PVM pVM);
 # ifdef DEBUG
 VMMR3DECL(void)         CPUMR3SaveEntryCtx(PVM pVM);
 # endif
 VMMR3DECL(int)          CPUMR3SetCR4Feature(PVM pVM, RTHCUINTREG fOr, RTHCUINTREG fAnd);
-
 VMMR3DECL(RCPTRTYPE(PCCPUMCPUID)) CPUMR3GetGuestCpuIdStdRCPtr(PVM pVM);
 VMMR3DECL(RCPTRTYPE(PCCPUMCPUID)) CPUMR3GetGuestCpuIdExtRCPtr(PVM pVM);

trunk/include/VBox/pgm.h

@@ -306 +306 @@
 #ifndef IN_RING0
 VMMDECL(bool)       PGMMapHasConflicts(PVM pVM);
-VMMDECL(int)        PGMMapResolveConflicts(PVM pVM);
 #endif
 #ifdef VBOX_STRICT
@@ -488 +487 @@
 VMMR3DECL(int)      PGMR3UnmapPT(PVM pVM, RTGCPTR GCPtr);
 VMMR3DECL(int)      PGMR3FinalizeMappings(PVM pVM);
+VMMR3DECL(int)      PGMR3MappingsDisable(PVM pVM);
 VMMR3DECL(int)      PGMR3MappingsSize(PVM pVM, uint32_t *pcb);
 VMMR3DECL(int)      PGMR3MappingsFix(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb);
 VMMR3DECL(int)      PGMR3MappingsUnfix(PVM pVM);
-VMMR3DECL(int)      PGMR3MappingsDisable(PVM pVM);
+VMMR3DECL(bool)     PGMR3MappingsNeedReFixing(PVM pVM);
 VMMR3DECL(int)      PGMR3MapIntermediate(PVM pVM, RTUINTPTR Addr, RTHCPHYS HCPhys, unsigned cbPages);
 VMMR3DECL(int)      PGMR3MapRead(PVM pVM, void *pvDst, RTGCPTR GCPtrSrc, size_t cb);

trunk/src/VBox/VMM/CPUM.cpp

@@ -104 +104 @@
 static DECLCALLBACK(int)  cpumR3LiveExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uPass);
 static DECLCALLBACK(int)  cpumR3SaveExec(PVM pVM, PSSMHANDLE pSSM);
+static DECLCALLBACK(int)  cpumR3LoadPrep(PVM pVM, PSSMHANDLE pSSM);
 static DECLCALLBACK(int)  cpumR3LoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+static DECLCALLBACK(int)  cpumR3LoadDone(PVM pVM, PSSMHANDLE pSSM);
 static DECLCALLBACK(void) cpumR3InfoAll(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 static DECLCALLBACK(void) cpumR3InfoGuest(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
@@ -214 +216 @@
                                    NULL, cpumR3LiveExec, NULL,
                                    NULL, cpumR3SaveExec, NULL,
-                                   NULL, cpumR3LoadExec, NULL);
+                                   cpumR3LoadPrep, cpumR3LoadExec, cpumR3LoadDone);
     if (RT_FAILURE(rc))
         return rc;
@@ -1876 +1878 @@
 
 /**
- * Execute state load operation.
- *
- * @returns VBox status code.
- * @param   pVM             VM Handle.
- * @param   pSSM            SSM operation handle.
- * @param   uVersion        Data layout version.
- * @param   uPass           The data pass.
+ * @copydoc FNSSMINTLOADPREP
+ */
+static DECLCALLBACK(int) cpumR3LoadPrep(PVM pVM, PSSMHANDLE pSSM)
+{
+    pVM->cpum.s.fPendingRestore = true;
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * @copydoc FNSSMINTLOADEXEC
  */
 static DECLCALLBACK(int) cpumR3LoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
@@ -1960 +1966 @@
         }
     }
+
+    pVM->cpum.s.fPendingRestore = false;
 
     /*
@@ -2078 +2086 @@
 
     return rc;
+}
+
+
+/**
+ * @copydoc FNSSMINTLOADPREP
+ */
+static DECLCALLBACK(int) cpumR3LoadDone(PVM pVM, PSSMHANDLE pSSM)
+{
+    if (RT_FAILURE(SSMR3HandleGetStatus(pSSM)))
+        return VINF_SUCCESS;
+
+    /* just check this since we can. */ /** @todo Add a SSM unit flag for indicating that it's mandatory during a restore.  */
+    if (pVM->cpum.s.fPendingRestore)
+    {
+        LogRel(("CPUM: Missing state!\n"));
+        return VERR_INTERNAL_ERROR_2;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+/**
+ * Checks if the CPUM state restore is still pending.
+ *
+ * @returns true / false.
+ * @param   pVM                 The VM handle.
+ */
+VMMDECL(bool) CPUMR3IsStateRestorePending(PVM pVM)
+{
+    return pVM->cpum.s.fPendingRestore;
 }
 
@@ -3471 +3510 @@
 VMMR3DECL(void) CPUMR3SaveEntryCtx(PVM pVM)
 {
-    /* @todo SMP support!! */
+    /** @todo SMP support!! */
     pVM->cpum.s.GuestEntry = *CPUMQueryGuestCtxPtr(VMMGetCpu(pVM));
 }

trunk/src/VBox/VMM/CPUMInternal.h

@@ -302 +302 @@
     /** Synthetic CPU type? */
     bool                    fSyntheticCpu;
-    uint8_t                 abPadding[2 + (HC_ARCH_BITS == 64) * 4];
+    /** Indiciates that a state restore is pending.
+     * This is used to verify load order dependencies (PGM). */
+    bool                    fPendingRestore;
+    uint8_t                 abPadding[1 + (HC_ARCH_BITS == 64) * 4];
 
     /** The standard set of CpuId leafs. */

trunk/src/VBox/VMM/CPUMInternal.mac

@@ -73 +73 @@
     .fRawEntered          resb    1
     .fSyntheticCpu        resb    1
+    .fPendingRestore      resb    1
 %if RTHCPTR_CB == 8
-    .abPadding            resb    6
+    .abPadding            resb    5
 %else
-    .abPadding            resb    2
+    .abPadding            resb    1
 %endif
 

trunk/src/VBox/VMM/PGM.cpp

@@ -638 +638 @@
 /** @todo Convert the first two commands to 'info' items. */
 static DECLCALLBACK(int)  pgmR3CmdRam(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
-static DECLCALLBACK(int)  pgmR3CmdMap(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
 static DECLCALLBACK(int)  pgmR3CmdError(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
 static DECLCALLBACK(int)  pgmR3CmdSync(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult);
@@ -672 +671 @@
     /* pszCmd,  cArgsMin, cArgsMax, paArgDesc,                cArgDescs,    pResultDesc,        fFlags,     pfnHandler          pszSyntax,          ....pszDescription */
     { "pgmram",        0, 0,        NULL,                     0,            NULL,               0,          pgmR3CmdRam,        "",                     "Display the ram ranges." },
-    { "pgmmap",        0, 0,        NULL,                     0,            NULL,               0,          pgmR3CmdMap,        "",                     "Display the mapping ranges." },
     { "pgmsync",       0, 0,        NULL,                     0,            NULL,               0,          pgmR3CmdSync,       "",                     "Sync the CR3 page." },
     { "pgmerror",      0, 1,        &g_aPgmErrorArgs[0],      1,            NULL,               0,          pgmR3CmdError,      "",                     "Enables inject runtime of errors into parts of PGM." },
@@ -2224 +2222 @@
      * Unfix any fixed mappings and disable CR3 monitoring.
      */
-    pVM->pgm.s.fMappingsFixed    = false;
-    pVM->pgm.s.GCPtrMappingFixed = 0;
-    pVM->pgm.s.cbMappingFixed    = 0;
-
-    /* Exit the guest paging mode before the pgm pool gets reset.
+    pVM->pgm.s.fMappingsFixed         = false;
+    pVM->pgm.s.fMappingsFixedRestored = false;
+    pVM->pgm.s.GCPtrMappingFixed      = NIL_RTGCPTR;
+    pVM->pgm.s.cbMappingFixed         = 0;
+
+    /*
+     * Exit the guest paging mode before the pgm pool gets reset.
      * Important to clean up the amd64 case.
      */
@@ -4034 +4034 @@
 
 /**
- * The '.pgmmap' command.
- *
- * @returns VBox status.
- * @param   pCmd        Pointer to the command descriptor (as registered).
- * @param   pCmdHlp     Pointer to command helper functions.
- * @param   pVM         Pointer to the current VM (if any).
- * @param   paArgs      Pointer to (readonly) array of arguments.
- * @param   cArgs       Number of arguments in the array.
- */
-static DECLCALLBACK(int) pgmR3CmdMap(PCDBGCCMD pCmd, PDBGCCMDHLP pCmdHlp, PVM pVM, PCDBGCVAR paArgs, unsigned cArgs, PDBGCVAR pResult)
-{
-    /*
-     * Validate input.
-     */
-    if (!pVM)
-        return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "error: The command requires a VM to be selected.\n");
-    if (!pVM->pgm.s.pMappingsR3)
-        return pCmdHlp->pfnPrintf(pCmdHlp, NULL, "Sorry, no mappings are registered.\n");
-
-    /*
-     * Print message about the fixedness of the mappings.
-     */
-    int rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL, pVM->pgm.s.fMappingsFixed ? "The mappings are FIXED.\n" : "The mappings are FLOATING.\n");
-    if (RT_FAILURE(rc))
-        return rc;
-
-    /*
-     * Dump the ranges.
-     */
-    PPGMMAPPING pCur;
-    for (pCur = pVM->pgm.s.pMappingsR3; pCur; pCur = pCur->pNextR3)
-    {
-        rc = pCmdHlp->pfnPrintf(pCmdHlp, NULL,
-            "%08x - %08x %s\n",
-            pCur->GCPtr, pCur->GCPtrLast, pCur->pszDesc);
-        if (RT_FAILURE(rc))
-            return rc;
-    }
-
-    return VINF_SUCCESS;
-}
-
-
-/**
  * The '.pgmerror' and '.pgmerroroff' commands.
  *

trunk/src/VBox/VMM/PGMInternal.h

@@ -2516 +2516 @@
      * PGMR3MapIntermediate calls will be rejected. */
     bool                            fFinalizedMappings;
-    /** If set no conflict checks are required.  (boolean) */
+    /** If set no conflict checks are required. */
     bool                            fMappingsFixed;
-    /** If set, then no mappings are put into the shadow page table. (boolean) */
-    bool                            fDisableMappings;
-    /** Size of fixed mapping */
+    /** If set if restored as fixed but we were unable to re-fixate at the old
+     *  location because of room or address incompatibilities. */
+    bool                            fMappingsFixedRestored;
+    /** If set, then no mappings are put into the shadow page table.
+     * Use pgmMapAreMappingsEnabled() instead of direct access. */
+    bool                            fMappingsDisabled;
+    /** Size of fixed mapping.
+     * This is valid if either fMappingsFixed or fMappingsFixedRestored is set. */
     uint32_t                        cbMappingFixed;
-    /** Base address (GC) of fixed mapping */
+    /** Base address (GC) of fixed mapping.
+     * This is valid if either fMappingsFixed or fMappingsFixedRestored is set. */
     RTGCPTR                         GCPtrMappingFixed;
     /** The address of the previous RAM range mapping. */
@@ -3243 +3249 @@
 void            pgmUnlock(PVM pVM);
 
+int             pgmR3MappingsFixInternal(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb);
 int             pgmR3SyncPTResolveConflict(PVM pVM, PPGMMAPPING pMapping, PX86PD pPDSrc, RTGCPTR GCPtrOldMapping);
 int             pgmR3SyncPTResolveConflictPAE(PVM pVM, PPGMMAPPING pMapping, RTGCPTR GCPtrOldMapping);
 PPGMMAPPING     pgmGetMapping(PVM pVM, RTGCPTR GCPtr);
-void            pgmR3MapRelocate(PVM pVM, PPGMMAPPING pMapping, RTGCPTR GCPtrOldMapping, RTGCPTR GCPtrNewMapping);
+int             pgmMapResolveConflicts(PVM pVM);
 DECLCALLBACK(void) pgmR3MapInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs);
 
@@ -4889 +4896 @@
 }
 
-/**
- * Tells if mappings are to be put into the shadow page table or not
+
+/**
+ * Tells if mappings are to be put into the shadow page table or not.
  *
  * @returns boolean result
  * @param   pVM         VM handle.
  */
-DECLINLINE(bool) pgmMapAreMappingsEnabled(PPGM pPGM)
-{
-#ifdef IN_RING0
+DECL_FORCE_INLINE(bool) pgmMapAreMappingsEnabled(PPGM pPGM)
+{
+#ifdef PGM_WITHOUT_MAPPINGS
     /* There are no mappings in VT-x and AMD-V mode. */
-    Assert(pPGM->fDisableMappings);
+    Assert(pPGM->fMappingsDisabled);
     return false;
 #else
-    return !pPGM->fDisableMappings;
+    return !pPGM->fMappingsDisabled;
+#endif
+}
+
+
+/**
+ * Checks if the mappings are floating and enabled.
+ *
+ * @returns true / false.
+ * @param   pVM         The VM handle.
+ */
+DECL_FORCE_INLINE(bool) pgmMapAreMappingsFloating(PPGM pPGM)
+{
+#ifdef PGM_WITHOUT_MAPPINGS
+    /* There are no mappings in VT-x and AMD-V mode. */
+    Assert(pPGM->fMappingsDisabled);
+    return false;
+#else
+    return !pPGM->fMappingsDisabled
+        && !pPGM->fMappingsFixed;
 #endif
 }

trunk/src/VBox/VMM/PGMMap.cpp

@@ -74 +74 @@
     cb = RT_ALIGN_32(cb, _4M);
     RTGCPTR GCPtrLast = GCPtr + cb - 1;
-    if (GCPtrLast < GCPtr)
-    {
-        AssertMsgFailed(("Range wraps! GCPtr=%x GCPtrLast=%x\n", GCPtr, GCPtrLast));
-        return VERR_INVALID_PARAMETER;
-    }
-    if (pVM->pgm.s.fMappingsFixed)
-    {
-        AssertMsgFailed(("Mappings are fixed! It's not possible to add new mappings at this time!\n"));
-        return VERR_PGM_MAPPINGS_FIXED;
-    }
-    if (!pfnRelocate)
-    {
-        AssertMsgFailed(("Callback is required\n"));
-        return VERR_INVALID_PARAMETER;
-    }
+
+    AssertMsgReturn(GCPtrLast >= GCPtr, ("Range wraps! GCPtr=%x GCPtrLast=%x\n", GCPtr, GCPtrLast),
+                    VERR_INVALID_PARAMETER);
+    AssertMsgReturn(!pVM->pgm.s.fMappingsFixed, ("Mappings are fixed! It's not possible to add new mappings at this time!\n"),
+                    VERR_PGM_MAPPINGS_FIXED);
+    AssertPtrReturn(pfnRelocate, VERR_INVALID_PARAMETER);
 
     /*
@@ -142 +133 @@
     pNew->GCPtrLast     = GCPtrLast;
     pNew->cb            = cb;
-    pNew->pszDesc       = pszDesc;
     pNew->pfnRelocate   = pfnRelocate;
     pNew->pvUser        = pvUser;
+    pNew->pszDesc       = pszDesc;
     pNew->cPTs          = cPTs;
 
@@ -268 +259 @@
              */
             MMHyperFree(pVM, pCur->aPTs[0].pPTR3);
-            pgmR3MapClearPDEs(pVM, pCur, pCur->GCPtr >> X86_PD_SHIFT);
+            if (pCur->GCPtr != NIL_RTGCPTR)
+                pgmR3MapClearPDEs(pVM, pCur, pCur->GCPtr >> X86_PD_SHIFT);
             MMHyperFree(pVM, pCur);
 
@@ -414 +406 @@
      * 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 = UINT32_C(0xc0000000) >> X86_PD_SHIFT; /* makes CSAM/PATM freak out booting linux. :-/ */
+#elif 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
@@ -504 +498 @@
 
 /**
- * Fixes the guest context mappings in a range reserved from the Guest OS.
+ * Fixates the guest context mappings in a range reserved from the Guest OS.
  *
  * @returns VBox status code.
@@ -513 +507 @@
 VMMR3DECL(int) PGMR3MappingsFix(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb)
 {
-    Log(("PGMR3MappingsFix: GCPtrBase=%#x cb=%#x\n", GCPtrBase, cb));
-
-    /* Ignore the additions mapping fix call in VT-x/AMD-V. */
-    if (    pVM->pgm.s.fMappingsFixed
-        &&  HWACCMIsEnabled(pVM))
+    Log(("PGMR3MappingsFix: GCPtrBase=%RGv cb=%#x (fMappingsFixed=%RTbool fMappingsDisabled=%RTbool)\n",
+         GCPtrBase, cb, pVM->pgm.s.fMappingsFixed, pVM->pgm.s.fMappingsDisabled));
+
+    /*
+     * Ignore the additions mapping fix call if disabled.
+     */
+    if (!pgmMapAreMappingsEnabled(&pVM->pgm.s))
+    {
+        Assert(HWACCMIsEnabled(pVM));
         return VINF_SUCCESS;
-
-    /* Only applies to VCPU 0 as we don't support SMP guests with raw mode. */
+    }
+
+    /*
+     * Only applies to VCPU 0 as we don't support SMP guests with raw mode.
+     */
     Assert(pVM->cCpus == 1);
-
     PVMCPU pVCpu = &pVM->aCpus[0];
-
-    /*
-     * This is all or nothing at all. So, a tiny bit of paranoia first.
-     */
-    if (GCPtrBase & X86_PAGE_4M_OFFSET_MASK)
-    {
-        AssertMsgFailed(("GCPtrBase (%#x) has to be aligned on a 4MB address!\n", GCPtrBase));
-        return VERR_INVALID_PARAMETER;
-    }
-    if (!cb || (cb & X86_PAGE_4M_OFFSET_MASK))
-    {
-        AssertMsgFailed(("cb (%#x) is 0 or not aligned on a 4MB address!\n", cb));
-        return VERR_INVALID_PARAMETER;
-    }
 
     /*
@@ -544 +530 @@
      */
     PGMSyncCR3(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR3(pVCpu), CPUMGetGuestCR4(pVCpu), true);
+
+    return pgmR3MappingsFixInternal(pVM, GCPtrBase, cb);
+}
+
+
+/**
+ * Internal worker for PGMR3MappingsFix and pgmR3Load.
+ *
+ * (This does not perform a SyncCR3 before the fixation like PGMR3MappingsFix.)
+ *
+ * @returns VBox status code.
+ * @param   pVM         The VM.
+ * @param   GCPtrBase   The address of the reserved range of guest memory.
+ * @param   cb          The size of the range starting at GCPtrBase.
+ */
+int pgmR3MappingsFixInternal(PVM pVM, RTGCPTR GCPtrBase, uint32_t cb)
+{
+    /*
+     * Check input arguments and pre-conditions.
+     */
+    AssertMsgReturn(!(GCPtrBase & X86_PAGE_4M_OFFSET_MASK), ("GCPtrBase (%#x) has to be aligned on a 4MB address!\n", GCPtrBase),
+                    VERR_INVALID_PARAMETER);
+    AssertMsgReturn(cb && !(cb & X86_PAGE_4M_OFFSET_MASK), ("cb (%#x) is 0 or not aligned on a 4MB address!\n", cb),
+                    VERR_INVALID_PARAMETER);
+    AssertReturn(pgmMapAreMappingsEnabled(&pVM->pgm.s), VERR_INTERNAL_ERROR_3);
+    AssertReturn(pVM->cCpus == 1, VERR_INTERNAL_ERROR_4);
 
     /*
@@ -574 +586 @@
      * In PAE / PAE mode, make sure we don't cross page directories.
      */
+    PVMCPU pVCpu = &pVM->aCpus[0];
     if (    (   pVCpu->pgm.s.enmGuestMode  == PGMMODE_PAE
              || pVCpu->pgm.s.enmGuestMode  == PGMMODE_PAE_NX)
@@ -619 +632 @@
     while (pCur)
     {
-        unsigned iPDOld = pCur->GCPtr >> X86_PD_SHIFT;
-        iPDNew = GCPtrCur >> X86_PD_SHIFT;
+        RTGCPTR const GCPtrOld = pCur->GCPtr;
 
         /*
          * Relocate the page table(s).
          */
-        pgmR3MapClearPDEs(pVM, pCur, iPDOld);
-        pgmR3MapSetPDEs(pVM, pCur, iPDNew);
+        if (pCur->GCPtr != NIL_RTGCPTR)
+            pgmR3MapClearPDEs(pVM, pCur, GCPtrOld >> X86_PD_SHIFT);
+        pgmR3MapSetPDEs(pVM, pCur, GCPtrCur >> X86_PD_SHIFT);
 
         /*
@@ -637 +650 @@
          * Callback to execute the relocation.
          */
-        pCur->pfnRelocate(pVM, iPDOld << X86_PD_SHIFT, iPDNew << X86_PD_SHIFT, PGMRELOCATECALL_RELOCATE, pCur->pvUser);
+        pCur->pfnRelocate(pVM, GCPtrOld, GCPtrCur, PGMRELOCATECALL_RELOCATE, pCur->pvUser);
 
         /*
@@ -647 +660 @@
 
     /*
-     * Mark the mappings as fixed and return.
-     */
-    pVM->pgm.s.fMappingsFixed    = true;
-    pVM->pgm.s.GCPtrMappingFixed = GCPtrBase;
-    pVM->pgm.s.cbMappingFixed    = cb;
+     * Mark the mappings as fixed at this new location and return.
+     */
+    pVM->pgm.s.fMappingsFixed           = true;
+    pVM->pgm.s.fMappingsFixedRestored   = false;
+    pVM->pgm.s.GCPtrMappingFixed        = GCPtrBase;
+    pVM->pgm.s.cbMappingFixed           = cb;
 
     for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
@@ -661 +675 @@
 }
 
-/**
- * Disable the hypervisor mappings in the shadow page tables (doesn't touch the intermediate table!)
+
+/**
+ * Interface for disabling the guest mappings when switching to HWACCM mode
+ * during VM creation and VM reset.
+ *
+ * (This doesn't touch the intermediate table!)
  *
  * @returns VBox status code.
@@ -669 +687 @@
 VMMR3DECL(int) PGMR3MappingsDisable(PVM pVM)
 {
-    uint32_t cb;
-    int rc = PGMR3MappingsSize(pVM, &cb);
-    AssertRCReturn(rc, rc);
-
-    /* Only applies to VCPU 0. */
-    PVMCPU pVCpu = &pVM->aCpus[0];
-
-    pgmLock(pVM);                           /* to avoid assertions */
-    rc = pgmMapDeactivateCR3(pVM, pVCpu->pgm.s.pShwPageCR3R3);
-    pgmUnlock(pVM);
-    AssertRCReturn(rc, rc);
-
-    /*
-     * Mark the mappings as fixed (using fake values) and disabled.
-     */
-    pVM->pgm.s.fDisableMappings  = true;
-    pVM->pgm.s.fMappingsFixed    = true;
-    pVM->pgm.s.GCPtrMappingFixed = MM_HYPER_AREA_ADDRESS;
-    pVM->pgm.s.cbMappingFixed    = cb;
+    AssertReturn(!pVM->pgm.s.fMappingsFixed,            VERR_INTERNAL_ERROR_4);
+    AssertReturn(!pVM->pgm.s.fMappingsFixedRestored,    VERR_INTERNAL_ERROR_4);
+    if (pVM->pgm.s.fMappingsDisabled)
+        return VINF_SUCCESS;
+
+    /*
+     * Deactivate (only applies to Virtual CPU #0).
+     */
+    if (pVM->aCpus[0].pgm.s.pShwPageCR3R3)
+    {
+        pgmLock(pVM);                           /* to avoid assertions */
+        int rc = pgmMapDeactivateCR3(pVM, pVM->aCpus[0].pgm.s.pShwPageCR3R3);
+        pgmUnlock(pVM);
+        AssertRCReturn(rc, rc);
+    }
+
+    /*
+     * Mark the mappings as disabled and trigger a CR3 re-sync.
+     */
+    pVM->pgm.s.fMappingsDisabled = true;
     for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
     {
@@ -699 +718 @@
 /**
  * Unfixes the mappings.
- * After calling this function mapping conflict detection will be enabled.
+ *
+ * Unless PGMR3MappingsDisable is in effect, mapping conflict detection will be
+ * enabled after this call.  If the mappings are fixed, a full CR3 resync will
+ * take place afterwards.
  *
  * @returns VBox status code.
@@ -706 +728 @@
 VMMR3DECL(int) PGMR3MappingsUnfix(PVM pVM)
 {
-    Log(("PGMR3MappingsUnfix: fMappingsFixed=%d\n", pVM->pgm.s.fMappingsFixed));
-
-    /* Ignore in VT-x/AMD-V mode. */
-    if (HWACCMIsEnabled(pVM))
-        return VINF_SUCCESS;
-
-    pVM->pgm.s.fMappingsFixed    = false;
-    pVM->pgm.s.GCPtrMappingFixed = 0;
-    pVM->pgm.s.cbMappingFixed    = 0;
-    for (VMCPUID i = 0; i < pVM->cCpus; i++)
-    {
-        PVMCPU pVCpu = &pVM->aCpus[i];
-        VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
+    Log(("PGMR3MappingsUnfix: fMappingsFixed=%RTbool fMappingsDisabled=%RTbool\n", pVM->pgm.s.fMappingsFixed, pVM->pgm.s.fMappingsDisabled));
+    if (   pgmMapAreMappingsEnabled(&pVM->pgm.s)
+        && (    pVM->pgm.s.fMappingsFixed
+            ||  pVM->pgm.s.fMappingsFixedRestored)
+       )
+    {
+        bool const fResyncCR3 = pVM->pgm.s.fMappingsFixed;
+
+        pVM->pgm.s.fMappingsFixed           = false;
+        pVM->pgm.s.fMappingsFixedRestored   = false;
+        pVM->pgm.s.GCPtrMappingFixed        = 0;
+        pVM->pgm.s.cbMappingFixed           = 0;
+
+        if (fResyncCR3)
+            for (VMCPUID i = 0; i < pVM->cCpus; i++)
+                VMCPU_FF_SET(&pVM->aCpus[i], VMCPU_FF_PGM_SYNC_CR3);
     }
     return VINF_SUCCESS;
@@ -725 +750 @@
 
 /**
+ * Checks if the mappings needs re-fixing after a restore.
+ *
+ * @returns true if they need, false if not.
+ * @param   pVM                 The VM handle.
+ */
+VMMR3DECL(bool) PGMR3MappingsNeedReFixing(PVM pVM)
+{
+    VM_ASSERT_VALID_EXT_RETURN(pVM, false);
+    return pVM->pgm.s.fMappingsFixedRestored;
+}
+
+
+/**
  * Map pages into the intermediate context (switcher code).
- * These pages are mapped at both the give virtual address and at
- * the physical address (for identity mapping).
+ *
+ * These pages are mapped at both the give virtual address and at the physical
+ * address (for identity mapping).
  *
  * @returns VBox status code.
@@ -955 +994 @@
          */
         pVM->pgm.s.pInterPD->a[iOldPDE].u        = 0;
+
         /*
          * PAE.
@@ -1028 +1068 @@
  * @param   pMapping            The mapping to relocate.
  * @param   GCPtrOldMapping     The address of the start of the old mapping.
+ *                              NIL_RTGCPTR if not currently mapped.
  * @param   GCPtrNewMapping     The address of the start of the new mapping.
  */
-void pgmR3MapRelocate(PVM pVM, PPGMMAPPING pMapping, RTGCPTR GCPtrOldMapping, RTGCPTR GCPtrNewMapping)
-{
-    unsigned iPDOld = GCPtrOldMapping >> X86_PD_SHIFT;
-    unsigned iPDNew = GCPtrNewMapping >> X86_PD_SHIFT;
-
+static void pgmR3MapRelocate(PVM pVM, PPGMMAPPING pMapping, RTGCPTR GCPtrOldMapping, RTGCPTR GCPtrNewMapping)
+{
     Log(("PGM: Relocating %s from %RGv to %RGv\n", pMapping->pszDesc, GCPtrOldMapping, GCPtrNewMapping));
-    AssertMsg(((unsigned)iPDOld << X86_PD_SHIFT) == pMapping->GCPtr, ("%RGv vs %RGv\n", (RTGCPTR)((unsigned)iPDOld << X86_PD_SHIFT), pMapping->GCPtr));
+    AssertMsg(GCPtrOldMapping == pMapping->GCPtr, ("%RGv vs %RGv\n", GCPtrOldMapping, pMapping->GCPtr));
+    AssertMsg((GCPtrOldMapping >> X86_PD_SHIFT) < X86_PG_ENTRIES, ("%RGv\n", GCPtrOldMapping));
+    AssertMsg((GCPtrNewMapping >> X86_PD_SHIFT) < X86_PG_ENTRIES, ("%RGv\n", GCPtrOldMapping));
 
     /*
      * Relocate the page table(s).
      */
-    pgmR3MapClearPDEs(pVM, pMapping, iPDOld);
-    pgmR3MapSetPDEs(pVM, pMapping, iPDNew);
+    if (GCPtrOldMapping != NIL_RTGCPTR)
+        pgmR3MapClearPDEs(pVM, pMapping, GCPtrOldMapping >> X86_PD_SHIFT);
+    pgmR3MapSetPDEs(pVM, pMapping, GCPtrNewMapping >> X86_PD_SHIFT);
 
     /*
@@ -1060 +1101 @@
 
     /* Find mapping which >= than pMapping. */
-    RTGCPTR     GCPtrNew = iPDNew << X86_PD_SHIFT;
+    RTGCPTR     GCPtrNew = GCPtrNewMapping;
     PPGMMAPPING pPrev = NULL;
     pCur = pVM->pgm.s.pMappingsR3;
@@ -1119 +1160 @@
      * Callback to execute the relocation.
      */
-    pMapping->pfnRelocate(pVM, iPDOld << X86_PD_SHIFT, iPDNew << X86_PD_SHIFT, PGMRELOCATECALL_RELOCATE, pMapping->pvUser);
+    pMapping->pfnRelocate(pVM, GCPtrOldMapping, GCPtrNewMapping, PGMRELOCATECALL_RELOCATE, pMapping->pvUser);
 }
 
@@ -1202 +1243 @@
          * Ask for the mapping.
          */
-        RTGCPTR GCPtrNewMapping = iPDNew << X86_PD_SHIFT;
+        RTGCPTR GCPtrNewMapping = (RTGCPTR32)iPDNew << X86_PD_SHIFT;
 
         if (pMapping->pfnRelocate(pVM, GCPtrOldMapping, GCPtrNewMapping, PGMRELOCATECALL_SUGGEST, pMapping->pvUser))
@@ -1290 +1331 @@
              * Ask for the mapping.
              */
-            RTGCPTR GCPtrNewMapping = ((RTGCPTR32)iPDPTE << X86_PDPT_SHIFT) + (iPDNew << X86_PD_PAE_SHIFT);
+            RTGCPTR GCPtrNewMapping = ((RTGCPTR32)iPDPTE << X86_PDPT_SHIFT) + ((RTGCPTR32)iPDNew << X86_PD_PAE_SHIFT);
 
             if (pMapping->pfnRelocate(pVM, GCPtrOldMapping, GCPtrNewMapping, PGMRELOCATECALL_SUGGEST, pMapping->pvUser))
@@ -1400 +1441 @@
 DECLCALLBACK(void) pgmR3MapInfo(PVM pVM, PCDBGFINFOHLP pHlp, const char *pszArgs)
 {
-    pHlp->pfnPrintf(pHlp, pVM->pgm.s.fMappingsFixed
-                    ? "\nThe mappings are FIXED.\n"
-                    : "\nThe mappings are FLOATING.\n");
+    if (pVM->pgm.s.fMappingsDisabled)
+        pHlp->pfnPrintf(pHlp, "\nThe mappings are DISABLED.\n");
+    else if (pVM->pgm.s.fMappingsFixed)
+        pHlp->pfnPrintf(pHlp, "\nThe mappings are FIXED: %RGv-%RGv\n",
+                        pVM->pgm.s.GCPtrMappingFixed, pVM->pgm.s.GCPtrMappingFixed + pVM->pgm.s.cbMappingFixed - 1);
+    else if (pVM->pgm.s.fMappingsFixedRestored)
+        pHlp->pfnPrintf(pHlp, "\nThe mappings are FLOATING-RESTORED-FIXED: %RGv-%RGv\n",
+                        pVM->pgm.s.GCPtrMappingFixed, pVM->pgm.s.GCPtrMappingFixed + pVM->pgm.s.cbMappingFixed - 1);
+    else
+        pHlp->pfnPrintf(pHlp, "\nThe mappings are FLOATING.\n");
+
     PPGMMAPPING pCur;
     for (pCur = pVM->pgm.s.pMappingsR3; pCur; pCur = pCur->pNextR3)
+    {
         pHlp->pfnPrintf(pHlp, "%RGv - %RGv  %s\n", pCur->GCPtr, pCur->GCPtrLast, pCur->pszDesc);
-}
-
+        if (pCur->cConflicts > 0)
+        {
+            pHlp->pfnPrintf(pHlp, "  %u conflict%s: ", pCur->cConflicts, pCur->cConflicts == 1 ? "" : "s");
+            uint32_t cLeft = RT_MIN(pCur->cConflicts, RT_ELEMENTS(pCur->aGCPtrConflicts));
+            uint32_t i     = pCur->cConflicts;
+            while (cLeft-- > 0)
+            {
+                i = (i - 1) & (PGMMAPPING_CONFLICT_MAX - 1);
+                pHlp->pfnPrintf(pHlp, cLeft ? "%RGv, " : "%RGv\n", pCur->aGCPtrConflicts[i]);
+            }
+        }
+    }
+}
+

trunk/src/VBox/VMM/PGMSavedState.cpp

@@ -47 +47 @@
 *   Defined Constants And Macros                                               *
 *******************************************************************************/
-/** Saved state data unit version. */
+/** Saved state data unit version.
+ * @todo remove the guest mappings from the saved state at next version change! */
 #define PGM_SAVED_STATE_VERSION                 11
 /** Saved state data unit version used during 3.1 development, misses the RAM
@@ -1939 +1940 @@
      * Save basic data (required / unaffected by relocation).
      */
+    bool const fMappingsFixed  = pVM->pgm.s.fMappingsFixed;
+    pVM->pgm.s.fMappingsFixed |= pVM->pgm.s.fMappingsFixedRestored;
     SSMR3PutStruct(pSSM, pPGM, &s_aPGMFields[0]);
+    pVM->pgm.s.fMappingsFixed  = fMappingsFixed;
 
     for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
-    {
-        PVMCPU pVCpu = &pVM->aCpus[idCpu];
-        SSMR3PutStruct(pSSM, &pVCpu->pgm.s, &s_aPGMCpuFields[0]);
-    }
+        SSMR3PutStruct(pSSM, &pVM->aCpus[idCpu].pgm.s, &s_aPGMCpuFields[0]);
 
     /*
@@ -2786 +2787 @@
 
         uint32_t cbRamSizeIgnored;
-        rc = SSMR3GetU32(pSSM, &cbRamSizeIgnored);
+        rc = SSMR3GetU32(pSSM,  &cbRamSizeIgnored);
         if (RT_FAILURE(rc))
             return rc;
@@ -2811 +2812 @@
 
     /*
-     * The guest mappings.
+     * The guest mappings - skipped now, see re-fixation in the caller.
      */
     uint32_t i = 0;
     for (;; i++)
     {
-        /* Check the seqence number / separator. */
-        rc = SSMR3GetU32(pSSM, &u32Sep);
+        rc = SSMR3GetU32(pSSM, &u32Sep);        /* seqence number */
         if (RT_FAILURE(rc))
             return rc;
         if (u32Sep == ~0U)
             break;
-        if (u32Sep != i)
-        {
-            AssertMsgFailed(("u32Sep=%#x (last)\n", u32Sep));
-            return VERR_SSM_DATA_UNIT_FORMAT_CHANGED;
-        }
-
-        /* get the mapping details. */
+        AssertMsgReturn(u32Sep == i, ("u32Sep=%#x i=%#x\n", u32Sep, i), VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
+
         char szDesc[256];
-        szDesc[0] = '\0';
         rc = SSMR3GetStrZ(pSSM, szDesc, sizeof(szDesc));
         if (RT_FAILURE(rc))
             return rc;
-        RTGCPTR GCPtr;
-        SSMR3GetGCPtr(pSSM, &GCPtr);
-        RTGCPTR cPTs;
-        rc = SSMR3GetGCUIntPtr(pSSM, &cPTs);
+        RTGCPTR GCPtrIgnore;
+        SSMR3GetGCPtr(pSSM, &GCPtrIgnore);      /* GCPtr */
+        rc = SSMR3GetGCPtr(pSSM, &GCPtrIgnore); /* cPTs  */
         if (RT_FAILURE(rc))
             return rc;
-
-        /* find matching range. */
-        PPGMMAPPING pMapping;
-        for (pMapping = pPGM->pMappingsR3; pMapping; pMapping = pMapping->pNextR3)
-        {
-            if (    pMapping->cPTs == cPTs
-                &&  !strcmp(pMapping->pszDesc, szDesc))
-                break;
-#ifdef DEBUG_sandervl
-            if (    !strcmp(szDesc, "Hypervisor Memory Area")
-                &&  HWACCMIsEnabled(pVM))
-                break;
-#endif
-        }
-        if (!pMapping)
-            return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Couldn't find mapping: cPTs=%#x szDesc=%s (GCPtr=%RGv)"),
-                                    cPTs, szDesc, GCPtr);
-
-        /* relocate it. */
-        if (    pMapping->GCPtr != GCPtr
-#ifdef DEBUG_sandervl
-             && !(!strcmp(szDesc, "Hypervisor Memory Area") && HWACCMIsEnabled(pVM))
-#endif
-           )
-        {
-            AssertMsg((GCPtr >> X86_PD_SHIFT << X86_PD_SHIFT) == GCPtr, ("GCPtr=%RGv\n", GCPtr));
-            pgmR3MapRelocate(pVM, pMapping, pMapping->GCPtr, GCPtr);
-        }
-        else
-            Log(("pgmR3Load: '%s' needed no relocation (%RGv)\n", szDesc, GCPtr));
     }
 
@@ -2893 +2856 @@
         }
 
-        return pgmR3LoadMemory(pVM, pSSM, SSM_PASS_FINAL);
-    }
-    return pgmR3LoadMemoryOld(pVM, pSSM, uVersion);
+        rc = pgmR3LoadMemory(pVM, pSSM, SSM_PASS_FINAL);
+    }
+    else
+        rc = pgmR3LoadMemoryOld(pVM, pSSM, uVersion);
+    return rc;
 }
 
@@ -2972 +2937 @@
                 VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL);
                 VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
-
                 pVCpu->pgm.s.fSyncFlags |= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL;
             }
@@ -2978 +2942 @@
             pgmR3HandlerPhysicalUpdateAll(pVM);
 
+            /*
+             * Change the paging mode and restore PGMCPU::GCPhysCR3.
+             * (The latter requires the CPUM state to be restored already.)
+             */
+            if (CPUMR3IsStateRestorePending(pVM))
+                return SSMR3SetLoadError(pSSM, VERR_WRONG_ORDER, RT_SRC_POS,
+                                         N_("PGM was unexpectedly restored before CPUM"));
+
             for (VMCPUID i = 0; i < pVM->cCpus; i++)
             {
                 PVMCPU pVCpu = &pVM->aCpus[i];
 
-                /*
-                 * Change the paging mode.
-                 */
                 rc = PGMR3ChangeMode(pVM, pVCpu, pVCpu->pgm.s.enmGuestMode);
+                AssertLogRelRCReturn(rc, rc);
 
                 /* Restore pVM->pgm.s.GCPhysCR3. */
@@ -2999 +2969 @@
                 pVCpu->pgm.s.GCPhysCR3 = GCPhysCR3;
             }
+
+            /*
+             * Try re-fixate the guest mappings.
+             */
+            pVM->pgm.s.fMappingsFixedRestored = false;
+            if (   pVM->pgm.s.fMappingsFixed
+                && pgmMapAreMappingsEnabled(&pVM->pgm.s))
+            {
+                RTGCPTR     GCPtrFixed    = pVM->pgm.s.GCPtrMappingFixed;
+                uint32_t    cbFixed       = pVM->pgm.s.cbMappingFixed;
+                pVM->pgm.s.fMappingsFixed = false;
+
+                uint32_t    cbRequired;
+                int rc2 = PGMR3MappingsSize(pVM, &cbRequired); AssertRC(rc2);
+                if (   RT_SUCCESS(rc2)
+                    && cbRequired > cbFixed)
+                    rc2 = VERR_OUT_OF_RANGE;
+                if (RT_SUCCESS(rc2))
+                    rc2 = pgmR3MappingsFixInternal(pVM, GCPtrFixed, cbFixed);
+                if (RT_FAILURE(rc2))
+                {
+                    LogRel(("PGM: Unable to re-fixate the guest mappings at %RGv-%RGv: rc=%Rrc (cbRequired=%#x)\n",
+                            GCPtrFixed, GCPtrFixed + cbFixed, rc2, cbRequired));
+                    pVM->pgm.s.fMappingsFixed         = false;
+                    pVM->pgm.s.fMappingsFixedRestored = true;
+                    pVM->pgm.s.GCPtrMappingFixed      = GCPtrFixed;
+                    pVM->pgm.s.cbMappingFixed         = cbFixed;
+                }
+            }
+            else
+            {
+                /* We used to set fixed + disabled while we only use disabled now,
+                   so wipe the state to avoid any confusion. */
+                pVM->pgm.s.fMappingsFixed    = false;
+                pVM->pgm.s.GCPtrMappingFixed = NIL_RTGCPTR;
+                pVM->pgm.s.cbMappingFixed    = 0;
+            }
+
+            /*
+             * If we have floating mappings, do a CR3 sync now to make sure the HMA
+             * doesn't conflict with guest code / data and thereby cause trouble
+             * when restoring other components like PATM.
+             */
+            if (pgmMapAreMappingsFloating(&pVM->pgm.s))
+            {
+                PVMCPU pVCpu = &pVM->aCpus[0];
+                rc = PGMSyncCR3(pVCpu, CPUMGetGuestCR0(pVCpu), CPUMGetGuestCR3(pVCpu),  CPUMGetGuestCR4(pVCpu), true);
+                if (RT_FAILURE(rc))
+                    return SSMR3SetLoadError(pSSM, VERR_WRONG_ORDER, RT_SRC_POS,
+                                             N_("PGMSyncCR3 failed unexpectedly with rc=%Rrc"), rc);
+
+                /* Make sure to re-sync before executing code. */
+                VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3_NON_GLOBAL);
+                VMCPU_FF_SET(pVCpu, VMCPU_FF_PGM_SYNC_CR3);
+                pVCpu->pgm.s.fSyncFlags |= PGM_SYNC_UPDATE_PAGE_BIT_VIRTUAL;
+            }
         }
     }

trunk/src/VBox/VMM/VM.cpp

@@ -1019 +1019 @@
         rc = vmR3InitDoCompleted(pVM, VMINITCOMPLETED_RING0);
 
-    /** todo: move this to the VMINITCOMPLETED_RING0 notification handler once implemented */
+    /** @todo Move this to the VMINITCOMPLETED_RING0 notification handler. */
     if (RT_SUCCESS(rc))
         rc = HWACCMR3InitFinalizeR0(pVM);

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

@@ -723 +723 @@
      * Check for conflicts and pending CR3 monitoring updates.
      */
-    if (!pVM->pgm.s.fMappingsFixed)
+    if (pgmMapAreMappingsFloating(&pVM->pgm.s))
     {
         if (    pgmGetMapping(pVM, GCPtrPage)
@@ -763 +763 @@
     {
         pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
-        Assert(!pVM->pgm.s.fMappingsFixed);
+        Assert(!pVM->pgm.s.fMappingsFixed); Assert(!pVM->pgm.s.fMappingsDisabled);
     }
 
@@ -1690 +1690 @@
         if (RT_LIKELY(rc == VINF_SUCCESS))
         {
-            if (!pVM->pgm.s.fMappingsFixed)
-            {
+            if (pgmMapAreMappingsFloating(&pVM->pgm.s))
                 pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
-            }
         }
         else
@@ -1701 +1699 @@
             pVCpu->pgm.s.GCPhysCR3 = GCPhysOldCR3;
             pVCpu->pgm.s.fSyncFlags |= PGM_SYNC_MAP_CR3;
-            if (!pVM->pgm.s.fMappingsFixed)
+            if (pgmMapAreMappingsFloating(&pVM->pgm.s))
                 pVCpu->pgm.s.fSyncFlags |= PGM_SYNC_MONITOR_CR3;
         }
@@ -1727 +1725 @@
         {
             pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
-            Assert(!pVM->pgm.s.fMappingsFixed);
+            Assert(!pVM->pgm.s.fMappingsFixed); Assert(!pVM->pgm.s.fMappingsDisabled);
         }
         if (fGlobal)
@@ -1764 +1762 @@
 
     /* We assume we're only called in nested paging mode. */
-    Assert(pVM->pgm.s.fMappingsFixed);
+    Assert(HWACCMIsNestedPagingActive(pVM) || pVCpu->pgm.s.enmShadowMode == PGMMODE_EPT);
+    Assert(pVM->pgm.s.fMappingsDisabled);
     Assert(!(pVCpu->pgm.s.fSyncFlags & PGM_SYNC_MONITOR_CR3));
-    Assert(HWACCMIsNestedPagingActive(pVM) || pVCpu->pgm.s.enmShadowMode == PGMMODE_EPT);
 
     /*
@@ -1911 +1909 @@
         {
             pVCpu->pgm.s.fSyncFlags &= ~PGM_SYNC_MONITOR_CR3;
-            Assert(!pVM->pgm.s.fMappingsFixed);
+            Assert(!pVM->pgm.s.fMappingsFixed); Assert(!pVM->pgm.s.fMappingsDisabled);
         }
     }

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

@@ -291 +291 @@
                  * The first thing we check is if we've got an undetected conflict.
                  */
-                if (!pVM->pgm.s.fMappingsFixed)
+                if (pgmMapAreMappingsFloating(&pVM->pgm.s))
                 {
                     unsigned iPT = pMapping->cb >> GST_PD_SHIFT;
@@ -2599 +2599 @@
 #  endif
     }
-# else  /* PGM_WITHOUT_MAPPINGS */
-    Assert(!pgmMapAreMappingsEnabled(&pVM->pgm.s));
-# endif /* PGM_WITHOUT_MAPPINGS */
+# endif /* !PGM_WITHOUT_MAPPINGS */
     Assert(!PdeDst.n.u1Present); /* We're only supposed to call SyncPT on PDE!P and conflicts.*/
 
@@ -3449 +3447 @@
     STAM_PROFILE_STOP(&pVCpu->pgm.s.CTX_MID_Z(Stat,SyncCR3Handlers), h);
     pgmUnlock(pVM);
-#endif
+#endif /* !NESTED && !EPT */
 
 #if PGM_SHW_TYPE == PGM_TYPE_NESTED || PGM_SHW_TYPE == PGM_TYPE_EPT
@@ -3457 +3455 @@
     /** @todo check if this is really necessary; the call does it as well... */
     HWACCMFlushTLB(pVCpu);
+    Assert(!pgmMapAreMappingsEnabled(&pVM->pgm.s));
     return VINF_SUCCESS;
 
@@ -3464 +3463 @@
      * out the shadow parts when the guest modifies its tables.
      */
+    Assert(!pgmMapAreMappingsEnabled(&pVM->pgm.s));
     return VINF_SUCCESS;
 
 #else /* PGM_SHW_TYPE != PGM_TYPE_NESTED && PGM_SHW_TYPE != PGM_TYPE_EPT && PGM_SHW_TYPE != PGM_TYPE_AMD64 */
 
-#  ifdef PGM_WITHOUT_MAPPINGS
-    Assert(pVM->pgm.s.fMappingsFixed);
-    return VINF_SUCCESS;
+#  ifndef PGM_WITHOUT_MAPPINGS
+    /*
+     * Check for and resolve conflicts with our guest mappings if they
+     * are enabled and not fixed.
+     */
+    if (pgmMapAreMappingsFloating(&pVM->pgm.s))
+    {
+        int rc = pgmMapResolveConflicts(pVM);
+        Assert(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3);
+        if (rc == VINF_PGM_SYNC_CR3)
+        {
+            LogFlow(("SyncCR3: detected conflict -> VINF_PGM_SYNC_CR3\n"));
+            return VINF_PGM_SYNC_CR3;
+        }
+    }
 #  else
-    /* Nothing to do when mappings are fixed. */
-    if (pVM->pgm.s.fMappingsFixed)
-        return VINF_SUCCESS;
-
-    int rc = PGMMapResolveConflicts(pVM);
-    Assert(rc == VINF_SUCCESS || rc == VINF_PGM_SYNC_CR3);
-    if (rc == VINF_PGM_SYNC_CR3)
-    {
-        LogFlow(("SyncCR3: detected conflict -> VINF_PGM_SYNC_CR3\n"));
-        return VINF_PGM_SYNC_CR3;
-    }
+    Assert(!pgmMapAreMappingsEnabled(&pVM->pgm.s));
 #  endif
     return VINF_SUCCESS;

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

@@ -389 +389 @@
     Log(("pgmMapClearShadowPDEs: old pde %x (cPTs=%x) (mappings enabled %d) fDeactivateCR3=%RTbool\n", iOldPDE, pMap->cPTs, pgmMapAreMappingsEnabled(&pVM->pgm.s), fDeactivateCR3));
 
+    /*
+     * Skip this if disabled or if it doesn't apply.
+     */
     if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
         ||  pVM->cCpus > 1)
@@ -602 +605 @@
         return;
 
+    /* This only applies to raw mode where we only support 1 VCPU. */
     Assert(pVM->cCpus == 1);
-
-    /* This only applies to raw mode where we only support 1 VCPU. */
     PVMCPU pVCpu = VMMGetCpu0(pVM);
     Assert(pVCpu->pgm.s.CTX_SUFF(pShwPageCR3));
@@ -633 +635 @@
 {
     /*
-     * Can skip this if mappings are disabled.
+     * Skip this if disabled or if it doesn't apply.
      */
     if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
@@ -639 +641 @@
         return VINF_SUCCESS;
 
-    /* Note. A log flush (in RC) can cause problems when called from MapCR3 (inconsistent state will trigger assertions). */
-    Log4(("pgmMapActivateCR3: fixed mappings=%d idxShwPageCR3=%#x\n", pVM->pgm.s.fMappingsFixed, pShwPageCR3 ? pShwPageCR3->idx : NIL_PGMPOOL_IDX));
+    /* Note! This might not be logged successfully in RC because we usually
+             cannot flush the log at this point. */
+    Log4(("pgmMapActivateCR3: fixed mappings=%RTbool idxShwPageCR3=%#x\n", pVM->pgm.s.fMappingsFixed, pShwPageCR3 ? pShwPageCR3->idx : NIL_PGMPOOL_IDX));
 
 #ifdef VBOX_STRICT
@@ -669 +672 @@
 {
     /*
-     * Can skip this if mappings are disabled.
+     * Skip this if disabled or if it doesn't apply.
      */
     if (    !pgmMapAreMappingsEnabled(&pVM->pgm.s)
@@ -702 +705 @@
      * Can skip this if mappings are safely fixed.
      */
-    if (pVM->pgm.s.fMappingsFixed)
+    if (!pgmMapAreMappingsFloating(&pVM->pgm.s))
         return false;
 
@@ -788 +791 @@
 
 /**
- * Checks and resolves (ring 3 only) guest conflicts with VMM GC mappings.
+ * Checks and resolves (ring 3 only) guest conflicts with the guest mappings.
  *
  * @returns VBox status.
  * @param   pVM                 The virtual machine.
  */
-VMMDECL(int) PGMMapResolveConflicts(PVM pVM)
-{
-    /*
-     * Can skip this if mappings are safely fixed.
-     */
-    if (pVM->pgm.s.fMappingsFixed)
-        return VINF_SUCCESS;
-
+int pgmMapResolveConflicts(PVM pVM)
+{
+    /* The caller is expected to check these two conditions. */
+    Assert(!pVM->pgm.s.fMappingsFixed);
+    Assert(!pVM->pgm.s.fMappingsDisabled);
+
+    /* This only applies to raw mode where we only support 1 VCPU. */
     Assert(pVM->cCpus == 1);
-
-    /* This only applies to raw mode where we only support 1 VCPU. */
-    PVMCPU pVCpu = &pVM->aCpus[0];
-
-    PGMMODE const enmGuestMode = PGMGetGuestMode(pVCpu);
+    PVMCPU          pVCpu        = &pVM->aCpus[0];
+    PGMMODE const   enmGuestMode = PGMGetGuestMode(pVCpu);
     Assert(enmGuestMode <= PGMMODE_PAE_NX);
 

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

@@ -556 +556 @@
     GEN_CHECK_OFF(PGM, fFinalizedMappings);
     GEN_CHECK_OFF(PGM, fMappingsFixed);
+    GEN_CHECK_OFF(PGM, fMappingsFixedRestored);
+    GEN_CHECK_OFF(PGM, fMappingsDisabled);
     GEN_CHECK_OFF(PGM, GCPtrMappingFixed);
     GEN_CHECK_OFF(PGM, cbMappingFixed);