Changeset 30396 in vbox

Timestamp:

Jun 23, 2010 3:26:41 PM (14 years ago)

Author:

vboxsync

Message:

Teleportation: Make the progress bar move during teleportation. The completion percentage calculation in PGM isn't all that great yet, but that can be fixed later.

Location:

trunk

Files:

• include/VBox/ssm.h (modified) (1 diff)
• src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp (modified) (2 diffs)
• src/VBox/Main/ProgressImpl.cpp (modified) (1 diff)
• src/VBox/VMM/CPUM.cpp (modified) (1 diff)
• src/VBox/VMM/PGMSavedState.cpp (modified) (1 diff)
• src/VBox/VMM/SSM.cpp (modified) (34 diffs)

trunk/include/VBox/ssm.h

@@ -1165 +1165 @@
 VMMR3DECL(uint32_t)     SSMR3HandleVersion(PSSMHANDLE pSSM);
 VMMR3DECL(const char *) SSMR3HandleHostOSAndArch(PSSMHANDLE pSSM);
-VMMR3_INT_DECL(int)     SSMR3SetGCPtrSize(PSSMHANDLE pSSM, unsigned cbGCPtr);
+VMMR3_INT_DECL(int)     SSMR3HandleSetGCPtrSize(PSSMHANDLE pSSM, unsigned cbGCPtr);
+VMMR3DECL(void)         SSMR3HandleReportLivePercent(PSSMHANDLE pSSM, unsigned uPercent);
 VMMR3DECL(int)          SSMR3Cancel(PVM pVM);
 

trunk/src/VBox/Frontends/VBoxManage/VBoxManageControlVM.cpp

@@ -822 +822 @@
             static const RTGETOPTDEF s_aTeleportOptions[] =
             {
-                { "--host",        'h', RTGETOPT_REQ_STRING }, /** @todo RTGETOPT_FLAG_MANDATORY */
-                { "--hostname",    'h', RTGETOPT_REQ_STRING }, /** @todo remove this */
-                { "--maxdowntime", 'd', RTGETOPT_REQ_UINT32 },
-                { "--port",        'p', RTGETOPT_REQ_UINT32 }, /** @todo RTGETOPT_FLAG_MANDATORY */
-                { "--password",    'P', RTGETOPT_REQ_STRING },
-                { "--timeout",     't', RTGETOPT_REQ_UINT32 }
+                { "--host",              'h', RTGETOPT_REQ_STRING }, /** @todo RTGETOPT_FLAG_MANDATORY */
+                { "--hostname",          'h', RTGETOPT_REQ_STRING }, /** @todo remove this */
+                { "--maxdowntime",       'd', RTGETOPT_REQ_UINT32 },
+                { "--port",              'p', RTGETOPT_REQ_UINT32 }, /** @todo RTGETOPT_FLAG_MANDATORY */
+                { "--password",          'P', RTGETOPT_REQ_STRING },
+                { "--timeout",           't', RTGETOPT_REQ_UINT32 },
+                { "--detailed-progress", 'D', RTGETOPT_REQ_NOTHING }
             };
             RTGETOPTSTATE GetOptState;
@@ -840 +841 @@
                     case 'h': bstrHostname  = Value.psz; break;
                     case 'd': uMaxDowntime  = Value.u32; break;
+                    case 'D': g_fDetailedProgress = true; break;
                     case 'p': uPort         = Value.u32; break;
                     case 'P': bstrPassword  = Value.psz; break;

trunk/src/VBox/Main/ProgressImpl.cpp

@@ -977 +977 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    AssertReturn(aPercent <= 100, E_INVALIDARG);
+    AssertMsgReturn(aPercent <= 100, ("%u\n", aPercent), E_INVALIDARG);
 
     checkForAutomaticTimeout();

trunk/src/VBox/VMM/CPUM.cpp

@@ -2085 +2085 @@
          */
         if (uVersion == CPUM_SAVED_STATE_VERSION_VER1_6)
