Changeset 81425 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Oct 21, 2019 6:19:39 PM (5 years ago)

Author:

vboxsync

Message:

Main/Machine+BIOSSettings+Console: Full implementation of NVRAM handling (part of VM delete, rename, clone and move code in combination with taking, deleting and restoring snapshots). Corresponding console update (ripping out old, never really used NVRAM handling).

Location:

trunk/src/VBox/Main/src-server

Files:

• BIOSSettingsImpl.cpp (modified) (5 diffs)
• MachineImpl.cpp (modified) (13 diffs)
• MachineImplCloneVM.cpp (modified) (13 diffs)
• MachineImplMoveVM.cpp (modified) (13 diffs)
• SnapshotImpl.cpp (modified) (11 diffs)

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

@@ -153 +153 @@
     m->bd.attachCopy(that->m->bd);
 
+    // Intentionally "forget" the NVRAM file since it must be unique and set
+    // to the correct value before the copy of the settings makes sense.
+    m->bd->strNVRAMPath.setNull();
+
     autoInitSpan.setSucceeded();
 
@@ -373 +377 @@
 
     m->bd.backup();
-
     m->bd->fIOAPICEnabled = RT_BOOL(aIOAPICEnabled);
+
     alock.release();
     AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
@@ -401 +405 @@
 
     m->bd.backup();
-
     m->bd->apicMode = aAPICMode;
+
     alock.release();
     AutoWriteLock mlock(m->pMachine COMMA_LOCKVAL_SRC_POS);  // mParent is const, needs no locking
@@ -591 +595 @@
     /* this will back up current data */
     m->bd.assignCopy(aThat->m->bd);
+
+    // Intentionally "forget" the NVRAM file since it must be unique and set
+    // to the correct value before the copy of the settings makes sense.
+    m->bd->strNVRAMPath.setNull();
+
 }
 
@@ -608 +617 @@
 }
 
