Changeset 32193 in vbox

Timestamp:

Sep 2, 2010 12:56:32 PM (15 years ago)

Author:

vboxsync

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

65497

Message:

FT updates

Location:

trunk/src/VBox/VMM

Files:

• FTM.cpp (modified) (8 diffs)
• FTMInternal.h (modified) (1 diff)
• VM.cpp (modified) (10 diffs)
• include/internal/vm.h (modified) (1 diff)

trunk/src/VBox/VMM/FTM.cpp

@@ -29 +29 @@
 #include <VBox/log.h>
 #include <VBox/pgm.h>
+#include <VBox/pdm.h>
 
 #include <iprt/assert.h>
@@ -590 +591 @@
 };
 
+
 /**
  * VMR3ReqCallWait callback
@@ -602 +604 @@
 }
 
-/**
- * Sync the VM state partially or fully
+
+/**
+ * Sync the VM state
  *
  * @returns VBox status code.
  * @param   pVM         The VM handle.
- * @param   enmState    Which state to sync
- */
-static int ftmR3PerformSync(PVM pVM, FTMSYNCSTATE enmState)
-{
-    int rc;
-    bool fFullSync = false;
-
-    if (enmState != FTMSYNCSTATE_DELTA_MEMORY)
-    {
-        rc = VMR3Suspend(pVM);
-        AssertRCReturn(rc, rc);
-        /** Hack alert as EM is responsible for dealing with the suspend state. We must do this here ourselves, but only for this EMT.*/
-        if (VM_IS_EMT(pVM))
-            EMR3NotifySuspend(pVM);
-    }
-
-    switch (enmState)
-    {
-    case FTMSYNCSTATE_FULL:
-        fFullSync = true;
-        /* no break */
-    case FTMSYNCSTATE_DELTA_VM:
-    {
-        bool fSuspended = false;
-
-        STAM_REL_COUNTER_INC((fFullSync) ? &pVM->ftm.s.StatFullSync : &pVM->ftm.s.StatDeltaVM);
-
-        RTSocketRetain(pVM->ftm.s.hSocket); /* For concurrent access by I/O thread and EMT. */
-
-        /* Reset the sync state. */
-        pVM->ftm.s.syncstate.uOffStream   = 0;
-        pVM->ftm.s.syncstate.cbReadBlock  = 0;
-        pVM->ftm.s.syncstate.fStopReading = false;
-        pVM->ftm.s.syncstate.fIOError     = false;
-        pVM->ftm.s.syncstate.fEndOfStream = false;
-
-        rc = ftmR3TcpSubmitCommand(pVM, (fFullSync) ? "full-sync" : "checkpoint");
-        AssertRC(rc);
-
-        pVM->ftm.s.fDeltaLoadSaveActive = (fFullSync == false);
-        rc = VMR3SaveFT(pVM, &g_ftmR3TcpOps, pVM, &fSuspended);
-        pVM->ftm.s.fDeltaLoadSaveActive = false;
-        AssertRC(rc);
-
-        rc = ftmR3TcpReadACK(pVM, (fFullSync) ? "full-sync-complete" : "checkpoint-complete");
-        AssertRC(rc);
-
-        RTSocketRelease(pVM->ftm.s.hSocket);
-        break;
-    }
-
-    case FTMSYNCSTATE_DELTA_MEMORY:
-        /* Nothing to do as we sync the memory in an async thread; no need to block EMT. */
-        STAM_REL_COUNTER_INC(&pVM->ftm.s.StatDeltaMem);
-        break;
-    }
+ */
+static int ftmR3PerformFullSync(PVM pVM)
+{
+    bool fSuspended = false;
+
+    int rc = VMR3Suspend(pVM);
+    AssertRCReturn(rc, rc);
+
+    STAM_REL_COUNTER_INC(&pVM->ftm.s.StatFullSync);
+
+    RTSocketRetain(pVM->ftm.s.hSocket); /* For concurrent access by I/O thread and EMT. */
+
+    /* Reset the sync state. */
+    pVM->ftm.s.syncstate.uOffStream   = 0;
+    pVM->ftm.s.syncstate.cbReadBlock  = 0;
+    pVM->ftm.s.syncstate.fStopReading = false;
+    pVM->ftm.s.syncstate.fIOError     = false;
+    pVM->ftm.s.syncstate.fEndOfStream = false;
+
+    rc = ftmR3TcpSubmitCommand(pVM, "full-sync");
+    AssertRC(rc);
+
+    pVM->ftm.s.fDeltaLoadSaveActive = false;
+    rc = VMR3SaveFT(pVM, &g_ftmR3TcpOps, pVM, &fSuspended, false /* fSkipStateChanges */);
+    AssertRC(rc);
+
+    rc = ftmR3TcpReadACK(pVM, "full-sync-complete");
+    AssertRC(rc);
+
+    RTSocketRelease(pVM->ftm.s.hSocket);
 
     /* Write protect all memory. */
@@ -668 +645 @@
     AssertRCReturn(rc, rc);
 
-    if (enmState != FTMSYNCSTATE_DELTA_MEMORY)
-    {
-        rc = VMR3Resume(pVM);
-        AssertRCReturn(rc, rc);
-
-        /** Hack alert as EM is responsible for dealing with the suspend state. We must do this here ourselves, but only for this EMT.*/
-        if (VM_IS_EMT(pVM))
-            EMR3NotifyResume(pVM);
-    }
-    return VINF_SUCCESS;
-}
+    rc = VMR3Resume(pVM);
+    AssertRC(rc);
+
+    return rc;
+}
+
 
 /**
@@ -773 +745 @@
      */
 
