Changeset 36074 in vbox for trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

Timestamp:

Feb 24, 2011 3:38:25 PM (14 years ago)

Author:

vboxsync

Message:

Main: implement sharing saved state files between snapshots and machines in 'saved' state; this dramatically speeds up restoring snapshots as well as taking snapshots of 'saved' machines

File:

• trunk/src/VBox/Main/src-server/SnapshotImpl.cpp (modified) (24 diffs)

trunk/src/VBox/Main/src-server/SnapshotImpl.cpp

@@ -428 +428 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    *aOnline = !stateFilePath().isEmpty();
+    *aOnline = getStateFilePath().isNotEmpty();
     return S_OK;
 }
@@ -504 +504 @@
  *      Must be called from under the object's lock!
  */
-const Utf8Str& Snapshot::stateFilePath() const
-{
-    return m->pMachine->mSSData->mStateFilePath;
-}
-
-/**
- *  @note
- *      Must be called from under the object's write lock!
- */
-HRESULT Snapshot::deleteStateFile()
-{
-    int vrc = RTFileDelete(m->pMachine->mSSData->mStateFilePath.c_str());
-    if (RT_SUCCESS(vrc))
-        m->pMachine->mSSData->mStateFilePath.setNull();
-    return RT_SUCCESS(vrc) ? S_OK : E_FAIL;
+const Utf8Str& Snapshot::getStateFilePath() const
+{
+    return m->pMachine->mSSData->strStateFilePath;
 }
 
@@ -688 +676 @@
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    const Utf8Str &path = m->pMachine->mSSData->mStateFilePath;
+    const Utf8Str &path = m->pMachine->mSSData->strStateFilePath;
     LogFlowThisFunc(("Snap[%s].statePath={%s}\n", m->strName.c_str(), path.c_str()));
 
@@ -696 +684 @@
        )
     {
-        m->pMachine->mSSData->mStateFilePath = Utf8StrFmt("%s%s",
-                                                          strNewPath.c_str(),
-                                                          path.c_str() + strOldPath.length());
+        m->pMachine->mSSData->strStateFilePath = Utf8StrFmt("%s%s",
+                                                            strNewPath.c_str(),
+                                                            path.c_str() + strOldPath.length());
         LogFlowThisFunc(("-> updated: {%s}\n", path.c_str()));
     }
@@ -710 +698 @@
     }
 }
+
+/**
+ * Returns true if this snapshot or one of its children uses the given file,
+ * whose path must be fully qualified, as its saved state. When invoked on a
+ * machine's first snapshot, this can be used to check if a saved state file
+ * is shared with any snapshots.
+ *
+ * Caller must hold the machine lock, which protects the snapshots tree.
+ *
+ * @param strPath
+ * @param pSnapshotToIgnore If != NULL, this snapshot is ignored during the checks.
+ * @return
+ */
+bool Snapshot::sharesSavedStateFile(const Utf8Str &strPath,
+                                    Snapshot *pSnapshotToIgnore)
+{
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+    const Utf8Str &path = m->pMachine->mSSData->strStateFilePath;
+
+    if (!pSnapshotToIgnore || pSnapshotToIgnore != this)
+        if (path.isNotEmpty())
+            if (path == strPath)
+                return true;        // no need to recurse then
+
+    // but otherwise we must check children
+    for (SnapshotsList::const_iterator it = m->llChildren.begin();
+         it != m->llChildren.end();
+         ++it)
+    {
+        Snapshot *pChild = *it;
+        if (!pSnapshotToIgnore || pSnapshotToIgnore != pChild)
+            if (pChild->sharesSavedStateFile(strPath, pSnapshotToIgnore))
+                return true;
+    }
+
+    return false;
+}
+
 
 /**
@@ -757 +783 @@
         return S_OK;
 
-    /* stateFile (optional) */
-    if (!stateFilePath().isEmpty())
-        m->pMachine->copyPathRelativeToMachine(stateFilePath(), data.strStateFile);
+    // state file (only if this snapshot is online)
+    if (getStateFilePath().isNotEmpty())
+        m->pMachine->copyPathRelativeToMachine(getStateFilePath(), data.strStateFile);
     else
         data.strStateFile.setNull();