+Utf8Str BIOSSettings::i_getNonVolatileStorageFile()
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.rc(), Utf8Str::Empty);
+
+    Utf8Str strTmp;
+    BIOSSettings::getNonVolatileStorageFile(strTmp);
+    return strTmp;
+}
+
 void BIOSSettings::i_updateNonVolatileStorageFile(const Utf8Str &aNonVolatileStorageFile)
 {

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

@@ -5025 +5025 @@
     if (!mData->mAccessible)
     {
-        // inaccessible maschines can only be unregistered; uninitialize ourselves
+        // inaccessible machines can only be unregistered; uninitialize ourselves
         // here because currently there may be no unregistered that are inaccessible
         // (this state combination is not supported). Note releasing the caller and
@@ -5041 +5041 @@
 
     HRESULT rc = S_OK;
-
-    /// @todo r=klaus this is stupid... why is the saved state always deleted?
-    // discard saved state
-    if (mData->mMachineState == MachineState_Saved)
-    {
-        // add the saved state file to the list of files the caller should delete
-        Assert(!mSSData->strStateFilePath.isEmpty());
+    mData->llFilesToDelete.clear();
+
+    if (!mSSData->strStateFilePath.isEmpty())
         mData->llFilesToDelete.push_back(mSSData->strStateFilePath);
 
-        mSSData->strStateFilePath.setNull();
-
-        // unconditionally set the machine state to powered off, we now
-        // know no session has locked the machine
-        mData->mMachineState = MachineState_PoweredOff;
-    }
-
-    size_t cSnapshots = 0;
-    if (mData->mFirstSnapshot)
-        cSnapshots = mData->mFirstSnapshot->i_getAllChildrenCount() + 1;
-    if (cSnapshots && aCleanupMode == CleanupMode_UnregisterOnly)
-        // fail now before we start detaching media
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Cannot unregister the machine '%s' because it has %d snapshots"),
-                           mUserData->s.strName.c_str(), cSnapshots);
+    Utf8Str strNVRAMFile = mBIOSSettings->i_getNonVolatileStorageFile();
+    if (!strNVRAMFile.isEmpty() && RTFileExists(strNVRAMFile.c_str()))
+        mData->llFilesToDelete.push_back(strNVRAMFile);
 
     // This list collects the medium objects from all medium attachments
@@ -5082 +5066 @@
     {
         // we have media attachments: detach them all and add the Medium objects to our list
-        if (aCleanupMode != CleanupMode_UnregisterOnly)
-            i_detachAllMedia(alock, NULL /* pSnapshot */, aCleanupMode, llMedia);
-        else
-            return setError(VBOX_E_INVALID_OBJECT_STATE,
-                            tr("Cannot unregister the machine '%s' because it has %d media attachments"),
-                            mUserData->s.strName.c_str(), mMediumAttachments->size());
-    }
-
-    if (cSnapshots)
+        i_detachAllMedia(alock, NULL /* pSnapshot */, aCleanupMode, llMedia);
+    }
+
+    if (mData->mFirstSnapshot)
     {
         // add the media from the medium attachments of the snapshots to llMedia
@@ -5101 +5080 @@
         mData->mMachineState = MachineState_DeletingSnapshot;
 
-        // make a copy of the first snapshot so the refcount does not drop to 0
-        // in beginDeletingSnapshot, which sets pFirstSnapshot to 0 (that hangs
-        // because of the AutoCaller voodoo)
+        // make a copy of the first snapshot reference so the refcount does not
+        // drop to 0 in beginDeletingSnapshot, which sets pFirstSnapshot to 0
+        // (would hang due to the AutoCaller voodoo)
         ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
 
@@ -5125 +5104 @@
     // machine lock no longer needed
     alock.release();
+
+    /* Make sure that the settings of the current VM are not saved, because
+     * they are rather crippled at this point to meet the cleanup expectations
+     * and there's no point destroying the VM config on disk just because. */
+    mParent->i_unmarkRegistryModified(id);
 
     // return media to caller
@@ -5365 +5349 @@
 
     // collect files to delete
-    StringsList llFilesToDelete(mData->llFilesToDelete);    // saved states pushed here by Unregister()
+    StringsList llFilesToDelete(mData->llFilesToDelete);    // saved states and NVRAM files pushed here by Unregister()
+    // machine config file
     if (mData->pMachineConfigFile->fileExists())
         llFilesToDelete.push_back(mData->m_strConfigFileFull);
+    // backup of machine config file
+    Utf8Str strTmp(mData->m_strConfigFileFull);
+    strTmp.append("-prev");
+    if (RTFileExists(strTmp.c_str()))
+        llFilesToDelete.push_back(strTmp);
 
     RTCList<ComPtr<IMedium> > llMediums;
@@ -7362 +7352 @@
 /**
  * Returns the default NVRAM filename based on the location of the VM config.
- * This intentionally works differently than the saved state file naming since
- * it is part of the current state. Taking a snapshot will use a similar naming
- * as for saved state, because these are actually read-only, retaining a
- * a specific state just like saved state. Note that this is a relative path.
+ * Note that this is a relative path.
  */
-
 Utf8Str Machine::i_getDefaultNVRAMFilename()
 {
@@ -7375 +7361 @@
     AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    if (mHWData->mFirmwareType == FirmwareType_BIOS)
+    if (   mHWData->mFirmwareType == FirmwareType_BIOS
+        || i_isSnapshotMachine())
         return Utf8Str::Empty;
 
@@ -7386 +7373 @@
 }
 
+/**
+ * Returns the NVRAM filename for a new snapshot. This intentionally works
+ * similarly to the saved state file naming. Note that this is usually
+ * a relative path, unless the snapshot folder is absolute.
+ */
+Utf8Str Machine::i_getSnapshotNVRAMFilename()
+{
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.rc(), Utf8Str::Empty);
+
+    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    if (mHWData->mFirmwareType == FirmwareType_BIOS)
+        return Utf8Str::Empty;
+
+    RTTIMESPEC ts;
+    RTTimeNow(&ts);
+    RTTIME time;
+    RTTimeExplode(&time, &ts);
+
+    Utf8Str strNVRAMFilePath = mUserData->s.strSnapshotFolder;
+    strNVRAMFilePath += RTPATH_DELIMITER;
+    strNVRAMFilePath += Utf8StrFmt("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.nvram",
+                                   time.i32Year, time.u8Month, time.u8MonthDay,
+                                   time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
+
+    return strNVRAMFilePath;
+}
 
 /**
@@ -9727 +9742 @@
         Utf8Str configFile, newConfigFile;
         Utf8Str configFilePrev, newConfigFilePrev;
+        Utf8Str NVRAMFile, newNVRAMFile;
         Utf8Str configDir, newConfigDir;
 
@@ -9836 +9852 @@
                     newConfigFilePrev += "-prev";
                     RTFileRename(configFilePrev.c_str(), newConfigFilePrev.c_str(), 0);
+                    NVRAMFile = mBIOSSettings->i_getNonVolatileStorageFile();
+                    if (NVRAMFile.isNotEmpty())
+                    {
+                        // in the NVRAM file path, replace the old directory with the new directory
+                        if (RTPathStartsWith(NVRAMFile.c_str(), configDir.c_str()))
+                        {
+                            Utf8Str strNVRAMFile = NVRAMFile.c_str() + configDir.length();
+                            NVRAMFile = newConfigDir + strNVRAMFile;
+                        }
+                        newNVRAMFile = newConfigFile;
+                        newNVRAMFile.stripSuffix();
+                        newNVRAMFile += ".nvram";
+                        RTFileRename(NVRAMFile.c_str(), newNVRAMFile.c_str(), 0);
+                    }
                 }
             }
@@ -9861 +9891 @@
                 mSSData->strStateFilePath = newConfigDir + strStateFileName;
             }
-
-            // and do the same thing for the saved state file paths of all the online snapshots
+            if (newNVRAMFile.isNotEmpty())
+                mBIOSSettings->i_updateNonVolatileStorageFile(newNVRAMFile);
+
+            // and do the same thing for the saved state file paths of all the online snapshots and NVRAM files of all snapshots
             if (mData->mFirstSnapshot)
+            {
                 mData->mFirstSnapshot->i_updateSavedStatePaths(configDir.c_str(),
                                                                newConfigDir.c_str());
+                mData->mFirstSnapshot->i_updateNVRAMPaths(configDir.c_str(),
+                                                          newConfigDir.c_str());
+            }
         }
         while (0);
@@ -9876 +9912 @@
                 RTFileRename(newConfigFilePrev.c_str(), configFilePrev.c_str(), 0);
                 RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
+                if (NVRAMFile.isNotEmpty() && newNVRAMFile.isNotEmpty())
+                    RTFileRename(newNVRAMFile.c_str(), NVRAMFile.c_str(), 0);
             }
             if (dirRenamed)

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

@@ -56 +56 @@
 {
     Guid                    snapshotUuid;
-    Utf8Str                 strSaveStateFile;
+    Utf8Str                 strFile;
     ULONG                   uWeight;
-} SAVESTATETASK;
+} FILECOPYTASK;
 
 // The private class
@@ -107 +107 @@
     inline void updateProgressStats(MEDIUMTASKCHAIN &mtc, bool fAttachLinked, ULONG &uCount, ULONG &uTotalWeight) const;
     inline HRESULT addSaveState(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight);
+    inline HRESULT addNVRAM(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight);
     inline HRESULT queryBaseName(const ComPtr<IMedium> &pMedium, Utf8Str &strBaseName) const;
     HRESULT queryMediasForMachineState(const RTCList<ComObjPtr<Machine> > &machineList,
@@ -121 +122 @@
     void updateStorageLists(settings::StorageControllersList &sc, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
     void updateSnapshotStorageLists(settings::SnapshotsList &sl, const Bstr &bstrOldId, const Bstr &bstrNewId) const;
-    void updateStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const;
+    void updateSaveStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const;
+    void updateNVRAMFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const;
     HRESULT createDifferencingMedium(const ComObjPtr<Machine> &pMachine, const ComObjPtr<Medium> &pParent,
                                      const Utf8Str &strSnapshotFolder, RTCList<ComObjPtr<Medium> > &newMedia,
                                      ComObjPtr<Medium> *ppDiff) const;
-    static DECLCALLBACK(int) copyStateFileProgress(unsigned uPercentage, void *pvUser);
+    static DECLCALLBACK(int) copyFileProgress(unsigned uPercentage, void *pvUser);
     static void updateSnapshotHardwareUUIDs(settings::SnapshotsList &snapshot_list, const Guid &id);
 
@@ -141 +143 @@
     RTCList<CloneOptions_T>     options;
     RTCList<MEDIUMTASKCHAIN>    llMedias;
-    RTCList<SAVESTATETASK>      llSaveStateFiles; /* Snapshot UUID -> File path */
+    RTCList<FILECOPYTASK>       llSaveStateFiles; /* Snapshot UUID -> File path */
+    RTCList<FILECOPYTASK>       llNVRAMFiles; /* Snapshot UUID -> File path */
 };
 