-    rc = ftmR3PerformSync(pVM, FTMSYNCSTATE_FULL);
+    rc = ftmR3PerformFullSync(pVM);
 
     for (;;)
@@ -790 +762 @@
 
             /* sync the changed memory with the standby node. */
-            rc = ftmR3PerformSync(pVM, FTMSYNCSTATE_DELTA_MEMORY);
+            /* Write protect all memory. */
+            rc = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)ftmR3WriteProtectMemory, 1, pVM);
+            AssertRC(rc);
 
             /* Enumerate all dirty pages and send them to the standby VM. */
@@ -1090 +1064 @@
 }
 
+/**
+ * Rendezvous callback used by FTMR3SetCheckpoint
+ * Sync state + changed memory with the standby node.
+ *
+ * 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) ftmR3SetCheckpointRendezvous(PVM pVM, PVMCPU pVCpu, void *pvUser)
+{
+    int rc = VINF_SUCCESS;
+    bool fSuspended = false;
+
+    /** We don't call VMR3Suspend here to avoid the overhead of state changes and notifications. This 
+     *  is only a short suspend.
+     */
+    PDMR3Suspend(pVM);
+
+    /** Hack alert: as EM is responsible for dealing with the suspend state. We must do this here ourselves, but only for this EMT.*/
+    EMR3NotifySuspend(pVM);
+
+    STAM_REL_COUNTER_INC(&pVM->ftm.s.StatDeltaVM);
+
+    RTSocketRetain(pVM->ftm.s.hSocket); /* For concurrent access by I/O thread and EMT. */
+
+    /* Reset the sync state. */
+    pVM->ftm.s.syncstate.uOffStream   = 0;
+    pVM->ftm.s.syncstate.cbReadBlock  = 0;
+    pVM->ftm.s.syncstate.fStopReading = false;
+    pVM->ftm.s.syncstate.fIOError     = false;
+    pVM->ftm.s.syncstate.fEndOfStream = false;
+
+    rc = ftmR3TcpSubmitCommand(pVM, "checkpoint");
+    AssertRC(rc);
+
+    pVM->ftm.s.fDeltaLoadSaveActive = true;
+    rc = VMR3SaveFT(pVM, &g_ftmR3TcpOps, pVM, &fSuspended, true /* fSkipStateChanges */);
+    pVM->ftm.s.fDeltaLoadSaveActive = false;
+    AssertRC(rc);
+
+    rc = ftmR3TcpReadACK(pVM, "checkpoint-complete");
+    AssertRC(rc);
+
+    RTSocketRelease(pVM->ftm.s.hSocket);
+
+    /* Write protect all memory. */
+    rc = PGMR3PhysWriteProtectRAM(pVM);
+    AssertRC(rc);
+
+    /** We don't call VMR3Resume here to avoid the overhead of state changes and notifications. This 
+     *  is only a short suspend.
+     */
+    PDMR3Resume(pVM);
+
+    /** Hack alert as EM is responsible for dealing with the suspend state. We must do this here ourselves, but only for this EMT.*/
+    EMR3NotifyResume(pVM);
+    return rc;
+}
 
 /**
@@ -1147 +1183 @@
     STAM_PROFILE_START(&pVM->ftm.s.StatCheckpoint, a);
 
-    /* Sync state + changed memory with the standby node. */
-    rc = ftmR3PerformSync(pVM, FTMSYNCSTATE_DELTA_VM);
+    rc = VMMR3EmtRendezvous(pVM, VMMEMTRENDEZVOUS_FLAGS_TYPE_ONCE, ftmR3SetCheckpointRendezvous, NULL);
 
     STAM_PROFILE_STOP(&pVM->ftm.s.StatCheckpoint, a);

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/VM.cpp