-            SSMR3SetGCPtrSize(pSSM, sizeof(RTGCPTR32));
+            SSMR3HandleSetGCPtrSize(pSSM, sizeof(RTGCPTR32));
         else if (uVersion <= CPUM_SAVED_STATE_VERSION_VER3_0)
-            SSMR3SetGCPtrSize(pSSM, HC_ARCH_BITS == 32 ? sizeof(RTGCPTR32) : sizeof(RTGCPTR));
+            SSMR3HandleSetGCPtrSize(pSSM, HC_ARCH_BITS == 32 ? sizeof(RTGCPTR32) : sizeof(RTGCPTR));
 
         /*

trunk/src/VBox/VMM/PGMSavedState.cpp

@@ -1890 +1890 @@
         }
     }
+
+    /*
+     * Come up with a completion percentage.  Currently this is a simple
+     * dirty page (long term) vs. total pages ratio + some pass trickery.
+     */
+    unsigned uPctDirty = cDirtyPagesLong
+                       / (long double)(pVM->pgm.s.cAllPages - pVM->pgm.s.LiveSave.cIgnoredPages - pVM->pgm.s.cZeroPages);
+    if (uPctDirty <= 100)
+        SSMR3HandleReportLivePercent(pSSM, RT_MIN(100 - uPctDirty, uPass * 2));
+    else
+        AssertMsgFailed(("uPctDirty=%u cDirtyPagesLong=%#x cAllPages=%#x cIgnoredPages=%#x cZeroPages=%#x\n",
+                         uPctDirty, cDirtyPagesLong, pVM->pgm.s.cAllPages, pVM->pgm.s.LiveSave.cIgnoredPages, pVM->pgm.s.cZeroPages));
+
     return VINF_SSM_VOTE_FOR_ANOTHER_PASS;
 }

trunk/src/VBox/VMM/SSM.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2009 Oracle Corporation
+ * Copyright (C) 2006-2010 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -485 +485 @@
     /** End of current unit in the estimated file. */
     uint64_t                offEstUnitEnd;
-    /** the amount of % we reserve for the 'prepare' phase */
+    /** The amount of % we reserve for the 'live' stage */
+    unsigned                uPercentLive;
+    /** The amount of % we reserve for the 'prepare' phase */
     unsigned                uPercentPrepare;
-    /** the amount of % we reserve for the 'done' stage */
+    /** The amount of % we reserve for the 'done' stage */
     unsigned                uPercentDone;
+    /** The lowest value reported via SSMR3HandleReportLivePercent during one
+     * vote run. */
+    unsigned                uReportedLivePercent;
     /** The filename, NULL if remote stream. */
     const char             *pszFilename;
@@ -872 +877 @@
 static DECLCALLBACK(int)    ssmR3SelfSaveExec(PVM pVM, PSSMHANDLE pSSM);
 static DECLCALLBACK(int)    ssmR3SelfLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
+static DECLCALLBACK(int)    ssmR3LiveControlLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass);
 static int                  ssmR3Register(PVM pVM, const char *pszName, uint32_t uInstance, uint32_t uVersion, size_t cbGuess, const char *pszBefore, PSSMUNIT *ppUnit);
+static int                  ssmR3LiveControlEmit(PSSMHANDLE pSSM, long double lrdPct, uint32_t uPass);
 #endif
 
@@ -916 +923 @@
                                    NULL /*pfnSavePrep*/, ssmR3SelfSaveExec, NULL /*pfnSaveDone*/,
                                    NULL /*pfnSavePrep*/, ssmR3SelfLoadExec, NULL /*pfnSaveDone*/);