@@ -211 +214 @@
     if (!bstrSrcSaveStatePath.isEmpty())
     {
-        SAVESTATETASK sst;
+        FILECOPYTASK fct;
         if (fAttachCurrent)
         {
             /* Make this saved state part of "current state" of the target
              * machine, whether it is part of a snapshot or not. */
-            sst.snapshotUuid.clear();
+            fct.snapshotUuid.clear();
         }
         else
-            sst.snapshotUuid = machine->i_getSnapshotId();
-        sst.strSaveStateFile = bstrSrcSaveStatePath;
+            fct.snapshotUuid = machine->i_getSnapshotId();
+        fct.strFile = bstrSrcSaveStatePath;
         uint64_t cbSize;
-        int vrc = RTFileQuerySizeByPath(sst.strSaveStateFile.c_str(), &cbSize);
+        int vrc = RTFileQuerySizeByPath(fct.strFile.c_str(), &cbSize);
         if (RT_FAILURE(vrc))
             return p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, p->tr("Could not query file size of '%s' (%Rrc)"),
-                                   sst.strSaveStateFile.c_str(), vrc);
-        /*  same rule as above: count both the data which needs to
+                                   fct.strFile.c_str(), vrc);
+        /* same rule as above: count both the data which needs to
          * be read and written */
-        sst.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
-        llSaveStateFiles.append(sst);
+        fct.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
+        llSaveStateFiles.append(fct);
         ++uCount;
-        uTotalWeight += sst.uWeight;
+        uTotalWeight += fct.uWeight;
+    }
+    return S_OK;
+}
+
+HRESULT MachineCloneVMPrivate::addNVRAM(const ComObjPtr<Machine> &machine, bool fAttachCurrent, ULONG &uCount, ULONG &uTotalWeight)
+{
+    Bstr bstrSrcNVRAMPath;
+    ComPtr<IBIOSSettings> pBIOSSettings;
+    HRESULT rc = machine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
+    if (FAILED(rc)) return rc;
+    rc = pBIOSSettings->COMGETTER(NonVolatileStorageFile)(bstrSrcNVRAMPath.asOutParam());
+    if (FAILED(rc)) return rc;
+    if (!bstrSrcNVRAMPath.isEmpty())
+    {
+        FILECOPYTASK fct;
+        if (fAttachCurrent)
+        {
+            /* Make this saved state part of "current state" of the target
+             * machine, whether it is part of a snapshot or not. */
+            fct.snapshotUuid.clear();
+        }
+        else
+            fct.snapshotUuid = machine->i_getSnapshotId();
+        fct.strFile = bstrSrcNVRAMPath;
+        if (!RTFileExists(fct.strFile.c_str()))
+            return S_OK;
+        uint64_t cbSize;
+        int vrc = RTFileQuerySizeByPath(fct.strFile.c_str(), &cbSize);
+        if (RT_FAILURE(vrc))
+            return p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc, p->tr("Could not query file size of '%s' (%Rrc)"),
+                                   fct.strFile.c_str(), vrc);
+        /* same rule as above: count both the data which needs to
+         * be read and written */
+        fct.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
+        llNVRAMFiles.append(fct);
+        ++uCount;
+        uTotalWeight += fct.uWeight;
     }
     return S_OK;
@@ -322 +362 @@
             llMedias.append(mtc);
         }
-        /* Add the save state files of this machine if there is one. */
+        /* Add the save state file of this machine if there is one. */
         rc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
+        if (FAILED(rc)) return rc;
+        /* Add the NVRAM file of this machine if there is one. */
+        rc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
         if (FAILED(rc)) return rc;
     }
@@ -428 +471 @@
             llMedias.append(mtc);
         }
-        /* Add the save state files of this machine if there is one. */
+        /* Add the save state file of this machine if there is one. */
         rc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
         if (FAILED(rc)) return rc;
+        /* Add the NVRAM file of this machine if there is one. */
+        rc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
+        if (FAILED(rc)) return rc;
         /* If this is the newly created current state, make sure that the
-         * saved state is also attached to it. */
+         * saved state and NVRAM is also attached to it. */
         if (fCreateDiffs)
         {
             rc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
+            if (FAILED(rc)) return rc;
+            rc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
             if (FAILED(rc)) return rc;
         }
