Changeset 24922 in vbox for trunk/src/VBox/Main

Timestamp:

Nov 24, 2009 7:33:31 PM (15 years ago)

Author:

vboxsync

Message:

Main,VMM: Debugging live snapshots.

File:

• trunk/src/VBox/Main/ConsoleImpl.cpp (modified) (17 diffs)

trunk/src/VBox/Main/ConsoleImpl.cpp

@@ -2579 +2579 @@
     ULONG ulMemSize;
     rc = mMachine->COMGETTER(MemorySize)(&ulMemSize);
-    if (FAILED(rc)) return rc;
+    if (FAILED(rc))
+        return rc;
 
     for (size_t i = 0;
@@ -2587 +2588 @@
         DeviceType_T type;
         rc = aMediumAttachments[i]->COMGETTER(Type)(&type);
-        if (FAILED(rc)) return rc;
+        if (FAILED(rc))
+            return rc;
 
         if (type == DeviceType_HardDisk)
@@ -2605 +2607 @@
 
     if (    fTakingSnapshotOnline
-         || (mMachineState == MachineState_Saved)
+         || mMachineState == MachineState_Saved
        )
     {
@@ -2624 +2626 @@
                          1);        // ulFirstOperationWeight
 
-    if (FAILED(rc)) return rc;
+    if (FAILED(rc))
+        return rc;
 
     VMTakeSnapshotTask *pTask;
     if (!(pTask = new VMTakeSnapshotTask(this, pProgress, aName, aDescription)))
-        return VERR_NO_MEMORY;
+        return E_OUTOFMEMORY;
 
     Assert(pTask->mProgress);
@@ -5271 +5274 @@
     if (mMachineState != aMachineState)
     {
-        LogFlowThisFunc(("machineState=%d\n", aMachineState));
+        LogThisFunc(("machineState=%s -> %s aUpdateServer=%RTbool\n",
+                     Global::stringifyMachineState(mMachineState), Global::stringifyMachineState(aMachineState), aUpdateServer));
         mMachineState = aMachineState;
 
@@ -5627 +5631 @@
                                                   void *aUser)
 {
-    LogFlowFunc(("Changing state from %d to %d (aVM=%p)\n",
-                 aOldState, aState, aVM));
+    LogFlowFunc(("Changing state from %s to %s (aVM=%p)\n",
+                 VMR3GetStateName(aOldState), VMR3GetStateName(aState), aVM));
 
     Console *that = static_cast<Console *>(aUser);
@@ -7345 +7349 @@
 
     bool fBeganTakingSnapshot = false;
+    bool fSuspenededBySave = false;
 
     AutoCaller autoCaller(pTask->mConsole);
@@ -7368 +7373 @@
                                                             pTask->fTakingSnapshotOnline,
                                                             pTask->bstrSavedStateFile.asOutParam());
-        if (FAILED(rc)) throw rc;
+        if (FAILED(rc))
+            throw rc;
 
         fBeganTakingSnapshot = true;
@@ -7381 +7387 @@
 
         /* sync the state with the server */
-        that->setMachineStateLocally(MachineState_Saving);
+        if (pTask->lastMachineState == MachineState_Running)
+            that->setMachineStateLocally(MachineState_LiveSnapshotting);
+        else
+            that->setMachineStateLocally(MachineState_Saving);
 
         // STEP 3: save the VM state (if online)
@@ -7392 +7401 @@
 
             alock.leave();
-
+            LogFlowFunc(("VMR3Save...\n"));
             int vrc = VMR3Save(that->mpVM,
                                strSavedStateFile.c_str(),
                                true /*fContinueAfterwards*/,
                                Console::stateProgressCallback,
-                               (void*)pTask);
+                               (void*)pTask,
+                               &fSuspenededBySave);
+            alock.enter();
             if (RT_FAILURE(vrc))
                 throw setError(E_FAIL,
-                            tr("Failed to save the machine state to '%s' (%Rrc)"),
-                            strSavedStateFile.c_str(), vrc);
-
-            alock.enter();
+                               tr("Failed to save the machine state to '%s' (%Rrc)"),
+                               strSavedStateFile.c_str(), vrc);
+
 
             // STEP 4: reattach hard disks