+    if (RT_SUCCESS(rc))
+        rc = SSMR3RegisterInternal(pVM, "SSMLiveControl", 0 /*uInstance*/, 1 /*uVersion*/, 1 /*cbGuess*/,
+                                   NULL /*pfnLivePrep*/, NULL /*pfnLiveExec*/,     NULL /*pfnLiveVote*/,
+                                   NULL /*pfnSavePrep*/, NULL /*pfnSaveExec*/,     NULL /*pfnSaveDone*/,
+                                   NULL /*pfnSavePrep*/, ssmR3LiveControlLoadExec, NULL /*pfnSaveDone*/);
 
     /*
@@ -1040 +1052 @@
     }
     return VINF_SUCCESS;
+}
+
+
+/**
+ * Load exec callback for the special live save state unit that tracks the
+ * progress of a live save.
+ *
+ * This is saved by ssmR3LiveControlEmit().
+ *
+ * @returns VBox status code.
+ * @param   pVM             Pointer to the shared VM structure.
+ * @param   pSSM            The SSM handle.
+ * @param   uVersion        The version (1).
+ * @param   uPass           The pass.
+ */
+static DECLCALLBACK(int) ssmR3LiveControlLoadExec(PVM pVM, PSSMHANDLE pSSM, uint32_t uVersion, uint32_t uPass)
+{
+    AssertLogRelMsgReturn(uVersion == 1, ("%d", uVersion), VERR_SSM_UNSUPPORTED_DATA_UNIT_VERSION);
+
+    uint16_t uPartsPerTenThousand;
+    int rc = SSMR3GetU16(pSSM, &uPartsPerTenThousand);
+    if (RT_SUCCESS(rc))
+    {
+        /* Scale it down to fit in our exec range. */
+        unsigned uPct = (unsigned)(  (long double)uPartsPerTenThousand / 100
+                                   * (100 - pSSM->uPercentPrepare - pSSM->uPercentDone) / 100)
+                      + pSSM->uPercentPrepare;
+        if (uPct != pSSM->uPercent)
+        {
+            AssertMsg(uPct < 100, ("uPct=%d uPartsPerTenThousand=%d uPercentPrepare=%d uPercentDone=%d\n", uPct, uPartsPerTenThousand, pSSM->uPercentPrepare, pSSM->uPercentDone));
+            pSSM->uPercent = uPct;
+            if (pSSM->pfnProgress)
+                pSSM->pfnProgress(pVM, RT_MIN(uPct, 100 - pSSM->uPercentDone), pSSM->pvUser);
+        }
+    }
+    return rc;
 }
 