@@ -576 +624 @@
             llMedias.append(mtc);
         }
-        /* Add the save state files of this machine if there is one. */
+        /* Add the save state file of this machine if there is one. */
         rc = addSaveState(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
+        if (FAILED(rc)) return rc;
+        /* Add the NVRAM file of this machine if there is one. */
+        rc = addNVRAM(machine, false /*fAttachCurrent*/, uCount, uTotalWeight);
         if (FAILED(rc)) return rc;
         /* If this is the newly created current state, make sure that the
@@ -584 +635 @@
         {
             rc = addSaveState(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
+            if (FAILED(rc)) return rc;
+            rc = addNVRAM(machine, true /*fAttachCurrent*/, uCount, uTotalWeight);
             if (FAILED(rc)) return rc;
         }
@@ -682 +735 @@
 }
 
-void MachineCloneVMPrivate::updateStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const
+void MachineCloneVMPrivate::updateSaveStateFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const
 {
     settings::SnapshotsList::iterator it;
@@ -690 +743 @@
             it->strStateFile = strFile;
         else if (!it->llChildSnapshots.empty())
-            updateStateFile(it->llChildSnapshots, id, strFile);
+            updateSaveStateFile(it->llChildSnapshots, id, strFile);
+    }
+}
+
+void MachineCloneVMPrivate::updateNVRAMFile(settings::SnapshotsList &snl, const Guid &id, const Utf8Str &strFile) const
+{
+    settings::SnapshotsList::iterator it;
+    for (it = snl.begin(); it != snl.end(); ++it)
+    {
+        if (it->uuid == id)
+            it->hardware.biosSettings.strNVRAMPath = strFile;
+        else if (!it->llChildSnapshots.empty())
+            updateNVRAMFile(it->llChildSnapshots, id, strFile);
     }
 }
@@ -753 +818 @@
 
 /* static */
-DECLCALLBACK(int) MachineCloneVMPrivate::copyStateFileProgress(unsigned uPercentage, void *pvUser)
+DECLCALLBACK(int) MachineCloneVMPrivate::copyFileProgress(unsigned uPercentage, void *pvUser)
 {
     ComObjPtr<Progress> pProgress = *static_cast< ComObjPtr<Progress>* >(pvUser);
@@ -1429 +1494 @@
         for (size_t i = 0; i < d->llSaveStateFiles.size(); ++i)
         {
-            SAVESTATETASK sst = d->llSaveStateFiles.at(i);
+            FILECOPYTASK fct = d->llSaveStateFiles.at(i);
             const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
-                                                        RTPathFilename(sst.strSaveStateFile.c_str()));
+                                                        RTPathFilename(fct.strFile.c_str()));
 
             /* Move to next sub-operation. */
             rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Copy save state file '%s' ..."),
-                                                        RTPathFilename(sst.strSaveStateFile.c_str())).raw(), sst.uWeight);
+                                                        RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
             if (FAILED(rc)) throw rc;
             /* Copy the file only if it was not copied already. */
             if (!newFiles.contains(strTrgSaveState.c_str()))
             {
-                int vrc = RTFileCopyEx(sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), 0,
-                                       MachineCloneVMPrivate::copyStateFileProgress, &d->pProgress);
+                int vrc = RTFileCopyEx(fct.strFile.c_str(), strTrgSaveState.c_str(), 0,
+                                       MachineCloneVMPrivate::copyFileProgress, &d->pProgress);
                 if (RT_FAILURE(vrc))
                     throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
                                           p->tr("Could not copy state file '%s' to '%s' (%Rrc)"),
-                                          sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), vrc);
+                                          fct.strFile.c_str(), strTrgSaveState.c_str(), vrc);
                 newFiles.append(strTrgSaveState);
             }
             /* Update the path in the configuration either for the current
              * machine state or the snapshots. */
-            if (!sst.snapshotUuid.isValid() || sst.snapshotUuid.isZero())
+            if (!fct.snapshotUuid.isValid() || fct.snapshotUuid.isZero())
                 trgMCF.strStateFile = strTrgSaveState;
             else
-                d->updateStateFile(trgMCF.llFirstSnapshot, sst.snapshotUuid, strTrgSaveState);
+                d->updateSaveStateFile(trgMCF.llFirstSnapshot, fct.snapshotUuid, strTrgSaveState);
+        }
+
+        /* Clone all NVRAM files. */
+        for (size_t i = 0; i < d->llNVRAMFiles.size(); ++i)
+        {
+            FILECOPYTASK fct = d->llNVRAMFiles.at(i);
+            Utf8Str strTrgNVRAM;
+            if (!fct.snapshotUuid.isValid() || fct.snapshotUuid.isZero())
+                strTrgNVRAM = Utf8StrFmt("%s%c%s.nvram", strTrgMachineFolder.c_str(), RTPATH_DELIMITER,
+                                         trgMCF.machineUserData.strName.c_str());
+            else
+                strTrgNVRAM = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
+                                         RTPathFilename(fct.strFile.c_str()));
+
+            /* Move to next sub-operation. */
+            rc = d->pProgress->SetNextOperation(BstrFmt(p->tr("Copy NVRAM file '%s' ..."),
+                                                        RTPathFilename(fct.strFile.c_str())).raw(), fct.uWeight);
+            if (FAILED(rc)) throw rc;
+            /* Copy the file only if it was not copied already. */
+            if (!newFiles.contains(strTrgNVRAM.c_str()))
+            {
+                rc = p->i_getVirtualBox()->i_ensureFilePathExists(strTrgNVRAM.c_str(), true);
+                if (FAILED(rc)) throw rc;
+                int vrc = RTFileCopyEx(fct.strFile.c_str(), strTrgNVRAM.c_str(), 0,
+                                       MachineCloneVMPrivate::copyFileProgress, &d->pProgress);
+                if (RT_FAILURE(vrc))
+                    throw p->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                          p->tr("Could not copy NVRAM file '%s' to '%s' (%Rrc)"),
+                                          fct.strFile.c_str(), strTrgNVRAM.c_str(), vrc);
+                newFiles.append(strTrgNVRAM);
+            }
+            /* Update the path in the configuration either for the current
+             * machine state or the snapshots. */
+            if (!fct.snapshotUuid.isValid() || fct.snapshotUuid.isZero())
+                trgMCF.hardwareMachine.biosSettings.strNVRAMPath = strTrgNVRAM;
+            else
+                d->updateNVRAMFile(trgMCF.llFirstSnapshot, fct.snapshotUuid, strTrgNVRAM);
         }
 

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