@@ -870 +896 @@
         return rc;
 
-    // now report the saved state file
-    if (!m->pMachine->mSSData->mStateFilePath.isEmpty())
-        llFilenames.push_back(m->pMachine->mSSData->mStateFilePath);
+    // report the saved state file if it's not on the list yet
+    if (!m->pMachine->mSSData->strStateFilePath.isEmpty())
+    {
+        bool fFound = false;
+        for (std::list<Utf8Str>::const_iterator it = llFilenames.begin();
+             it != llFilenames.end();
+             ++it)
+        {
+            const Utf8Str &str = *it;
+            if (str == m->pMachine->mSSData->strStateFilePath)
+            {
+                fFound = true;
+                break;
+            }
+        }
+        if (!fFound)
+            llFilenames.push_back(m->pMachine->mSSData->strStateFilePath);
+    }
 
     this->beginSnapshotDelete();
@@ -952 +993 @@
     /* SSData is always unique for SnapshotMachine */
     mSSData.allocate();
-    mSSData->mStateFilePath = aStateFilePath;
+    mSSData->strStateFilePath = aStateFilePath;
 
     HRESULT rc = S_OK;
@@ -1090 +1131 @@
     /* SSData is always unique for SnapshotMachine */
     mSSData.allocate();
-    mSSData->mStateFilePath = aStateFilePath;
+    mSSData->strStateFilePath = aStateFilePath;
 
     /* create all other child objects that will be immutable private copies */
@@ -1262 +1303 @@
     RestoreSnapshotTask(SessionMachine *m,
                         Progress *p,
-                        Snapshot *s,
-                        ULONG ulStateFileSizeMB)
-        : SnapshotTask(m, p, s),
-          m_ulStateFileSizeMB(ulStateFileSizeMB)
+                        Snapshot *s)
+        : SnapshotTask(m, p, s)
     {}
 
@@ -1272 +1311 @@
         pMachine->restoreSnapshotHandler(*this);
     }
-
-    ULONG       m_ulStateFileSizeMB;
 };
 
@@ -1399 +1436 @@
     Utf8Str strStateFilePath;
     /* stateFilePath is null when the machine is not online nor saved */