@@ -2892 +2940 @@
 
 /**
- * Works the progress calculation.
+ * Works the progress calculation for non-live saves and restores.
  *
  * @param   pSSM        The SSM handle.
- * @param   cbAdvance   Number of bytes to advance
- */
-static void ssmR3Progress(PSSMHANDLE pSSM, uint64_t cbAdvance)
-{
-    /* Can't advance it beyond the estimated end of the unit. */
-    uint64_t cbLeft = pSSM->offEstUnitEnd - pSSM->offEst;
-    if (cbAdvance > cbLeft)
-        cbAdvance = cbLeft;
-    pSSM->offEst += cbAdvance;
-
-    /* uPercentPrepare% prepare, xx% exec, uPercentDone% done+crc */
-    while (   pSSM->offEst >= pSSM->offEstProgress
-           && pSSM->uPercent <= 100-pSSM->uPercentDone)
-    {
-        if (pSSM->pfnProgress)
-            pSSM->pfnProgress(pSSM->pVM, pSSM->uPercent, pSSM->pvUser);
-        pSSM->uPercent++;
-        pSSM->offEstProgress = (pSSM->uPercent - pSSM->uPercentPrepare) * pSSM->cbEstTotal
-                             / (100 - pSSM->uPercentDone - pSSM->uPercentPrepare);
+ * @param   cbAdvance   Number of bytes to advance (with in the current unit).
+ */
+static void ssmR3ProgressByByte(PSSMHANDLE pSSM, uint64_t cbAdvance)
+{
+    if (!pSSM->fLiveSave)
+    {
+        /* Can't advance it beyond the estimated end of the unit. */
+        uint64_t cbLeft = pSSM->offEstUnitEnd - pSSM->offEst;
+        if (cbAdvance > cbLeft)
+            cbAdvance = cbLeft;
+        pSSM->offEst += cbAdvance;
+
+        /* uPercentPrepare% prepare, xx% exec, uPercentDone% done+crc. This is not
+           quite right for live save, but the non-live stage there is very short. */
+        while (   pSSM->offEst >= pSSM->offEstProgress
+               && pSSM->uPercent <= 100 - pSSM->uPercentDone)
+        {
+            if (pSSM->pfnProgress)
+                pSSM->pfnProgress(pSSM->pVM, pSSM->uPercent, pSSM->pvUser);
+            pSSM->uPercent++;
+            pSSM->offEstProgress = (pSSM->uPercent - pSSM->uPercentPrepare - pSSM->uPercentLive) * pSSM->cbEstTotal
+                                 / (100 - pSSM->uPercentDone - pSSM->uPercentPrepare - pSSM->uPercentLive);
+        }
     }
 }
@@ -3151 +3203 @@
     if (RT_SUCCESS(rc))
         rc = ssmR3DataWriteRaw(pSSM, pSSM->u.Write.abDataBuffer, cb);
-    ssmR3Progress(pSSM, cb);
+    ssmR3ProgressByByte(pSSM, cb);
     return rc;
 }
@@ -3213 +3265 @@
 
                 pSSM->offUnit += cbRec;
-                ssmR3Progress(pSSM, SSM_ZIP_BLOCK_SIZE);
+                ssmR3ProgressByByte(pSSM, SSM_ZIP_BLOCK_SIZE);
 
                 /* advance */
@@ -3236 +3288 @@
 
                 /* advance */
-                ssmR3Progress(pSSM, SSM_ZIP_BLOCK_SIZE);
+                ssmR3ProgressByByte(pSSM, SSM_ZIP_BLOCK_SIZE);
                 if (cbBuf == SSM_ZIP_BLOCK_SIZE)
                     return VINF_SUCCESS;
@@ -3250 +3302 @@
                 if (RT_SUCCESS(rc))
                     rc = ssmR3DataWriteRaw(pSSM, pvBuf, cbBuf);
-                ssmR3Progress(pSSM, cbBuf);
+                ssmR3ProgressByByte(pSSM, cbBuf);
                 break;
             }