@@ -315 +315 @@
     ULONG uTotalWeight = 1;
 
-    /* The lists m_llMedias and m_llSaveStateFiles are filled in the queryMediasForAllStates() */
+    /* The lists m_llMedias, m_llSaveStateFiles and m_llNVRAMFiles are filled in the queryMediasForAllStates() */
     hrc = queryMediasForAllStates();
     if (FAILED(hrc))
@@ -371 +371 @@
         {
             uint64_t cbFile = 0;
-            SAVESTATETASKMOVE &sst = m_llSaveStateFiles.at(i);
-
-            Utf8Str name = sst.strSaveStateFile;
+            SNAPFILETASKMOVE &sft = m_llSaveStateFiles.at(i);
+
+            Utf8Str name = sft.strFile;
             /* if a state file is located in the actual VM folder it will be added to the actual list */
             if (RTPathStartsWith(name.c_str(), strSettingsFilePath.c_str()))
@@ -380 +380 @@
                 if (RT_SUCCESS(vrc))
                 {
-                    std::pair<std::map<Utf8Str, SAVESTATETASKMOVE>::iterator,bool> ret;
-                    ret = m_finalSaveStateFilesMap.insert(std::make_pair(name, sst));
+                    std::pair<std::map<Utf8Str, SNAPFILETASKMOVE>::iterator,bool> ret;
+                    ret = m_finalSaveStateFilesMap.insert(std::make_pair(name, sft));
                     if (ret.second == true)
                     {
                         totalStateSize += cbFile;
                         ++uCount;
-                        uTotalWeight += sst.uWeight;
+                        uTotalWeight += sft.uWeight;
                         Log2(("The state file %s was added into the moved list\n", name.c_str()));
                     }
@@ -402 +402 @@
 
         neededFreeSpace += totalStateSize;
+    }
+
+    /* Prepare data for moving ".nvram" files */
+    {
+        uint64_t totalNVRAMSize = 0;
+
+        for (size_t i = 0; i < m_llNVRAMFiles.size(); ++i)
+        {
+            uint64_t cbFile = 0;
+            SNAPFILETASKMOVE &sft = m_llNVRAMFiles.at(i);
+
+            Utf8Str name = sft.strFile;
+            /* if a NVRAM file is located in the actual VM folder it will be added to the actual list */
+            if (RTPathStartsWith(name.c_str(), strSettingsFilePath.c_str()))
+            {
+                vrc = RTFileQuerySizeByPath(name.c_str(), &cbFile);
+                if (RT_SUCCESS(vrc))
+                {
+                    std::pair<std::map<Utf8Str, SNAPFILETASKMOVE>::iterator,bool> ret;
+                    ret = m_finalNVRAMFilesMap.insert(std::make_pair(name, sft));
+                    if (ret.second == true)
+                    {
+                        totalNVRAMSize += cbFile;
+                        ++uCount;
+                        uTotalWeight += sft.uWeight;
+                        Log2(("The NVRAM file %s was added into the moved list\n", name.c_str()));
+                    }
+                }
+                else
+                {
+                    Log2(("The NVRAM file %s wasn't added into the moved list. Couldn't get the file size.\n",
+                          name.c_str()));
+                    return m_pMachine->setErrorVrc(vrc,
+                                                   m_pMachine->tr("Failed to get file size for '%s': %Rrc"),
+                                                   name.c_str(), vrc);
+                }
+            }
+        }
+
+        neededFreeSpace += totalNVRAMSize;
     }
 
@@ -643 +683 @@
             /* Check if a snapshot folder is necessary and if so doesn't already
              * exists. */
-            if (   taskMoveVM->m_finalSaveStateFilesMap.size() != 0
+            if (   (   taskMoveVM->m_finalSaveStateFilesMap.size() > 0
+                    || taskMoveVM->m_finalNVRAMFilesMap.size() > 1)
                 && !RTDirExists(strTrgSnapshotFolder.c_str()))
             {
@@ -653 +694 @@
             }
 
-            std::map<Utf8Str, SAVESTATETASKMOVE>::iterator itState = taskMoveVM->m_finalSaveStateFilesMap.begin();
+            std::map<Utf8Str, SNAPFILETASKMOVE>::iterator itState = taskMoveVM->m_finalSaveStateFilesMap.begin();
             while (itState != taskMoveVM->m_finalSaveStateFilesMap.end())
             {
-                const SAVESTATETASKMOVE &sst = itState->second;
+                const SNAPFILETASKMOVE &sft = itState->second;
                 const Utf8Str &strTrgSaveState = Utf8StrFmt("%s%c%s", strTrgSnapshotFolder.c_str(), RTPATH_DELIMITER,
-                                                            RTPathFilename(sst.strSaveStateFile.c_str()));
+                                                            RTPathFilename(sft.strFile.c_str()));
 
                 /* Move to next sub-operation. */
                 hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy the save state file '%s' ..."),
-                                                                        RTPathFilename(sst.strSaveStateFile.c_str())).raw(),
-                                                                sst.uWeight);
+                                                                        RTPathFilename(sft.strFile.c_str())).raw(),
+                                                                sft.uWeight);
                 if (FAILED(hrc))
                     throw hrc;
 