-    if (    fTakingSnapshotOnline
-         || mData->mMachineState == MachineState_Saved)
-    {
-        Utf8Str strFullSnapshotFolder;
-        calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
-        strStateFilePath = Utf8StrFmt("%s%c{%RTuuid}.sav",
-                                      strFullSnapshotFolder.c_str(),
-                                      RTPATH_DELIMITER,
-                                      snapshotId.raw());
-        /* ensure the directory for the saved state file exists */
+    if (fTakingSnapshotOnline)
+        // creating a new online snapshot: then we need a fresh saved state file
+        composeSavedStateFilename(strStateFilePath);
+    else if (mData->mMachineState == MachineState_Saved)
+        // taking an online snapshot from machine in "saved" state: then use existing state file
+        strStateFilePath = mSSData->strStateFilePath;
+
+    if (strStateFilePath.isNotEmpty())
+    {
+        // ensure the directory for the saved state file exists
         HRESULT rc = VirtualBox::ensureFilePathExists(strStateFilePath);
         if (FAILED(rc)) return rc;
@@ -1464 +1501 @@
             throw rc;
 
-        if (mConsoleTaskData.mLastState == MachineState_Saved)
-        {
-            Utf8Str stateFrom = mSSData->mStateFilePath;
-            Utf8Str stateTo = mConsoleTaskData.mSnapshot->stateFilePath();
-
-            LogFlowThisFunc(("Copying the execution state from '%s' to '%s'...\n",
-                             stateFrom.c_str(), stateTo.c_str()));
-
-            aConsoleProgress->SetNextOperation(Bstr(tr("Copying the execution state")).raw(),
-                                               1);        // weight
-
-            /* Leave the lock before a lengthy operation (machine is protected
-             * by "Saving" machine state now) */
-            alock.release();
-
-            /* copy the state file */
-            int vrc = RTFileCopyEx(stateFrom.c_str(),
-                                   stateTo.c_str(),
-                                   0,
-                                   progressCallback,
-                                   aConsoleProgress);
-            alock.acquire();
-
-            if (RT_FAILURE(vrc))
-                /** @todo r=bird: Delete stateTo when appropriate. */
-                throw setError(E_FAIL,
-                               tr("Could not copy the state file '%s' to '%s' (%Rrc)"),
-                               stateFrom.c_str(),
-                               stateTo.c_str(),
-                               vrc);
-        }
-
         // if we got this far without an error, then save the media registries
         // that got modified for the diff images
@@ -1596 +1601 @@
 
         rc = saveSettings(NULL, flSaveSettings);
-                // no need to change for whether VirtualBox.xml needs saving since
-                // we'll save the global settings below anyway
     }
 
@@ -1618 +1621 @@
         mData->mCurrentSnapshot = pOldCurrentSnap;      // might have been changed above
 
-        /* delete the saved state file (it might have been already created) */
-        if (mConsoleTaskData.mSnapshot->stateFilePath().length())
-            RTFileDelete(mConsoleTaskData.mSnapshot->stateFilePath().c_str());
+        // delete the saved state file (it might have been already created)
+        if (fOnline)
+            // no need to test for whether the saved state file is shared: an online
+            // snapshot means that a new saved state file was created, which we must
+            // clean up now
+            RTFileDelete(mConsoleTaskData.mSnapshot->getStateFilePath().c_str());
 
         mConsoleTaskData.mSnapshot->uninit();
@@ -1628 +1634 @@
     mConsoleTaskData.mLastState = MachineState_Null;
     mConsoleTaskData.mSnapshot.setNull();
-
-    // save VirtualBox.xml (media registry most probably changed with diff image);
-    // for that we should hold only the VirtualBox lock
-    machineLock.release();
-    AutoWriteLock vboxLock(mParent COMMA_LOCKVAL_SRC_POS);
-    mParent->saveSettings();
 
     return rc;
@@ -1708 +1708 @@
     }
 
-    ULONG ulStateFileSizeMB = 0;
-    if (pSnapshot->stateFilePath().length())
-    {
-        ++ulOpCount;      // one for the saved state
-
-        uint64_t ullSize;
-        int irc = RTFileQuerySize(pSnapshot->stateFilePath().c_str(), &ullSize);
-        if (!RT_SUCCESS(irc))
-            // if we can't access the file here, then we'll be doomed later also, so fail right away
-            setError(E_FAIL, tr("Cannot access state file '%s', runtime error, %Rra"), pSnapshot->stateFilePath().c_str(), irc);
-        if (ullSize == 0) // avoid division by zero
-            ullSize = _1M;
-
-        ulStateFileSizeMB = (ULONG)(ullSize / _1M);
-        LogFlowThisFunc(("op %d: saved state file '%s' has %RI64 bytes (%d MB)\n",
-                         ulOpCount, pSnapshot->stateFilePath().c_str(), ullSize, ulStateFileSizeMB));
-
-        ulTotalWeight += ulStateFileSizeMB;
-    }
-
     ComObjPtr<Progress> pProgress;
     pProgress.createObject();