@@ -4061 +4113 @@
 
 /**
+ * Emits a SSMLiveControl unit with a new progress report.
+ *
+ * @returns VBox status code.
+ * @param   pSSM                    The saved state handle.
+ * @param   lrdPct                  The progress of the the live save.
+ * @param   uPass                   The current pass.
+ */
+static int ssmR3LiveControlEmit(PSSMHANDLE pSSM, long double lrdPct, uint32_t uPass)
+{
+    AssertMsg(lrdPct <= 100.0, ("%u\n", lrdPct * 100));
+
+    /*
+     * Make sure we're in one of the two EXEC states or we may fail.
+     */
+    SSMSTATE enmSavedState = pSSM->enmOp;
+    if (enmSavedState == SSMSTATE_LIVE_VOTE)
+        pSSM->enmOp = SSMSTATE_LIVE_EXEC;
+    else if (enmSavedState == SSMSTATE_SAVE_DONE)
+        pSSM->enmOp = SSMSTATE_SAVE_EXEC;
+
+    /*
+     * Write the unit header.
+     */
+    SSMFILEUNITHDRV2 UnitHdr;
+    memcpy(&UnitHdr.szMagic[0], SSMFILEUNITHDR_MAGIC, sizeof(UnitHdr.szMagic));
+    UnitHdr.offStream       = ssmR3StrmTell(&pSSM->Strm);
+    UnitHdr.u32CurStreamCRC = ssmR3StrmCurCRC(&pSSM->Strm);
+    UnitHdr.u32CRC          = 0;
+    UnitHdr.u32Version      = 1;
+    UnitHdr.u32Instance     = 0;
+    UnitHdr.u32Pass         = uPass;
+    UnitHdr.fFlags          = 0;
+    UnitHdr.cbName          = sizeof("SSMLiveControl");
+    memcpy(&UnitHdr.szName[0], "SSMLiveControl", UnitHdr.cbName);
+    UnitHdr.u32CRC          = RTCrc32(&UnitHdr, RT_OFFSETOF(SSMFILEUNITHDRV2, szName[UnitHdr.cbName]));
+    Log(("SSM: Unit at %#9llx: '%s', instance %u, pass %#x, version %u\n",
+         UnitHdr.offStream, UnitHdr.szName, UnitHdr.u32Instance, UnitHdr.u32Pass, UnitHdr.u32Version));
+    int rc = ssmR3StrmWrite(&pSSM->Strm, &UnitHdr, RT_OFFSETOF(SSMFILEUNITHDRV2, szName[UnitHdr.cbName]));
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Write the payload.
+         */
+        ssmR3DataWriteBegin(pSSM);
+
+        uint16_t u16PartsPerTenThousand = (uint16_t)(lrdPct * (100 - pSSM->uPercentDone));
+        AssertMsg(u16PartsPerTenThousand <= 10000, ("%u\n", u16PartsPerTenThousand));
+        ssmR3DataWrite(pSSM, &u16PartsPerTenThousand, sizeof(u16PartsPerTenThousand));
+
+        rc = ssmR3DataFlushBuffer(pSSM); /* will return SSMHANDLE::rc if it is set */
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Write the termination record and flush the compression stream.
+             */
+            SSMRECTERM TermRec;
+            TermRec.u8TypeAndFlags   = SSM_REC_FLAGS_FIXED | SSM_REC_FLAGS_IMPORTANT | SSM_REC_TYPE_TERM;
+            TermRec.cbRec            = sizeof(TermRec) - 2;
+            if (pSSM->Strm.fChecksummed)
+            {
+                TermRec.fFlags       = SSMRECTERM_FLAGS_CRC32;
+                TermRec.u32StreamCRC = RTCrc32Finish(RTCrc32Process(ssmR3StrmCurCRC(&pSSM->Strm), &TermRec, 2));
+            }
+            else
+            {
+                TermRec.fFlags       = 0;
+                TermRec.u32StreamCRC = 0;
+            }
+            TermRec.cbUnit           = pSSM->offUnit + sizeof(TermRec);
+            rc = ssmR3DataWriteRaw(pSSM, &TermRec, sizeof(TermRec));
+            if (RT_SUCCESS(rc))
+                rc = ssmR3DataWriteFinish(pSSM);
+            if (RT_SUCCESS(rc))
+            {
+                pSSM->enmOp = enmSavedState;
+                return rc;
+            }
+        }
+    }
+
+    LogRel(("SSM: Failed to write live control unit. rc=%Rrc\n", rc));
+    if (RT_SUCCESS_NP(pSSM->rc))
+        pSSM->rc = rc;
+    pSSM->enmOp = enmSavedState;
+    return rc;
+}
+
+
+/**
  * Do the pfnSaveDone run.
  *
@@ -4338 +4479 @@
 
 /**
+ * Works the progress calculation during the exec part of a live save.
+ *
+ * @param   pSSM        The SSM handle.
+ * @param   iUnit       The current unit number.
+ */
+static void ssmR3ProgressByUnit(PSSMHANDLE pSSM, uint32_t iUnit)
+{
+    if (pSSM->fLiveSave)
+    {
+        unsigned    uPctExec = iUnit * 100 / pSSM->pVM->ssm.s.cUnits;
+        unsigned    cPctExec = 100 - pSSM->uPercentDone - pSSM->uPercentPrepare - pSSM->uPercentLive;
+        long double lrdPct   = (long double)uPctExec * cPctExec / 100 + pSSM->uPercentPrepare + pSSM->uPercentLive;
+        unsigned    uPct     = (unsigned)lrdPct;
+        if (uPct != pSSM->uPercent)
+        {
+            ssmR3LiveControlEmit(pSSM, lrdPct, SSM_PASS_FINAL);
+            pSSM->uPercent =  uPct;
+            pSSM->pfnProgress(pSSM->pVM, uPct, pSSM->pvUser);
+        }
+    }
+}
+
+
+/**
  * Do the pfnSaveExec run.
  *
@@ -4350 +4515 @@
     pSSM->rc = VINF_SUCCESS;
     pSSM->enmOp = SSMSTATE_SAVE_EXEC;
-    for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
+    unsigned iUnit = 0;
+    for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext, iUnit++)
     {
         /*
@@ -4356 +4522 @@
          * make sure to keep the progress indicator up to date.
          */