-                int vrc = RTFileCopyEx(sst.strSaveStateFile.c_str(), strTrgSaveState.c_str(), 0,
+                int vrc = RTFileCopyEx(sft.strFile.c_str(), strTrgSaveState.c_str(), 0,
                                        MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
                 if (RT_FAILURE(vrc))
                     throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
                                                 taskMoveVM->m_pMachine->tr("Could not copy state file '%s' to '%s' (%Rrc)"),
-                                                sst.strSaveStateFile.c_str(),
+                                                sft.strFile.c_str(),
                                                 strTrgSaveState.c_str(),
                                                 vrc);
@@ -679 +720 @@
                 newFiles.append(strTrgSaveState);
                 /* save original file for deletion in the end */
-                originalFiles.append(sst.strSaveStateFile);
+                originalFiles.append(sft.strFile);
                 ++itState;
+            }
+
+            std::map<Utf8Str, SNAPFILETASKMOVE>::iterator itNVRAM = taskMoveVM->m_finalNVRAMFilesMap.begin();
+            while (itNVRAM != taskMoveVM->m_finalNVRAMFilesMap.end())
+            {
+                const SNAPFILETASKMOVE &sft = itNVRAM->second;
+                const Utf8Str &strTrgNVRAM = Utf8StrFmt("%s%c%s", sft.snapshotUuid.isZero() ? strTargetFolder.c_str() : strTrgSnapshotFolder.c_str(),
+                                                        RTPATH_DELIMITER, RTPathFilename(sft.strFile.c_str()));
+
+                /* Move to next sub-operation. */
+                hrc = taskMoveVM->m_pProgress->SetNextOperation(BstrFmt(machine->tr("Copy the NVRAM file '%s' ..."),
+                                                                        RTPathFilename(sft.strFile.c_str())).raw(),
+                                                                sft.uWeight);
+                if (FAILED(hrc))
+                    throw hrc;
+
+                int vrc = RTFileCopyEx(sft.strFile.c_str(), strTrgNVRAM.c_str(), 0,
+                                       MachineMoveVM::copyFileProgress, &taskMoveVM->m_pProgress);
+                if (RT_FAILURE(vrc))
+                    throw machine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                                taskMoveVM->m_pMachine->tr("Could not copy NVRAM file '%s' to '%s' (%Rrc)"),
+                                                sft.strFile.c_str(),
+                                                strTrgNVRAM.c_str(),
+                                                vrc);
+
+                /* save new file in case of restoring */
+                newFiles.append(strTrgNVRAM);
+                /* save original file for deletion in the end */
+                originalFiles.append(sft.strFile);
+                ++itNVRAM;
             }
         }
@@ -695 +766 @@
 
         /*
+         * Update NVRAM file paths
+         * very important step!
+         */
+        Log2(("Update NVRAM paths\n"));
+        /** @todo r=klaus: this update is not necessarily matching what the
+         * above code has set as the new folders, so it needs reimplementing.
+         * What's good about this implementation: it does not look at the
+         * list of NVRAM files, because that only lists the existing ones,
+         * but all paths need fixing. */
+        taskMoveVM->updatePathsToNVRAMFiles(taskMoveVM->m_vmFolders[VBox_SettingFolder],
+                                            strTargetFolder);
+
+        /*
          * Moving Machine settings file
          * The settings file are moved after all disks and snapshots because this file should be updated
@@ -753 +837 @@
             /* save original file for deletion in the end */
             originalFiles.append(strSettingsFilePath);
+
+            Utf8Str strPrevSettingsFilePath = strSettingsFilePath;
+            strPrevSettingsFilePath.append("-prev");
+            if (RTFileExists(strPrevSettingsFilePath.c_str()))
+                originalFiles.append(strPrevSettingsFilePath);
         }
 
@@ -921 +1010 @@
                                                 taskMoveVM->m_vmFolders[VBox_SettingFolder]);
 
+            /* Revert original paths to the NVRAM files */
+            taskMoveVM->updatePathsToNVRAMFiles(strTargetFolder,
+                                                taskMoveVM->m_vmFolders[VBox_SettingFolder]);
+
             /* Delete all created files. Here we update progress object */
             hrc = taskMoveVM->deleteFiles(newFiles);
@@ -1159 +1252 @@
                                                                RTPATH_DELIMITER,
                                                                RTPathFilename(m_pMachine->mSSData->strStateFilePath.c_str()));
+    }
+}
+
+void MachineMoveVM::updatePathsToNVRAMFiles(const Utf8Str &sourcePath, const Utf8Str &targetPath)
+{
+    ComObjPtr<Snapshot> pSnapshot;
+    HRESULT rc = m_pMachine->i_findSnapshotById(Guid() /* zero */, pSnapshot, true);
+    if (SUCCEEDED(rc) && !pSnapshot.isNull())
+        pSnapshot->i_updateNVRAMPaths(sourcePath.c_str(),
+                                      targetPath.c_str());
+    ComObjPtr<BIOSSettings> pBIOSSettings(m_pMachine->mBIOSSettings);
+    const Utf8Str NVRAMFile(pBIOSSettings->i_getNonVolatileStorageFile());
+    if (NVRAMFile.isNotEmpty())
+    {
+        Utf8Str newNVRAMFile;
+        if (RTPathStartsWith(NVRAMFile.c_str(), sourcePath.c_str()))
+            newNVRAMFile = Utf8StrFmt("%s%s", targetPath.c_str(), NVRAMFile.c_str() + sourcePath.length());
+        else
+            newNVRAMFile = Utf8StrFmt("%s%c%s", targetPath.c_str(), RTPATH_DELIMITER, RTPathFilename(newNVRAMFile.c_str()));
+        pBIOSSettings->i_updateNonVolatileStorageFile(newNVRAMFile);
     }
 }
