Changeset 31895 in vbox for trunk/src/VBox

Timestamp:

Aug 24, 2010 9:00:14 AM (15 years ago)

Author:

vboxsync

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

65105

Message:

FT updates

Location:

trunk/src/VBox

Files:

• Frontends/VBoxBFE/VMControl.cpp (modified) (1 diff)
• Main/ConsoleImpl.cpp (modified) (2 diffs)
• VMM/FTM.cpp (modified) (3 diffs)
• VMM/FTMInternal.h (modified) (1 diff)
• VMM/PGMInternal.h (modified) (1 diff)
• VMM/PGMPhys.cpp (modified) (1 diff)
• VMM/PGMPool.cpp (modified) (1 diff)
• VMM/SSM.cpp (modified) (5 diffs)
• VMM/VM.cpp (modified) (4 diffs)
• VMM/testcase/tstSSM.cpp (modified) (1 diff)

trunk/src/VBox/Frontends/VBoxBFE/VMControl.cpp

@@ -132 +132 @@
     startProgressInfo("Saving");
     rc = VMR3ReqCallWait(gpVM, VMCPUID_ANY,
-                         (PFNRT)VMR3Save, 5, gpVM, g_pszStateFile, false /*fContinueAftewards*/, &callProgressInfo, (uintptr_t)NULL);
+                         (PFNRT)VMR3Save, 7, gpVM, g_pszStateFile, 
+                         NULL /* pStreamOps */,
+                         NULL /* pvStreamOpsUser */,
+                         false /*fContinueAftewards*/, &callProgressInfo, (uintptr_t)NULL);
     AssertRC(rc);
     endProgressInfo();

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -7803 +7803 @@
             int vrc = VMR3Save(that->mpVM,
                                strSavedStateFile.c_str(),
+                               NULL /* pStreamOps */,
+                               NULL /* pvStreamOpsUser */,
                                true /*fContinueAfterwards*/,
                                Console::stateProgressCallback,
@@ -8062 +8064 @@
     int vrc = VMR3Save(that->mpVM,
                        task->mSavedStateFile.c_str(),
+                        NULL /* pStreamOps */,
+                        NULL /* pvStreamOpsUser */,
                        false, /*fContinueAfterwards*/
                        Console::stateProgressCallback,

trunk/src/VBox/VMM/FTM.cpp

@@ -521 +521 @@
 
 /**
+ * Sync the VM state partially or fully
+ *
+ * @returns VBox status code.
+ * @param   pVM         The VM handle.
+ * @param   enmState    Which state to sync
+ */
+static DECLCALLBACK(void) ftmR3PerformSync(PVM pVM, FTMSYNCSTATE enmState)
+{
+    int rc;
+
+    if (enmState != FTMSYNCSTATE_DELTA_MEMORY)
+    {
+        rc = VMR3Suspend(pVM);
+        AssertReturnVoid(RT_SUCCESS(rc));
+    }
+
+    switch (enmState)
+    {
+    case FTMSYNCSTATE_FULL:
+        break;
+
+    case FTMSYNCSTATE_DELTA_VM:
+        break;
+
+    case FTMSYNCSTATE_DELTA_MEMORY:
+        break;
+    }
+    /* Write protect all memory. */
+    rc = PGMR3PhysWriteProtectRAM(pVM);
+    AssertRC(rc);
+
+    if (enmState != FTMSYNCSTATE_DELTA_MEMORY)
+    {
+        rc = VMR3Resume(pVM);
+        AssertRC(rc);
+    }
+}
+
+/**
  * Thread function which starts syncing process for this master VM
  *
@@ -527 +566 @@
  * @return  VINF_SUCCESS (ignored).
  *
- * @note Locks the Console object for writing.
  */
 static DECLCALLBACK(int) ftmR3MasterThread(RTTHREAD Thread, void *pvUser)
@@ -579 +617 @@
      */
 
+    /* First sync all memory and write protect everything so 
+     * we can send changed pages later on.
+     */
+
+    rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)ftmR3PerformSync, 2, pVM, FTMSYNCSTATE_FULL);
+    AssertRC(rc);
+
     for (;;)
     {

trunk/src/VBox/VMM/FTMInternal.h

@@ -29 +29 @@
  * @{
  */
+
+typedef enum
+{
+    /* Sync the changed memory pages. */
+    FTMSYNCSTATE_DELTA_MEMORY,
+    /* Sync the changed state (memory + vm/device internal state) */
+    FTMSYNCSTATE_DELTA_VM,
+    /* Sync the entire VM state. */
+    FTMSYNCSTATE_FULL
+} FTMSYNCSTATE;
 
 

trunk/src/VBox/VMM/PGMInternal.h

@@ -3789 +3789 @@
 void            pgmR3PoolClearAll(PVM pVM, bool fFlushRemTlb);
 DECLCALLBACK(VBOXSTRICTRC) pgmR3PoolClearAllRendezvous(PVM pVM, PVMCPU pVCpu, void *fpvFlushRemTbl);
+void            pgmR3PoolWriteProtectPages(PVM pVM);
 
 #endif /* IN_RING3 */

trunk/src/VBox/VMM/PGMPhys.cpp

@@ -956 +956 @@
     return VERR_NOT_IMPLEMENTED;
 #endif
+}
+
+/**
+ * Rendezvous callback used by PGMR3WriteProtectRAM that write protects all physical RAM
+ *
+ * This is only called on one of the EMTs while the other ones are waiting for
+ * it to complete this function.
+ *
+ * @returns VINF_SUCCESS (VBox strict status code).
+ * @param   pVM         The VM handle.
+ * @param   pVCpu       The VMCPU for the EMT we're being called on. Unused.
+ * @param   pvUser      User parameter
+ */
+static DECLCALLBACK(VBOXSTRICTRC) pgmR3PhysWriteProtectRAMRendezvous(PVM pVM, PVMCPU pVCpu, void *pvUser)
+{
+    int rc = VINF_SUCCESS;
+
+    pgmLock(pVM);
+#ifdef PGMPOOL_WITH_OPTIMIZED_DIRTY_PT
+    pgmPoolResetDirtyPages(pVM);
+#endif
+
+    /** @todo pointless to write protect the physical page pointed to by RSP. */
+
+    /*
+     * Clear all the GCPhys links and rebuild the phys ext free list.
+     */
+    for (PPGMRAMRANGE pRam = pVM->pgm.s.CTX_SUFF(pRamRanges);
+         pRam;
+         pRam = pRam->CTX_SUFF(pNext))
+    {
+        if (!PGM_RAM_RANGE_IS_AD_HOC(pRam))
+        {
+            unsigned iPage = pRam->cb >> PAGE_SHIFT;
+            while (iPage-- > 0)
+            {
+                PPGMPAGE pPage = &pRam->aPages[iPage];
+                if (RT_LIKELY(PGM_PAGE_GET_TYPE(pPage) == PGMPAGETYPE_RAM))
+                {
+                    /*
+                     * A RAM page.
+                     */
+                    switch (PGM_PAGE_GET_STATE(pPage))
+                    {
+                    case PGM_PAGE_STATE_ALLOCATED:                    
+                        /** @todo Optimize this: Don't always re-enable write
+                            * monitoring if the page is known to be very busy. */
+                        if (PGM_PAGE_IS_WRITTEN_TO(pPage))
+                            PGM_PAGE_CLEAR_WRITTEN_TO(pPage);
+
+                        PGM_PAGE_SET_STATE(pPage, PGM_PAGE_STATE_WRITE_MONITORED);
+                        break;
+
+                    case PGM_PAGE_STATE_SHARED:
+                        AssertFailed();
+                        break;
+
+                    case PGM_PAGE_STATE_WRITE_MONITORED:    /* nothing to change. */
+                    default:
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    pgmR3PoolWriteProtectPages(pVM);
+    PGM_INVL_ALL_VCPU_TLBS(pVM);
+    for (VMCPUID idCpu = 0; idCpu < pVM->cCpus; idCpu++)
+        CPUMSetChangedFlags(&pVM->aCpus[idCpu], CPUM_CHANGED_GLOBAL_TLB_FLUSH);
+
+    pgmUnlock(pVM);
+    return rc;
+}
+
+/**
+ * Protect all physical RAM to monitor writes
+ *
+ * @returns VBox status code.
+ * @param   pVM         The VM handle.
+ */
+VMMR3DECL(int) PGMR3PhysWriteProtectRAM(PVM pVM)
+{
+    VM_ASSERT_EMT_RETURN(pVM, VERR_VM_THREAD_NOT_EMT);
+
+    int rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, pgmR3PhysWriteProtectRAMRendezvous, NULL);
+    AssertRC(rc);
+    return rc;
 }
 

trunk/src/VBox/VMM/PGMPool.cpp

@@ -818 +818 @@
 }
 
+/**
+ * Protect all pgm pool page table entries to monitor writes
+ *
+ * @param   pVM         The VM handle.
+ *
+ * Remark: assumes the caller will flush all TLBs (!!)
+ */     
+void pgmR3PoolWriteProtectPages(PVM pVM)
+{
+    Assert(PGMIsLockOwner(pVM));
+    PPGMPOOL pPool = pVM->pgm.s.CTX_SUFF(pPool);
+    unsigned cLeft = pPool->cUsedPages;
+    unsigned iPage = pPool->cCurPages;
+    while (--iPage >= PGMPOOL_IDX_FIRST)
+    {
+        PPGMPOOLPAGE pPage = &pPool->aPages[iPage];
+        if (    pPage->GCPhys != NIL_RTGCPHYS
+            &&  pPage->cPresent)
+        {
+            union
+            {
+                void           *pv;
+                PX86PT          pPT;
+                PPGMSHWPTPAE    pPTPae;
+                PEPTPT          pPTEpt;
+            } uShw;
+            uShw.pv = NULL;
+
+            switch (pPage->enmKind)
+            {
+                /*
+                 * We only care about shadow page tables.
+                 */
+                case PGMPOOLKIND_32BIT_PT_FOR_32BIT_PT:
+                case PGMPOOLKIND_32BIT_PT_FOR_32BIT_4MB:
+                case PGMPOOLKIND_32BIT_PT_FOR_PHYS:
+                    for (unsigned iShw = 0; iShw < RT_ELEMENTS(uShw.pPT); iShw++)
+                    {
+                        if (uShw.pPT->a[iShw].n.u1Present)
+                            uShw.pPT->a[iShw].n.u1Write = 0;
+                    }
+                    break;
+
+                case PGMPOOLKIND_PAE_PT_FOR_32BIT_PT:
+                case PGMPOOLKIND_PAE_PT_FOR_32BIT_4MB:
+                case PGMPOOLKIND_PAE_PT_FOR_PAE_PT:
+                case PGMPOOLKIND_PAE_PT_FOR_PAE_2MB:
+                case PGMPOOLKIND_PAE_PT_FOR_PHYS:
+                    for (unsigned iShw = 0; iShw < RT_ELEMENTS(uShw.pPTPae); iShw++)
+                    {
+                        if (uShw.pPTPae->a[iShw].n.u1Present)
+                            uShw.pPTPae->a[iShw].n.u1Write = 0;
+                    }
+                    break;
+
+                case PGMPOOLKIND_EPT_PT_FOR_PHYS:
+                    for (unsigned iShw = 0; iShw < RT_ELEMENTS(uShw.pPTEpt); iShw++)
+                    {
+                        if (uShw.pPTEpt->a[iShw].n.u1Present)
+                            uShw.pPTEpt->a[iShw].n.u1Write = 0;
+                    }
+                    break;
+
+                default:
+                    break;
+            }
+            if (!--cLeft)
+                break;
+        }
+    }
+}
 
 #ifdef VBOX_WITH_DEBUGGER

trunk/src/VBox/VMM/SSM.cpp

@@ -4886 +4886 @@
  *
  * @param   pVM             The VM handle.
- * @param   pszFilename     Name of the file to save the state in.
+ * @param   pszFilename     Name of the file to save the state in. NULL if pStreamOps is used.
+ * @param   pStreamOps      The stream method table. NULL if pszFilename is
+ *                          used.
+ * @param   pvStreamOpsUser The user argument to the stream methods.
  * @param   enmAfter        What is planned after a successful save operation.
  * @param   pfnProgress     Progress callback. Optional.
@@ -4893 +4896 @@
  * @thread  EMT
  */
-VMMR3DECL(int) SSMR3Save(PVM pVM, const char *pszFilename, SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser)
+VMMR3DECL(int) SSMR3Save(PVM pVM, const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, 
+                         SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvUser)
 {
     LogFlow(("SSMR3Save: pszFilename=%p:{%s} enmAfter=%d pfnProgress=%p pvUser=%p\n", pszFilename, pszFilename, enmAfter, pfnProgress, pvUser));
@@ -4906 +4910 @@
                     VERR_INVALID_PARAMETER);
 
+    AssertReturn(!pszFilename != !pStreamOps, VERR_INVALID_PARAMETER);
+    if (pStreamOps)
+    {
+        AssertReturn(pStreamOps->u32Version == SSMSTRMOPS_VERSION, VERR_INVALID_MAGIC);
+        AssertReturn(pStreamOps->u32EndVersion == SSMSTRMOPS_VERSION, VERR_INVALID_MAGIC);
+        AssertReturn(pStreamOps->pfnWrite, VERR_INVALID_PARAMETER);
+        AssertReturn(pStreamOps->pfnRead, VERR_INVALID_PARAMETER);
+        AssertReturn(pStreamOps->pfnSeek, VERR_INVALID_PARAMETER);
+        AssertReturn(pStreamOps->pfnTell, VERR_INVALID_PARAMETER);
+        AssertReturn(pStreamOps->pfnSize, VERR_INVALID_PARAMETER);
+        AssertReturn(pStreamOps->pfnClose, VERR_INVALID_PARAMETER);
+    }
+
     /*
      * Create the saved state file and handle.
@@ -4913 +4930 @@
      */
     PSSMHANDLE pSSM;
-    int rc = ssmR3SaveDoCreateFile(pVM, pszFilename, NULL /*pStreamOps*/, NULL /*pvStreamOpsUser*/,
+    int rc = ssmR3SaveDoCreateFile(pVM, pszFilename, pStreamOps, pvStreamOpsUser,
                                    enmAfter, pfnProgress, pvUser, &pSSM);
     if (RT_FAILURE(rc))
@@ -4920 +4937 @@
     pSSM->uPercentPrepare = 20;
     pSSM->uPercentDone    = 2;
+    pSSM->fLiveSave       = false;
 
     /*

trunk/src/VBox/VMM/VM.cpp

@@ -1641 +1641 @@
     if (rc == 1 && enmAfter != SSMAFTER_TELEPORT)
     {
-        Assert(!pStreamOps);
-        rc = SSMR3Save(pVM, pszFilename, enmAfter, pfnProgress, pvProgressUser);
+        rc = SSMR3Save(pVM, pszFilename, pStreamOps, pvStreamOpsUser, enmAfter, pfnProgress, pvProgressUser);
         vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_SAVING);
     }
@@ -1749 +1748 @@
  * @param   pVM                 The VM which state should be saved.
  * @param   pszFilename         The name of the save state file.
+ * @param   pStreamOps          The stream methods.
+ * @param   pvStreamOpsUser     The user argument to the stream methods.
  * @param   fContinueAfterwards Whether continue execution afterwards or not.
  *                              When in doubt, set this to true.
@@ -1760 +1761 @@
  *              RunningLS+SuspeningLS+SuspendedLS+Saving+Suspended.
  */
-VMMR3DECL(int) VMR3Save(PVM pVM, const char *pszFilename, bool fContinueAfterwards,
-                        PFNVMPROGRESS pfnProgress, void *pvUser, bool *pfSuspended)
+VMMR3DECL(int) VMR3Save(PVM pVM, const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
+                        bool fContinueAfterwards, PFNVMPROGRESS pfnProgress, void *pvUser, bool *pfSuspended)
 {
     LogFlow(("VMR3Save: pVM=%p pszFilename=%p:{%s} fContinueAfterwards=%RTbool pfnProgress=%p pvUser=%p pfSuspended=%p\n",
@@ -1782 +1783 @@
     SSMAFTER enmAfter = fContinueAfterwards ? SSMAFTER_CONTINUE : SSMAFTER_DESTROY;
     int rc = vmR3SaveTeleport(pVM, 250 /*cMsMaxDowntime*/,
-                              pszFilename, NULL /*pStreamOps*/, NULL /*pvStreamOpsUser*/,
+                              pszFilename, pStreamOps, pvStreamOpsUser,
                               enmAfter, pfnProgress, pvUser, pfSuspended);
     LogFlow(("VMR3Save: returns %Rrc (*pfSuspended=%RTbool)\n", rc, *pfSuspended));

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

@@ -745 +745 @@
      */
     uint64_t u64Start = RTTimeNanoTS();
-    rc = SSMR3Save(pVM, pszFilename, SSMAFTER_DESTROY, NULL, NULL);
+    rc = SSMR3Save(pVM, pszFilename, NULL, NULL, SSMAFTER_DESTROY, NULL, NULL);
     if (RT_FAILURE(rc))
     {