+        ssmR3ProgressByUnit(pSSM, iUnit);
         pSSM->offEstUnitEnd += pUnit->cbGuess;
         if (!pUnit->u.Common.pfnSaveExec)
@@ -4361 +4528 @@
             pUnit->fCalled = true;
             if (pUnit->cbGuess)
-                ssmR3Progress(pSSM, pSSM->offEstUnitEnd - pSSM->offEst);
+                ssmR3ProgressByByte(pSSM, pSSM->offEstUnitEnd - pSSM->offEst);
             continue;
         }
@@ -4463 +4630 @@
          * Advance the progress indicator to the end of the current unit.
          */
-        ssmR3Progress(pSSM, pSSM->offEstUnitEnd - pSSM->offEst);
+        ssmR3ProgressByByte(pSSM, pSSM->offEstUnitEnd - pSSM->offEst);
     } /* for each unit */
-
+    ssmR3ProgressByUnit(pSSM, pVM->ssm.s.cUnits);
 
     /* (progress should be pending 99% now) */
-    AssertMsg(   pSSM->uPercent == (101 - pSSM->uPercentDone)
-              || pSSM->fLiveSave, ("%d\n", pSSM->uPercent));
+    AssertMsg(   pSSM->uPercent == 101 - pSSM->uPercentDone
+              || pSSM->uPercent == 100 - pSSM->uPercentDone,
+              ("%d\n", pSSM->uPercent));
     return VINF_SUCCESS;
 }
@@ -4528 +4696 @@
      */
     if (pSSM->pfnProgress)
-        pSSM->pfnProgress(pVM, pSSM->uPercentPrepare-1, pSSM->pvUser);
-    pSSM->uPercent = pSSM->uPercentPrepare;
+        pSSM->pfnProgress(pVM, pSSM->uPercentPrepare + pSSM->uPercentLive - 1, pSSM->pvUser);
+    pSSM->uPercent = pSSM->uPercentPrepare + pSSM->uPercentLive;
 
     return VINF_SUCCESS;
@@ -4687 +4855 @@
     pSSM->offEst                    = 0;
     pSSM->offEstUnitEnd             = 0;
+    pSSM->uPercentLive              = 0;
     pSSM->uPercentPrepare           = 0;
     pSSM->uPercentDone              = 0;
+    pSSM->uReportedLivePercent      = 0;
     pSSM->pszFilename               = pszFilename;
     pSSM->u.Write.offDataBuffer     = 0;
@@ -4747 +4917 @@
     if (RT_FAILURE(rc))
         return rc;
+    pSSM->uPercentLive    = 0;
     pSSM->uPercentPrepare = 20;
     pSSM->uPercentDone    = 2;