@@ -1420 +1533 @@
         rc = addSaveState(machine);
         if (FAILED(rc)) return rc;
+
+        /* Add the NVRAM files of this machine if there is one. */
+        rc = addNVRAM(machine);
+        if (FAILED(rc)) return rc;
     }
 
@@ -1443 +1560 @@
     if (!bstrSrcSaveStatePath.isEmpty())
     {
-        SAVESTATETASKMOVE sst;
-
-        sst.snapshotUuid = machine->i_getSnapshotId();
-        sst.strSaveStateFile = bstrSrcSaveStatePath;
+        SNAPFILETASKMOVE sft;
+
+        sft.snapshotUuid = machine->i_getSnapshotId();
+        sft.strFile = bstrSrcSaveStatePath;
         uint64_t cbSize;
 
-        int vrc = RTFileQuerySizeByPath(sst.strSaveStateFile.c_str(), &cbSize);
+        int vrc = RTFileQuerySizeByPath(sft.strFile.c_str(), &cbSize);
         if (RT_FAILURE(vrc))
             return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
                                             m_pMachine->tr("Could not get file size of '%s': %Rrc"),
-                                            sst.strSaveStateFile.c_str(),
+                                            sft.strFile.c_str(),
                                             vrc);
 
         /* same rule as above: count both the data which needs to
          * be read and written */
-        sst.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
-        m_llSaveStateFiles.append(sst);
+        sft.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
+        m_llSaveStateFiles.append(sft);
+    }
+    return S_OK;
+}
+
+HRESULT MachineMoveVM::addNVRAM(const ComObjPtr<Machine> &machine)
+{
+    ComPtr<IBIOSSettings> pBIOSSettings;
+    HRESULT rc = machine->COMGETTER(BIOSSettings)(pBIOSSettings.asOutParam());
+    if (FAILED(rc)) return rc;
+    Bstr bstrSrcNVRAMPath;
+    rc = pBIOSSettings->COMGETTER(NonVolatileStorageFile)(bstrSrcNVRAMPath.asOutParam());
+    if (FAILED(rc)) return rc;
+    Utf8Str strSrcNVRAMPath(bstrSrcNVRAMPath);
+    if (!strSrcNVRAMPath.isEmpty() && RTFileExists(strSrcNVRAMPath.c_str()))
+    {
+        SNAPFILETASKMOVE sft;
+
+        sft.snapshotUuid = machine->i_getSnapshotId();
+        sft.strFile = strSrcNVRAMPath;
+        uint64_t cbSize;
+
+        int vrc = RTFileQuerySizeByPath(sft.strFile.c_str(), &cbSize);
+        if (RT_FAILURE(vrc))
+            return m_pMachine->setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                            m_pMachine->tr("Could not get file size of '%s': %Rrc"),
+                                            sft.strFile.c_str(),
+                                            vrc);
+
+        /* same rule as above: count both the data which needs to
+         * be read and written */
+        sft.uWeight = (ULONG)(2 * (cbSize + _1M - 1) / _1M);
+        m_llNVRAMFiles.append(sft);
     }
     return S_OK;

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

@@ -656 +656 @@
 
     /* state file may be NULL (for offline snapshots) */
-    if (    path.length()
+    if (    path.isNotEmpty()
          && RTPathStartsWith(path.c_str(), strOldPath.c_str())
        )
@@ -663 +663 @@
                                                             strNewPath.c_str(),
                                                             path.c_str() + strOldPath.length());
-        LogFlowThisFunc(("-> updated: {%s}\n", path.c_str()));
+        LogFlowThisFunc(("-> updated: {%s}\n", m->pMachine->mSSData->strStateFilePath.c_str()));
     }
 
@@ -673 +673 @@
         pChild->i_updateSavedStatePathsImpl(strOldPath, strNewPath);
     }
+}
+
+/**
+ *  Checks if the specified path change affects the saved state file path of
+ *  this snapshot or any of its (grand-)children and updates it accordingly.
+ *
+ *  Intended to be called by Machine::openConfigLoader() only.
+ *
+ *  @param  strOldPath old path (full)
+ *  @param  strNewPath new path (full)
+ *
+ *  @note Locks the machine (for the snapshots tree) +  this object + children for writing.
+ */
+void Snapshot::i_updateSavedStatePaths(const Utf8Str &strOldPath,
+                                       const Utf8Str &strNewPath)
+{
+    LogFlowThisFunc(("aOldPath={%s} aNewPath={%s}\n", strOldPath.c_str(), strNewPath.c_str()));
+
+    AutoCaller autoCaller(this);
+    AssertComRC(autoCaller.rc());
+
+    // snapshots tree is protected by machine lock
+    AutoWriteLock alock(m->pMachine COMMA_LOCKVAL_SRC_POS);
+
+    // call the implementation under the tree lock
+    i_updateSavedStatePathsImpl(strOldPath, strNewPath);
 }
 