@@ -1624 +1624 @@
  * @returns VBox status code.
  *
- * @param   pVM             The VM handle.
- * @param   cMsMaxDowntime  The maximum downtime given as milliseconds.
- * @param   pszFilename     The name of the file.  NULL if pStreamOps is used.
- * @param   pStreamOps      The stream methods.  NULL if pszFilename is used.
- * @param   pvStreamOpsUser The user argument to the stream methods.
- * @param   enmAfter        What to do afterwards.
- * @param   pfnProgress     Progress callback. Optional.
- * @param   pvProgressUser  User argument for the progress callback.
- * @param   ppSSM           Where to return the saved state handle in case of a
- *                          live snapshot scenario.
+ * @param   pVM                 The VM handle.
+ * @param   cMsMaxDowntime      The maximum downtime given as milliseconds.
+ * @param   pszFilename         The name of the file.  NULL if pStreamOps is used.
+ * @param   pStreamOps          The stream methods.  NULL if pszFilename is used.
+ * @param   pvStreamOpsUser     The user argument to the stream methods.
+ * @param   enmAfter            What to do afterwards.
+ * @param   pfnProgress         Progress callback. Optional.
+ * @param   pvProgressUser      User argument for the progress callback.
+ * @param   ppSSM               Where to return the saved state handle in case of a
+ *                              live snapshot scenario.
+ * @param   fSkipStateChanges   Set if we're supposed to skip state changes (FTM delta case)
+ *
  * @thread  EMT
  */
 static DECLCALLBACK(int) vmR3Save(PVM pVM, uint32_t cMsMaxDowntime, const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
-                                  SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser, PSSMHANDLE *ppSSM)
-{
+                                  SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser, PSSMHANDLE *ppSSM,
+                                  bool fSkipStateChanges)
+{
+    int rc = VINF_SUCCESS;
+
     LogFlow(("vmR3Save: pVM=%p cMsMaxDowntime=%u pszFilename=%p:{%s} pStreamOps=%p pvStreamOpsUser=%p enmAfter=%d pfnProgress=%p pvProgressUser=%p ppSSM=%p\n",
              pVM, cMsMaxDowntime, pszFilename, pszFilename, pStreamOps, pvStreamOpsUser, enmAfter, pfnProgress, pvProgressUser, ppSSM));
@@ -1657 +1662 @@
      * Change the state and perform/start the saving.
      */
-    int rc = vmR3TrySetState(pVM, "VMR3Save", 2,
+    if (!fSkipStateChanges)
+    {
+        rc = vmR3TrySetState(pVM, "VMR3Save", 2,
                              VMSTATE_SAVING,     VMSTATE_SUSPENDED,
                              VMSTATE_RUNNING_LS, VMSTATE_RUNNING);
+    }
+    else
+    {
+        Assert(enmAfter != SSMAFTER_TELEPORT);
+        rc = 1;
+    }
+
     if (rc == 1 && enmAfter != SSMAFTER_TELEPORT)
     {
         rc = SSMR3Save(pVM, pszFilename, pStreamOps, pvStreamOpsUser, enmAfter, pfnProgress, pvProgressUser);
-        vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_SAVING);
+        if (!fSkipStateChanges)
+            vmR3SetState(pVM, VMSTATE_SUSPENDED, VMSTATE_SAVING);
     }
     else if (rc == 2 || enmAfter == SSMAFTER_TELEPORT)
     {
+        Assert(!fSkipStateChanges);
         if (enmAfter == SSMAFTER_TELEPORT)
             pVM->vm.s.fTeleportedAndNotFullyResumedYet = true;
@@ -1684 +1700 @@
  * @returns VBox status code.
  *
- * @param   pVM             The VM handle.
+ * @param   pVM                 The VM handle.
  * @param   cMsMaxDowntime      The maximum downtime given as milliseconds.
- * @param   pszFilename     The name of the file.  NULL if pStreamOps is used.
- * @param   pStreamOps      The stream methods.  NULL if pszFilename is used.
- * @param   pvStreamOpsUser The user argument to the stream methods.
- * @param   enmAfter        What to do afterwards.
- * @param   pfnProgress     Progress callback. Optional.
- * @param   pvProgressUser  User argument for the progress callback.
- * @param   pfSuspended     Set if we suspended the VM.
+ * @param   pszFilename         The name of the file.  NULL if pStreamOps is used.
+ * @param   pStreamOps          The stream methods.  NULL if pszFilename is used.
+ * @param   pvStreamOpsUser     The user argument to the stream methods.
+ * @param   enmAfter            What to do afterwards.
+ * @param   pfnProgress         Progress callback. Optional.
+ * @param   pvProgressUser      User argument for the progress callback.
+ * @param   pfSuspended         Set if we suspended the VM.
+ * @param   fSkipStateChanges   Set if we're supposed to skip state changes (FTM delta case)
  *
  * @thread  Non-EMT
@@ -1698 +1715 @@
 static int vmR3SaveTeleport(PVM pVM, uint32_t cMsMaxDowntime,
                             const char *pszFilename, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser,
-                            SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser, bool *pfSuspended)
+                            SSMAFTER enmAfter, PFNVMPROGRESS pfnProgress, void *pvProgressUser, bool *pfSuspended,
+                            bool fSkipStateChanges)
 {
     /*
@@ -1705 +1723 @@
     PSSMHANDLE pSSM;
     int rc = VMR3ReqCallWaitU(pVM->pUVM, 0 /*idDstCpu*/,
-                              (PFNRT)vmR3Save, 9, pVM, cMsMaxDowntime, pszFilename, pStreamOps, pvStreamOpsUser,
-                              enmAfter, pfnProgress, pvProgressUser, &pSSM);
+                              (PFNRT)vmR3Save, 10, pVM, cMsMaxDowntime, pszFilename, pStreamOps, pvStreamOpsUser,
+                              enmAfter, pfnProgress, pvProgressUser, &pSSM, fSkipStateChanges);
     if (    RT_SUCCESS(rc)
         &&  pSSM)
     {
+        Assert(!fSkipStateChanges);
+
         /*
          * Live snapshot.
@@ -1804 +1824 @@
     int rc = vmR3SaveTeleport(pVM, 250 /*cMsMaxDowntime*/,
                               pszFilename, NULL /* pStreamOps */, NULL /* pvStreamOpsUser */,
-                              enmAfter, pfnProgress, pvUser, pfSuspended);
+                              enmAfter, pfnProgress, pvUser, pfSuspended,
+                              false /* fSkipStateChanges */);
     LogFlow(("VMR3Save: returns %Rrc (*pfSuspended=%RTbool)\n", rc, *pfSuspended));
     return rc;