@@ -4768 +4939 @@
 
 /**
+ * Used by PGM to report the completion percentage of the live stage during the
+ * vote run.
+ *
+ * @param   pSSM                The saved state handle.
+ * @param   uPercent            The completion percentage.
+ */
+VMMR3DECL(void) SSMR3HandleReportLivePercent(PSSMHANDLE pSSM, unsigned uPercent)
+{
+    AssertMsgReturnVoid(pSSM->enmOp == SSMSTATE_LIVE_VOTE, ("%d\n", pSSM->enmOp));
+    AssertReturnVoid(uPercent <= 100);
+    if (uPercent < pSSM->uReportedLivePercent)
+        pSSM->uReportedLivePercent = uPercent;
+}
+
+
+/**
  * Calls pfnLiveVote for all units.
  *
@@ -4784 +4971 @@
     pSSM->rc = VINF_SUCCESS;
     pSSM->enmOp = SSMSTATE_LIVE_VOTE;
+
+    unsigned uPrevPrecent = pSSM->uReportedLivePercent;
+    pSSM->uReportedLivePercent = 101;
+
     for (PSSMUNIT pUnit = pVM->ssm.s.pHead; pUnit; pUnit = pUnit->pNext)
     {
@@ -4837 +5028 @@
     }
     if (rcRet == VINF_SUCCESS)
+    {
         LogRel(("SSM: Step 1 completed after pass %u.\n", uPass));
+        pSSM->uReportedLivePercent = 100;
+    }
+    else
+    {
+        /*
+         * Work the progress callback.
+         */
+        if (pSSM->uReportedLivePercent > 100)
+            pSSM->uReportedLivePercent = 0;
+        if (   pSSM->uReportedLivePercent != uPrevPrecent
+            && pSSM->pfnProgress
+            && pSSM->uPercentLive)
+        {
+            long double lrdPct = (long double)pSSM->uReportedLivePercent * pSSM->uPercentLive / 100;
+            unsigned    uPct   = (unsigned)lrdPct;
+            if (uPct != pSSM->uPercent)
+            {
+                ssmR3LiveControlEmit(pSSM, lrdPct, uPass);
+                pSSM->uPercent = uPct;
+                pSSM->pfnProgress(pVM, uPct, pSSM->pvUser);
+            }
+        }
+    }
     return rcRet;
 }
@@ -5207 +5422 @@
     if (RT_FAILURE(rc))
         return rc;
-    pSSM->uPercentPrepare        = 20; /** @todo fix these. */
+    pSSM->uPercentLive           = 93;
+    pSSM->uPercentPrepare        = 2;
     pSSM->uPercentDone           = 2;
     pSSM->fLiveSave              = true;
@@ -5302 +5518 @@
             if (pcbRead)
                 *pcbRead = cbRead;
-            ssmR3Progress(pSSM, cbRead);
+            ssmR3ProgressByByte(pSSM, cbRead);
             return VINF_SUCCESS;
         }
@@ -5415 +5631 @@
     {
         pSSM->offUnit += cbToRead;
-        ssmR3Progress(pSSM, cbToRead);
+        ssmR3ProgressByByte(pSSM, cbToRead);
         return VINF_SUCCESS;
     }
@@ -5482 +5698 @@
     {
         pSSM->offUnit += cbCompr;
-        ssmR3Progress(pSSM, cbCompr);
+        ssmR3ProgressByByte(pSSM, cbCompr);
     }
     else
@@ -6670 +6886 @@
  *          format isn't 1.1 the call will be ignored.
  */