@@ -714 +740 @@
 
 /**
- *  Checks if the specified path change affects the saved state file path of
+ * Internal implementation for Snapshot::updateNVRAMPaths (below).
+ * @param   strOldPath
+ * @param   strNewPath
+ */
+void Snapshot::i_updateNVRAMPathsImpl(const Utf8Str &strOldPath,
+                                      const Utf8Str &strNewPath)
+{
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
+
+    const Utf8Str path = m->pMachine->mBIOSSettings->i_getNonVolatileStorageFile();
+    LogFlowThisFunc(("Snap[%s].nvramPath={%s}\n", m->strName.c_str(), path.c_str()));
+
+    /* NVRAM filename may be empty */
+    if (    path.isNotEmpty()
+         && RTPathStartsWith(path.c_str(), strOldPath.c_str())
+       )
+    {
+        m->pMachine->mBIOSSettings->i_updateNonVolatileStorageFile(Utf8StrFmt("%s%s",
+                                                                              strNewPath.c_str(),
+                                                                              path.c_str() + strOldPath.length()));
+        LogFlowThisFunc(("-> updated: {%s}\n", m->pMachine->mBIOSSettings->i_getNonVolatileStorageFile().c_str()));
+    }
+
+    for (SnapshotsList::const_iterator it = m->llChildren.begin();
+         it != m->llChildren.end();
+         ++it)
+    {
+        Snapshot *pChild = *it;
+        pChild->i_updateNVRAMPathsImpl(strOldPath, strNewPath);
+    }
+}
+
+/**
+ *  Checks if the specified path change affects the NVRAM file path of
  *  this snapshot or any of its (grand-)children and updates it accordingly.
  *
@@ -724 +783 @@
  *  @note Locks the machine (for the snapshots tree) +  this object + children for writing.
  */
-void Snapshot::i_updateSavedStatePaths(const Utf8Str &strOldPath,
-                                       const Utf8Str &strNewPath)
+void Snapshot::i_updateNVRAMPaths(const Utf8Str &strOldPath,
+                                  const Utf8Str &strNewPath)
 {
     LogFlowThisFunc(("aOldPath={%s} aNewPath={%s}\n", strOldPath.c_str(), strNewPath.c_str()));
@@ -844 +903 @@
 
     // report the saved state file if it's not on the list yet
-    if (!m->pMachine->mSSData->strStateFilePath.isEmpty())
+    if (m->pMachine->mSSData->strStateFilePath.isNotEmpty())
     {
         bool fFound = false;
@@ -861 +920 @@
             llFilenames.push_back(m->pMachine->mSSData->strStateFilePath);
     }
+
+    Utf8Str strNVRAMFile = m->pMachine->mBIOSSettings->i_getNonVolatileStorageFile();
+    if (strNVRAMFile.isNotEmpty() && RTFileExists(strNVRAMFile.c_str()))
+        llFilenames.push_back(strNVRAMFile);
 
     i_beginSnapshotDelete();
@@ -1782 +1845 @@
             if (FAILED(rc))
                 throw rc;
+        }
+
+        // Handle NVRAM file snapshotting
+        Utf8Str strNVRAM = mBIOSSettings->i_getNonVolatileStorageFile();
+        Utf8Str strNVRAMSnap = pSnapshotMachine->i_getSnapshotNVRAMFilename();
+        Utf8Str strNVRAMSnapAbs;
+        i_calculateFullPath(strNVRAMSnap, strNVRAMSnapAbs);
+        if (strNVRAM.isNotEmpty() && strNVRAMSnap.isNotEmpty() && RTFileExists(strNVRAM.c_str()))
+        {
+            rc = VirtualBox::i_ensureFilePathExists(strNVRAMSnapAbs, true /* fCreate */);
+            if (FAILED(rc))
+                throw rc;
+            int vrc = RTFileCopy(strNVRAM.c_str(), strNVRAMSnapAbs.c_str());
+            if (RT_FAILURE(vrc))
+                throw setErrorBoth(VBOX_E_IPRT_ERROR, vrc,
+                                   tr("Could not copy NVRAM file '%s' to '%s' (%Rrc)"),
+                                   strNVRAM.c_str(), strNVRAMSnapAbs.c_str(), vrc);
+            pSnapshotMachine->mBIOSSettings->i_updateNonVolatileStorageFile(strNVRAMSnap);
         }
 
@@ -2276 +2357 @@
                 mSSData->strStateFilePath = strSnapshotStateFile;
 
+            const Utf8Str srcNVRAM(pSnapshotMachine->mBIOSSettings->i_getNonVolatileStorageFile());
+            const Utf8Str dstNVRAM(mBIOSSettings->i_getNonVolatileStorageFile());
+            if (dstNVRAM.isNotEmpty() && RTFileExists(dstNVRAM.c_str()))
+                RTFileDelete(dstNVRAM.c_str());
+            if (srcNVRAM.isNotEmpty() && dstNVRAM.isNotEmpty() && RTFileExists(srcNVRAM.c_str()))
+                RTFileCopy(srcNVRAM.c_str(), dstNVRAM.c_str());
+
             LogFlowThisFunc(("Setting new current snapshot {%RTuuid}\n", task.m_pSnapshot->i_getId().raw()));
             /* make the snapshot we restored from the current snapshot */
@@ -2621 +2709 @@
     ULONG ulTotalWeight = 1;        // one for preparations
 
-    if (pSnapshot->i_getStateFilePath().length())
+    if (pSnapshot->i_getStateFilePath().isNotEmpty())
     {
         ++ulOpCount;
@@ -3391 +3479 @@
         }
 
+        /* 3a: delete NVRAM file if present. */
+        {
+            Utf8Str NVRAMPath = pSnapMachine->mBIOSSettings->i_getNonVolatileStorageFile();
+            if (NVRAMPath.isNotEmpty() && RTFileExists(NVRAMPath.c_str()))
+                RTFileDelete(NVRAMPath.c_str());
+        }
+
+        /* third pass: */
         {
             // beginSnapshotDelete() needs the machine lock, and the snapshots