@@ -7413 +7423 @@
             com::SafeIfaceArray<IMediumAttachment> atts;
             rc = that->mMachine->COMGETTER(MediumAttachments)(ComSafeArrayAsOutParam(atts));
-            if (FAILED(rc)) throw rc;
+            if (FAILED(rc))
+                throw rc;
 
             for (size_t i = 0;
@@ -7431 +7442 @@
                 */
                 rc = atts[i]->COMGETTER(Controller)(&controllerName);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc))
+                    throw rc;
 
                 rc = that->mMachine->GetStorageControllerByName(controllerName, controller.asOutParam());
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc))
+                    throw rc;
 
                 rc = controller->COMGETTER(ControllerType)(&enmController);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc))
+                    throw rc;
                 rc = controller->COMGETTER(Instance)(&lInstance);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc))
+                    throw rc;
                 rc = controller->COMGETTER(Bus)(&enmBus);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc))
+                    throw rc;
 
                 /*
@@ -7459 +7475 @@
                 if (RT_FAILURE(vrc))
                     throw setError(E_FAIL, Console::tr("%Rrc"), vrc);
-                if (FAILED(rc)) throw rc;
+                if (FAILED(rc))
+                    throw rc;
             }
         }
@@ -7468 +7485 @@
          * before calling mControl->BeginTakingSnapshot().
          */
-        rc = that->mControl->EndTakingSnapshot(TRUE);        // success
+        rc = that->mControl->EndTakingSnapshot(TRUE /*aSuccess*/);
         // do not throw rc here because we can't call EndTakingSnapshot() twice