-VMMR3_INT_DECL(int) SSMR3SetGCPtrSize(PSSMHANDLE pSSM, unsigned cbGCPtr)
+VMMR3_INT_DECL(int) SSMR3HandleSetGCPtrSize(PSSMHANDLE pSSM, unsigned cbGCPtr)
 {
     Assert(cbGCPtr == sizeof(RTGCPTR32) || cbGCPtr == sizeof(RTGCPTR64));
@@ -7398 +7614 @@
      * Initialize the handle.
      */
-    pSSM->pVM               = pVM;
-    pSSM->enmOp             = SSMSTATE_INVALID;
-    pSSM->enmAfter          = SSMAFTER_INVALID;
-    pSSM->fCancelled        = SSMHANDLE_OK;
-    pSSM->rc                = VINF_SUCCESS;
-    pSSM->cbUnitLeftV1      = 0;
-    pSSM->offUnit           = UINT64_MAX;
-    pSSM->fLiveSave         = false;
-    pSSM->pfnProgress       = NULL;
-    pSSM->pvUser            = NULL;
-    pSSM->uPercent          = 0;
-    pSSM->offEstProgress    = 0;
-    pSSM->cbEstTotal        = 0;
-    pSSM->offEst            = 0;
-    pSSM->offEstUnitEnd     = 0;
-    pSSM->uPercentPrepare   = 5;
-    pSSM->uPercentDone      = 2;
-    pSSM->pszFilename       = pszFilename;
+    pSSM->pVM                   = pVM;
+    pSSM->enmOp                 = SSMSTATE_INVALID;
+    pSSM->enmAfter              = SSMAFTER_INVALID;
+    pSSM->fCancelled            = SSMHANDLE_OK;
+    pSSM->rc                    = VINF_SUCCESS;
+    pSSM->cbUnitLeftV1          = 0;
+    pSSM->offUnit               = UINT64_MAX;
+    pSSM->fLiveSave             = false;
+    pSSM->pfnProgress           = NULL;
+    pSSM->pvUser                = NULL;
+    pSSM->uPercent              = 0;
+    pSSM->offEstProgress        = 0;
+    pSSM->cbEstTotal            = 0;
+    pSSM->offEst                = 0;
+    pSSM->offEstUnitEnd         = 0;
+    pSSM->uPercentLive          = 0;
+    pSSM->uPercentPrepare       = 5;
+    pSSM->uPercentDone          = 2;
+    pSSM->uReportedLivePercent  = 0;
+    pSSM->pszFilename           = pszFilename;
 
     pSSM->u.Read.pZipDecompV1   = NULL;
@@ -7558 +7776 @@
                     Log(("SSM: EndOfFile: offset %#9llx size %9d\n", offUnit, UnitHdr.cbUnit));
                     /* Complete the progress bar (pending 99% afterwards). */
-                    ssmR3Progress(pSSM, pSSM->cbEstTotal - pSSM->offEst);
+                    ssmR3ProgressByByte(pSSM, pSSM->cbEstTotal - pSSM->offEst);
                     break;
                 }
@@ -7652 +7870 @@
                                 Log(("SSM: Unit '%s' left %lld bytes unread!\n", pszName, -i64Diff));
                                 rc = ssmR3StrmSkipTo(&pSSM->Strm, offUnit + UnitHdr.cbUnit);
-                                ssmR3Progress(pSSM, offUnit + UnitHdr.cbUnit - pSSM->offEst);
+                                ssmR3ProgressByByte(pSSM, offUnit + UnitHdr.cbUnit - pSSM->offEst);
                             }
                             else if (i64Diff > 0)
@@ -7849 +8067 @@
              */
             Log(("SSM: Unit at %#9llx: END UNIT\n", offUnit));
-            ssmR3Progress(pSSM, pSSM->cbEstTotal - pSSM->offEst);
-
+            ssmR3ProgressByByte(pSSM, pSSM->cbEstTotal - pSSM->offEst);
             return ssmR3LoadDirectoryAndFooter(pSSM);
         }
@@ -8003 +8220 @@
         ssmR3SetCancellable(pVM, &Handle, true);
 
-        Handle.enmAfter     = enmAfter;
-        Handle.pfnProgress  = pfnProgress;
-        Handle.pvUser       = pvProgressUser;
+        Handle.enmAfter         = enmAfter;
+        Handle.pfnProgress      = pfnProgress;
+        Handle.pvUser           = pvProgressUser;
+        Handle.uPercentLive     = 0;
+        Handle.uPercentPrepare  = 2;
+        Handle.uPercentDone     = 2;
 
         if (Handle.u.Read.u16VerMajor)
@@ -8069 +8289 @@
         }
 
-        /* pending 2% */
+        /* end of prepare % */
         if (pfnProgress)
-            pfnProgress(pVM, Handle.uPercentPrepare-1, pvProgressUser);
+            pfnProgress(pVM, Handle.uPercentPrepare - 1, pvProgressUser);
         Handle.uPercent      = Handle.uPercentPrepare;
         Handle.cbEstTotal    = Handle.u.Read.cbLoadFile;
@@ -8092 +8312 @@
             AssertMsg(   Handle.fLiveSave
                       || RT_FAILURE(rc)
-                      || Handle.uPercent == (101-Handle.uPercentDone), ("%d\n", Handle.uPercent));
+                      || Handle.uPercent == 101 - Handle.uPercentDone, ("%d\n", Handle.uPercent));
         }