@@ -1826 +1847 @@
  * @param   pvStreamOpsUser     The user argument to the stream methods.
  * @param   pfSuspended         Set if we suspended the VM.
+ * @param   fSkipStateChanges   Set if we're supposed to skip state changes (FTM delta case)
  *
  * @thread      Any
@@ -1832 +1854 @@
  *              RunningLS+SuspeningLS+SuspendedLS+Saving+Suspended.
  */
-VMMR3DECL(int) VMR3SaveFT(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, bool *pfSuspended)
+VMMR3DECL(int) VMR3SaveFT(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, bool *pfSuspended,
+                          bool fSkipStateChanges)
 {
     LogFlow(("VMR3SaveFT: pVM=%p pStreamOps=%p pvSteamOpsUser=%p pfSuspended=%p\n",
@@ -1850 +1873 @@
     int rc = vmR3SaveTeleport(pVM, 250 /*cMsMaxDowntime*/,
                               NULL, pStreamOps, pvStreamOpsUser,
-                              SSMAFTER_CONTINUE, NULL, NULL, pfSuspended);
+                              SSMAFTER_CONTINUE, NULL, NULL, pfSuspended,
+                              fSkipStateChanges);
     LogFlow(("VMR3SaveFT: returns %Rrc (*pfSuspended=%RTbool)\n", rc, *pfSuspended));
     return rc;
@@ -1895 +1919 @@
     int rc = vmR3SaveTeleport(pVM, cMsMaxDowntime,
                               NULL /*pszFilename*/, pStreamOps, pvStreamOpsUser,
-                              SSMAFTER_TELEPORT, pfnProgress, pvProgressUser, pfSuspended);
+                              SSMAFTER_TELEPORT, pfnProgress, pvProgressUser, pfSuspended,
+                              false /* fSkipStateChanges */);
     LogFlow(("VMR3Teleport: returns %Rrc (*pfSuspended=%RTbool)\n", rc, *pfSuspended));
     return rc;

trunk/src/VBox/VMM/include/internal/vm.h

@@ -21 +21 @@
 #include <VBox/vm.h>
 
-VMMR3DECL(int) VMR3SaveFT(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, bool *pfSuspended);
+VMMR3DECL(int) VMR3SaveFT(PVM pVM, PCSSMSTRMOPS pStreamOps, void *pvStreamOpsUser, bool *pfSuspended, bool fSkipStateChanges);
 
 #endif