-    }
-    catch (HRESULT rc)
+        LogFlowFunc(("EndTakingSnapshot -> %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
+    }
+    catch (HRESULT rcThrown)
     {
         /* preserve existing error info */
@@ -7477 +7495 @@
 
         if (fBeganTakingSnapshot)
-            that->mControl->EndTakingSnapshot(FALSE);             // failure
-    }
-
-    pTask->mProgress->notifyComplete(rc);
+            that->mControl->EndTakingSnapshot(FALSE /*aSuccess*/);
+
+        rc = rcThrown;
+        LogFunc(("Caught %Rhrc [mMachineState=%s]\n", rc, Global::stringifyMachineState(that->mMachineState)));
+    }
+    Assert(alock.isWriteLockOnCurrentThread());
+
+    if (FAILED(rc)) /* Must come before calling setMachineState. */
+        pTask->mProgress->notifyComplete(rc);
+
+    /*
+     * Fix up the machine state.
+     *
+     * For live snapshots we do all the work, for the two other variantions we
+     * just update the local copy.
+     */
+    MachineState_T enmMachineState;
+    that->mMachine->COMGETTER(State)(&enmMachineState);
+    if (   that->mMachineState == MachineState_LiveSnapshotting
+        || that->mMachineState == MachineState_Saving)
+    {
+
+        if (!pTask->fTakingSnapshotOnline)
+            that->setMachineStateLocally(pTask->lastMachineState);
+        else if (SUCCEEDED(rc))
+        {
+            Assert(   pTask->lastMachineState == MachineState_Running
+                   || pTask->lastMachineState == MachineState_Paused);
+            Assert(that->mMachineState == MachineState_Saving);
+            if (pTask->lastMachineState == MachineState_Running)
+            {
+                LogFlowFunc(("VMR3Resume...\n"));
+                alock.leave();
+                int vrc = VMR3Resume(that->mpVM);
+                alock.enter();
+                if (RT_FAILURE(vrc))
+                {
+                    rc = setError(VBOX_E_VM_ERROR, tr("Could not resume the machine execution (%Rrc)"), vrc);
+                    pTask->mProgress->notifyComplete(rc);
+                    if (that->mMachineState == MachineState_Saving)
+                        that->setMachineStateLocally(MachineState_Paused);
+                }
+            }
+            else
+                that->setMachineStateLocally(MachineState_Paused);
+        }
+        else
+        {
+            /** @todo this could probably be made more generic and reused elsewhere. */
+            /* paranoid cleanup on for a failed online snapshot. */
+            VMSTATE enmVMState = VMR3GetState(that->mpVM);
+            switch (enmVMState)
+            {
+                case VMSTATE_RUNNING:
+                case VMSTATE_RUNNING_LS:
+                case VMSTATE_DEBUGGING:
+                case VMSTATE_DEBUGGING_LS:
+                case VMSTATE_POWERING_OFF:
+                case VMSTATE_POWERING_OFF_LS:
+                case VMSTATE_RESETTING:
+                case VMSTATE_RESETTING_LS:
+                    Assert(!fSuspenededBySave);
+                    that->setMachineState(MachineState_Running);
+                    break;
+
+                case VMSTATE_GURU_MEDITATION:
+                case VMSTATE_GURU_MEDITATION_LS:
+                    that->setMachineState(MachineState_Stuck);
+                    break;
+
+                case VMSTATE_FATAL_ERROR:
+                case VMSTATE_FATAL_ERROR_LS:
+                    if (pTask->lastMachineState == MachineState_Paused)
+                        that->setMachineStateLocally(pTask->lastMachineState);
+                    else
+                        that->setMachineState(MachineState_Paused);
+                    break;
+
+                default:
+                    AssertMsgFailed(("%s\n", VMR3GetStateName(enmVMState)));
+                case VMSTATE_SUSPENDED:
+                case VMSTATE_SUSPENDED_LS:
+                case VMSTATE_SUSPENDING:
+                case VMSTATE_SUSPENDING_LS:
+                case VMSTATE_SUSPENDING_EXT_LS:
+                    if (fSuspenededBySave)
+                    {
+                        Assert(pTask->lastMachineState == MachineState_Running);
+                        LogFlowFunc(("VMR3Resume (on failure)...\n"));
+                        alock.leave();
+                        int vrc = VMR3Resume(that->mpVM);
+                        alock.enter();
+                        AssertLogRelRC(vrc);
+                        if (RT_FAILURE(vrc))
+                            that->setMachineState(MachineState_Paused);
+                    }
+                    else if (pTask->lastMachineState == MachineState_Paused)
+                        that->setMachineStateLocally(pTask->lastMachineState);
+                    else
+                        that->setMachineState(MachineState_Paused);
+                    break;
+            }
+
+        }
+    }
+    /*else: somebody else has change the state... Leave it. */
+
+    /* check the remote state to see that we got it right. */
+    that->mMachine->COMGETTER(State)(&enmMachineState);
+    AssertLogRelMsg(that->mMachineState == enmMachineState,
+                    ("mMachineState=%s enmMachineState=%s\n", Global::stringifyMachineState(that->mMachineState),
+                     Global::stringifyMachineState(enmMachineState) ));
+
+
+    if (SUCCEEDED(rc)) /* The failure cases are handled above. */
+        pTask->mProgress->notifyComplete(rc);
 
     delete pTask;
-
-    if (pTask->lastMachineState == MachineState_Running)
-    {
-        /* restore the paused state if appropriate */
-        that->setMachineStateLocally(MachineState_Paused);
-        /* restore the running state if appropriate */
-        that->Resume();
-    }
-    else
-        that->setMachineStateLocally(pTask->lastMachineState);
 
     LogFlowFuncLeave();
@@ -7524 +7644 @@
     LogFlowFunc(("Saving the state to '%s'...\n", task->mSavedStateFile.raw()));
 
+    bool fSuspenededBySave;
     int vrc = VMR3Save(that->mpVM,
                        task->mSavedStateFile.c_str(),
                        false, /*fContinueAfterwards*/
                        Console::stateProgressCallback,
-                       static_cast<VMProgressTask*>(task.get()));
+                       static_cast<VMProgressTask*>(task.get()),
+                       &fSuspenededBySave);
     if (RT_FAILURE(vrc))
     {
@@ -7535 +7657 @@
         rc = E_FAIL;
     }
+    Assert(!fSuspenededBySave);
 
     /* lock the console once we're going to access it */