@@ -1742 +1722 @@
     RestoreSnapshotTask *task = new RestoreSnapshotTask(this,
                                                         pProgress,
-                                                        pSnapshot,
-                                                        ulStateFileSizeMB);
+                                                        pSnapshot);
     int vrc = RTThreadCreate(NULL,
                              taskHandler,
@@ -1822 +1801 @@
         if (aTask.machineStateBackup == MachineState_Saved)
         {
-            Assert(!mSSData->mStateFilePath.isEmpty());
-            RTFileDelete(mSSData->mStateFilePath.c_str());
-            mSSData->mStateFilePath.setNull();
+            Assert(!mSSData->strStateFilePath.isEmpty());
+
+            // release the saved state file AFTER unsetting the member variable
+            // so that releaseSavedStateFile() won't think it's still in use
+            Utf8Str strStateFile(mSSData->strStateFilePath);
+            mSSData->strStateFilePath.setNull();
+            releaseSavedStateFile(strStateFile, NULL /* pSnapshotToIgnore */ );
+
             aTask.modifyBackedUpState(MachineState_PoweredOff);
+
             rc = saveStateSettings(SaveSTS_StateFilePath);
             if (FAILED(rc))
@@ -1872 +1857 @@
 
             /* should not have a saved state file associated at this point */
-            Assert(mSSData->mStateFilePath.isEmpty());
-
-            if (!aTask.pSnapshot->stateFilePath().isEmpty())
-            {
-                Utf8Str snapStateFilePath = aTask.pSnapshot->stateFilePath();
-
-                Utf8Str strFullSnapshotFolder;
-                calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
-                Utf8Str stateFilePath = Utf8StrFmt("%s%c{%RTuuid}.sav",
-                                                   strFullSnapshotFolder.c_str(),
-                                                   RTPATH_DELIMITER,
-                                                   mData->mUuid.raw());
-
-                LogFlowThisFunc(("Copying saved state file from '%s' to '%s'...\n",
-                                  snapStateFilePath.c_str(), stateFilePath.c_str()));
-
-                aTask.pProgress->SetNextOperation(Bstr(tr("Restoring the execution state")).raw(),
-                                                  aTask.m_ulStateFileSizeMB);        // weight
-
-                /* leave the lock before the potentially lengthy operation */
-                snapshotLock.release();
-                alock.leave();
-
-                /* copy the state file */
-                RTFileDelete(stateFilePath.c_str());
-                int vrc = RTFileCopyEx(snapStateFilePath.c_str(),
-                                       stateFilePath.c_str(),
-                                       0,
-                                       progressCallback,
-                                       static_cast<IProgress*>(aTask.pProgress));
-
-                alock.enter();
-                snapshotLock.acquire();
-
-                if (RT_SUCCESS(vrc))
-                    mSSData->mStateFilePath = stateFilePath;
-                else
-                    throw setError(E_FAIL,
-                                   tr("Could not copy the state file '%s' to '%s' (%Rrc)"),
-                                   snapStateFilePath.c_str(),
-                                   stateFilePath.c_str(),
-                                   vrc);
-            }
+            Assert(mSSData->strStateFilePath.isEmpty());
+
+            const Utf8Str &strSnapshotStateFile = aTask.pSnapshot->getStateFilePath();
+
+            if (strSnapshotStateFile.isNotEmpty())
+                // online snapshot: then share the state file
+                mSSData->strStateFilePath = strSnapshotStateFile;
 
             LogFlowThisFunc(("Setting new current snapshot {%RTuuid}\n", aTask.pSnapshot->getId().raw()));
@@ -1950 +1899 @@
         /* we have already deleted the current state, so set the execution
          * state accordingly no matter of the delete snapshot result */
-        if (!mSSData->mStateFilePath.isEmpty())
+        if (mSSData->strStateFilePath.isNotEmpty())
             setMachineState(MachineState_Saved);
         else
@@ -2144 +2093 @@
     ULONG ulTotalWeight = 1;        // one for preparations
 
-    if (pSnapshot->stateFilePath().length())
+    if (pSnapshot->getStateFilePath().length())
     {
         ++ulOpCount;
@@ -2529 +2478 @@
             AutoWriteLock machineLock(this COMMA_LOCKVAL_SRC_POS);
 
-            Utf8Str stateFilePath = aTask.pSnapshot->stateFilePath();
+            Utf8Str stateFilePath = aTask.pSnapshot->getStateFilePath();
             if (!stateFilePath.isEmpty())
             {
@@ -2535 +2484 @@
                                                   1);        // weight
 
-                aTask.pSnapshot->deleteStateFile();
-                // machine needs saving now
+                releaseSavedStateFile(stateFilePath, aTask.pSnapshot /* pSnapshotToIgnore */);
+
+                // machine will need saving now
                 mParent->addGuidToListUniquely(llRegistriesThatNeedSaving, getId());
             }