Changeset 44393 in vbox for trunk

Timestamp:

Jan 25, 2013 9:21:05 PM (12 years ago)

Author:

vboxsync

Message:

VM,++: Changed the VM callbacks (at error, at runtime error, at state change) to use PUVM instead of PVM.

Location:

trunk

Files:

• include/VBox/vmm/vmapi.h (modified) (6 diffs)
• src/VBox/Debugger/VBoxDbgBase.cpp (modified) (2 diffs)
• src/VBox/Debugger/VBoxDbgBase.h (modified) (1 diff)
• src/VBox/Main/include/ConsoleImpl.h (modified) (2 diffs)
• src/VBox/Main/src-client/ConsoleImpl.cpp (modified) (23 diffs)
• src/VBox/Main/src-client/ConsoleImpl2.cpp (modified) (1 diff)
• src/VBox/Main/src-client/ConsoleImplTeleporter.cpp (modified) (2 diffs)
• src/VBox/VMM/VMMR3/PGM.cpp (modified) (4 diffs)
• src/VBox/VMM/VMMR3/SSM.cpp (modified) (11 diffs)
• src/VBox/VMM/VMMR3/VM.cpp (modified) (7 diffs)
• src/VBox/VMM/testcase/tstVMREQ.cpp (modified) (1 diff)

trunk/include/VBox/vmm/vmapi.h

@@ -93 +93 @@
  * VM error callback function.
  *
- * @param   pVM             The VM handle. Can be NULL if an error occurred before
- *                          successfully creating a VM.
+ * @param   pUVM            The user mode VM handle.  Can be NULL if an error
+ *                          occurred before successfully creating a VM.
  * @param   pvUser          The user argument.
  * @param   rc              VBox status code.
@@ -101 +101 @@
  * @param   args            Error message arguments.
  */
-typedef DECLCALLBACK(void) FNVMATERROR(PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL, const char *pszError, va_list args);
+typedef DECLCALLBACK(void) FNVMATERROR(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL, const char *pszError, va_list args);
 /** Pointer to a VM error callback. */
 typedef FNVMATERROR *PFNVMATERROR;
@@ -129 +129 @@
  * See VMSetRuntimeError for the detailed description of parameters.
  *
- * @param   pVM             The VM handle.
+ * @param   pUVM            The user mode VM handle.
  * @param   pvUser          The user argument.
  * @param   fFlags          The error flags.
@@ -136 +136 @@
  * @param   va              Error message arguments.
  */
-typedef DECLCALLBACK(void) FNVMATRUNTIMEERROR(PVM pVM, void *pvUser, uint32_t fFlags, const char *pszErrorId,
+typedef DECLCALLBACK(void) FNVMATRUNTIMEERROR(PUVM pUVM, void *pvUser, uint32_t fFlags, const char *pszErrorId,
                                               const char *pszFormat, va_list va);
 /** Pointer to a VM runtime error callback. */
@@ -164 +164 @@
 
 /**
- * VM state callback function.
+ * VM state change callback function.
  *
  * You are not allowed to call any function which changes the VM state from a
  * state callback, except VMR3Destroy().
  *
- * @param   pVM         The VM handle.
+ * @param   pUVM        The user mode VM handle.
  * @param   enmState    The new state.
  * @param   enmOldState The old state.
  * @param   pvUser      The user argument.
  */
-typedef DECLCALLBACK(void) FNVMATSTATE(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
+typedef DECLCALLBACK(void) FNVMATSTATE(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
 /** Pointer to a VM state callback. */
 typedef FNVMATSTATE *PFNVMATSTATE;
@@ -318 +318 @@
 /**
  * Progress callback.
+ *
  * This will report the completion percentage of an operation.
  *
  * @returns VINF_SUCCESS.
  * @returns Error code to cancel the operation with.
- * @param   pVM         The VM handle.
+ * @param   pUVM        The user mode VM handle.
  * @param   uPercent    Completion percentage (0-100).
  * @param   pvUser      User specified argument.
  */
-typedef DECLCALLBACK(int) FNVMPROGRESS(PVM pVM, unsigned uPercent, void *pvUser);
+typedef DECLCALLBACK(int) FNVMPROGRESS(PUVM pUVM, unsigned uPercent, void *pvUser);
 /** Pointer to a FNVMPROGRESS function. */
 typedef FNVMPROGRESS *PFNVMPROGRESS;
-
-/**
- * VM destruction callback.
- * @param   pVM     The VM which is about to be destroyed.
- * @param   pvUser  The user parameter specified at registration.
- */
-typedef DECLCALLBACK(void) FNVMATDTOR(PVM pVM, void *pvUser);
-/** Pointer to a VM destruction callback. */
-typedef FNVMATDTOR *PFNVMATDTOR;
 
 

trunk/src/VBox/Debugger/VBoxDbgBase.cpp

@@ -104 +104 @@
 
 /*static*/ DECLCALLBACK(void)
-VBoxDbgBase::atStateChange(PVM pVM, VMSTATE enmState, VMSTATE /*enmOldState*/, void *pvUser)
-{
-    VBoxDbgBase *pThis = (VBoxDbgBase *)pvUser; NOREF(pVM);
+VBoxDbgBase::atStateChange(PUVM pUVM, VMSTATE enmState, VMSTATE /*enmOldState*/, void *pvUser)
+{
+    VBoxDbgBase *pThis = (VBoxDbgBase *)pvUser; NOREF(pUVM);
     switch (enmState)
     {
@@ -112 +112 @@
         {
             /** @todo need to do some locking here?  */
-            PUVM pUVM = ASMAtomicXchgPtrT(&pThis->m_pUVM, NULL, PUVM);
-            if (pUVM)
+            PUVM pUVM2 = ASMAtomicXchgPtrT(&pThis->m_pUVM, NULL, PUVM);
+            if (pUVM2)
             {
+                Assert(pUVM2 == pUVM);
                 pThis->sigTerminated();
-                VMR3ReleaseUVM(pUVM);
+                VMR3ReleaseUVM(pUVM2);
             }
             break;

trunk/src/VBox/Debugger/VBoxDbgBase.h

@@ -104 +104 @@
 
 private:
-    /**
-     * VM state callback function.
-     *
-     * You are not allowed to call any function which changes the VM state from a
-     * state callback, except VMR3Destroy().
-     *
-     * @param   pVM         The VM handle.
-     * @param   enmState    The new state.
-     * @param   enmOldState The old state.
-     * @param   pvUser      The user argument.
-     */
-    static DECLCALLBACK(void) atStateChange(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
+    /** @callback_method_impl{FNVMATSTATE}  */
+    static DECLCALLBACK(void) atStateChange(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
 
 private:

trunk/src/VBox/Main/include/ConsoleImpl.h

@@ -596 +596 @@
     static DECLCALLBACK(int) configGuestProperties(void *pvConsole, PUVM pUVM);
     static DECLCALLBACK(int) configGuestControl(void *pvConsole);
-    static DECLCALLBACK(void) vmstateChangeCallback(PVM aVM, VMSTATE aState,
-                                                    VMSTATE aOldState, void *aUser);
+    static DECLCALLBACK(void) vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
     static DECLCALLBACK(int) unplugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
     static DECLCALLBACK(int) plugCpu(Console *pThis, PUVM pUVM, VMCPUID idCpu);
@@ -640 +639 @@
     static DECLCALLBACK(int)    fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser);
 
-    static DECLCALLBACK(int)    stateProgressCallback(PVM pVM, unsigned uPercent, void *pvUser);
-
-    static DECLCALLBACK(void)   genericVMSetErrorCallback(PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL,
+    static DECLCALLBACK(int)    stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser);
+
+    static DECLCALLBACK(void)   genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
                                                           const char *pszErrorFmt, va_list va);
 
     void                        setVMRuntimeErrorCallbackF(uint32_t fFatal, const char *pszErrorId, const char *pszFormat, ...);
-    static DECLCALLBACK(void)   setVMRuntimeErrorCallback(PVM pVM, void *pvUser, uint32_t fFatal,
+    static DECLCALLBACK(void)   setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFatal,
                                                           const char *pszErrorId, const char *pszFormat, va_list va);
 

trunk/src/VBox/Main/src-client/ConsoleImpl.cpp

@@ -3899 +3899 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pConsole);
+            vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
         }
         /// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
@@ -4144 +4144 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pConsole);
-        }
-        /** @todo: if we failed with drive mount, then the VMR3Resume
+            vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
+        }
+        /** @todo  if we failed with drive mount, then the VMR3Resume
          * error (if any) will be hidden from the caller. For proper reporting
          * of such multiple errors to the caller we need to enhance the
@@ -4397 +4397 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pConsole);
+            vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
         }
         /** @todo: if we failed with drive mount, then the VMR3Resume
@@ -4775 +4775 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pThis);
+            vmstateChangeCallback(pUVM, VMSTATE_SUSPENDED, enmVMState, pThis);
         }
         /// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
@@ -5751 +5751 @@
             /* too bad, we failed. try to sync the console state with the VMM state */
             AssertLogRelRC(vrc2);
-            vmstateChangeCallback(ptrVM.raw(), VMSTATE_SUSPENDED, enmVMState, this);
+            vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
         }
     }
@@ -5827 +5827 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(ptrVM.raw(), VMSTATE_SUSPENDED, enmVMState, this);
+            vmstateChangeCallback(ptrVM.rawUVM(), VMSTATE_SUSPENDED, enmVMState, this);
         }
     }
@@ -7496 +7496 @@
 }
 
-/**
- * VM state callback function. Called by the VMM
- * using its state machine states.
- *
- * Primarily used to handle VM initiated power off, suspend and state saving,
- * but also for doing termination completed work (VMSTATE_TERMINATE).
- *
- * In general this function is called in the context of the EMT.
- *
- * @param   aVM         The VM handle.
- * @param   aState      The new state.
- * @param   aOldState   The old state.
- * @param   aUser       The user argument (pointer to the Console object).
- *
- * @note Locks the Console object for writing.
+/** @callback_method_impl{FNVMATSTATE}
+ *
+ * @note    Locks the Console object for writing.
+ * @remarks The @a pUVM parameter can be NULL in one case where powerUpThread()
+ *          calls after the VM was destroyed.
  */
-DECLCALLBACK(void) Console::vmstateChangeCallback(PVM aVM,
-                                                  VMSTATE aState,
-                                                  VMSTATE aOldState,
-                                                  void *aUser)
-{
-    LogFlowFunc(("Changing state from %s to %s (aVM=%p)\n",
-                 VMR3GetStateName(aOldState), VMR3GetStateName(aState), aVM));
-
-    Console *that = static_cast<Console *>(aUser);
+DECLCALLBACK(void) Console::vmstateChangeCallback(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
+{
+    LogFlowFunc(("Changing state from %s to %s (pUVM=%p)\n",
+                 VMR3GetStateName(enmOldState), VMR3GetStateName(enmState),     pUVM));
+
+    Console *that = static_cast<Console *>(pvUser);
     AssertReturnVoid(that);
 
@@ -7532 +7519 @@
                      || autoCaller.state() == InUninit);
 
-    switch (aState)
+    switch (enmState)
     {
         /*
@@ -7620 +7607 @@
                 break;
 
-            /* Terminate host interface networking. If aVM is NULL, we've been
+            /* Terminate host interface networking. If pUVM is NULL, we've been
              * manually called from powerUpThread() either before calling
              * VMR3Create() or after VMR3Create() failed, so no need to touch
              * networking.
              */
-            if (aVM)
+            if (pUVM)
                 that->powerDownHostInterfaces();
 
@@ -7740 +7727 @@
 
                 default:
-                    AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(aOldState),  VMR3GetStateName(aState) ));
+                    AssertMsgFailed(("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState),  VMR3GetStateName(enmState) ));
                     that->setMachineState(MachineState_Paused);
                     break;
@@ -7749 +7736 @@
         case VMSTATE_RUNNING:
         {
-            if (   aOldState == VMSTATE_POWERING_ON
-                || aOldState == VMSTATE_RESUMING
-                || aOldState == VMSTATE_RUNNING_FT)
+            if (   enmOldState == VMSTATE_POWERING_ON
+                || enmOldState == VMSTATE_RESUMING
+                || enmOldState == VMSTATE_RUNNING_FT)
             {
                 AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
@@ -7760 +7747 @@
                 Assert(   (   (   that->mMachineState == MachineState_Starting
                                || that->mMachineState == MachineState_Paused)
-                           && aOldState == VMSTATE_POWERING_ON)
+                           && enmOldState == VMSTATE_POWERING_ON)
                        || (   (   that->mMachineState == MachineState_Restoring
                                || that->mMachineState == MachineState_TeleportingIn
@@ -7766 +7753 @@
                                || that->mMachineState == MachineState_Saving
                               )
-                           && aOldState == VMSTATE_RESUMING)
+                           && enmOldState == VMSTATE_RESUMING)
                        || (   that->mMachineState == MachineState_FaultTolerantSyncing
-                           && aOldState == VMSTATE_RUNNING_FT));
+                           && enmOldState == VMSTATE_RUNNING_FT));
 
                 that->setMachineState(MachineState_Running);
@@ -7779 +7766 @@
             AssertMsg(   that->mMachineState == MachineState_LiveSnapshotting
                       || that->mMachineState == MachineState_Teleporting,
-                      ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(aOldState),  VMR3GetStateName(aState) ));
+                      ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState),  VMR3GetStateName(enmState) ));
             break;
 
         case VMSTATE_RUNNING_FT:
             AssertMsg(that->mMachineState == MachineState_FaultTolerantSyncing,
-                      ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(aOldState),  VMR3GetStateName(aState) ));
+                      ("%s/%s -> %s\n", Global::stringifyMachineState(that->mMachineState), VMR3GetStateName(enmOldState),  VMR3GetStateName(enmState) ));
             break;
 
@@ -8408 +8395 @@
  * and VMR3Teleport.
  *
- * @param   pVM         The VM handle.
+ * @param   pUVM        The user mode VM handle.
  * @param   uPercent    Completion percentage (0-100).
  * @param   pvUser      Pointer to an IProgress instance.
@@ -8414 +8401 @@
  */
 /*static*/
-DECLCALLBACK(int) Console::stateProgressCallback(PVM pVM, unsigned uPercent, void *pvUser)
+DECLCALLBACK(int) Console::stateProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
 {
     IProgress *pProgress = static_cast<IProgress *>(pvUser);
@@ -8422 +8409 @@
         pProgress->SetCurrentOperationProgress(uPercent);
 
+    NOREF(pUVM);
     return VINF_SUCCESS;
 }
@@ -8432 +8420 @@
  */
 /*static*/ DECLCALLBACK(void)
-Console::genericVMSetErrorCallback(PVM pVM, void *pvUser, int rc, RT_SRC_POS_DECL,
+Console::genericVMSetErrorCallback(PUVM pUVM, void *pvUser, int rc, RT_SRC_POS_DECL,
                                    const char *pszErrorFmt, va_list va)
 {
@@ -8450 +8438 @@
 
     va_end(va2);
+
+    NOREF(pUVM);
 }
 
@@ -8456 +8446 @@
  * See VMSetRuntimeError for the detailed description of parameters.
  *
- * @param   pVM             The VM handle.  Ignored, so passing NULL is fine.
+ * @param   pUVM            The user mode VM handle.  Ignored, so passing NULL
+ *                          is fine.
  * @param   pvUser          The user argument, pointer to the Console instance.
  * @param   fFlags          The action flags. See VMSETRTERR_FLAGS_*.
@@ -8465 +8456 @@
  */
 /* static */ DECLCALLBACK(void)
-Console::setVMRuntimeErrorCallback(PVM pVM, void *pvUser, uint32_t fFlags,
+Console::setVMRuntimeErrorCallback(PUVM pUVM, void *pvUser, uint32_t fFlags,
                                    const char *pszErrorId,
                                    const char *pszFormat, va_list va)
@@ -8478 +8469 @@
 
     LogRel(("Console: VM runtime error: fatal=%RTbool, errorID=%s message=\"%s\"\n",
-             fFatal, pszErrorId, message.c_str()));
-
-    that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(),
-                         Bstr(message).raw());
-
-    LogFlowFuncLeave();
+            fFatal, pszErrorId, message.c_str()));
+
+    that->onRuntimeError(BOOL(fFatal), Bstr(pszErrorId).raw(), Bstr(message).raw());
+
+    LogFlowFuncLeave(); NOREF(pUVM);
 }
 
@@ -9152 +9142 @@
 
         Assert(pConsole->mpUVM == NULL);
-        vmstateChangeCallback(NULL, VMSTATE_TERMINATED, VMSTATE_CREATING,
-                              pConsole);
+        vmstateChangeCallback(NULL, VMSTATE_TERMINATED, VMSTATE_CREATING, pConsole);
     }
 

trunk/src/VBox/Main/src-client/ConsoleImpl2.cpp

@@ -161 +161 @@
     for (int i = 0; i < 2; i++)
     {
-        inputStruct.key = (uint32_t)((i == 0) ? 'OSK0' : 'OSK1');
+        inputStruct.key = (uint32_t)(i == 0 ? 'OSK0' : 'OSK1');
         kr = IOConnectCallStructMethod((mach_port_t)port,
                                        (uint32_t)2,

trunk/src/VBox/Main/src-client/ConsoleImplTeleporter.cpp

@@ -585 +585 @@
  * @copydoc PFNVMPROGRESS
  */
-static DECLCALLBACK(int) teleporterProgressCallback(PVM pVM, unsigned uPercent, void *pvUser)
+static DECLCALLBACK(int) teleporterProgressCallback(PUVM pUVM, unsigned uPercent, void *pvUser)
 {
     TeleporterState *pState = (TeleporterState *)pvUser;
@@ -604 +604 @@
     }
 
+    NOREF(pUVM);
     return VINF_SUCCESS;
 }

trunk/src/VBox/VMM/VMMR3/PGM.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2011 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -625 +625 @@
 #include "PGMInternal.h"
 #include <VBox/vmm/vm.h>
+#include <VBox/vmm/uvm.h>
 #include "PGMInline.h"
 
@@ -653 +654 @@
 static DECLCALLBACK(int)  pgmR3RelocateHyperVirtHandler(PAVLROGCPTRNODECORE pNode, void *pvUser);
 #ifdef VBOX_STRICT
-static DECLCALLBACK(void) pgmR3ResetNoMorePhysWritesFlag(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser);
+static FNVMATSTATE        pgmR3ResetNoMorePhysWritesFlag;
 #endif
 static int                pgmR3ModeDataInit(PVM pVM, bool fResolveGCAndR0);
@@ -2601 +2602 @@
  * a snapshot has been created.
  */
-static DECLCALLBACK(void) pgmR3ResetNoMorePhysWritesFlag(PVM pVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
+static DECLCALLBACK(void) pgmR3ResetNoMorePhysWritesFlag(PUVM pUVM, VMSTATE enmState, VMSTATE enmOldState, void *pvUser)
 {
     if (   enmState == VMSTATE_RUNNING
         || enmState == VMSTATE_RESUMING)
-        pVM->pgm.s.fNoMorePhysWrites = false;
+        pUVM->pVM->pgm.s.fNoMorePhysWrites = false;
     NOREF(enmOldState); NOREF(pvUser);
 }

trunk/src/VBox/VMM/VMMR3/SSM.cpp

@@ -1093 +1093 @@
             pSSM->uPercent = uPct;
             if (pSSM->pfnProgress)
-                pSSM->pfnProgress(pVM, RT_MIN(uPct, 100 - pSSM->uPercentDone), pSSM->pvUser);
+                pSSM->pfnProgress(pVM->pUVM, RT_MIN(uPct, 100 - pSSM->uPercentDone), pSSM->pvUser);
         }
     }
@@ -2988 +2988 @@
         {
             if (pSSM->pfnProgress)
-                pSSM->pfnProgress(pSSM->pVM, pSSM->uPercent, pSSM->pvUser);
+                pSSM->pfnProgress(pSSM->pVM->pUVM, pSSM->uPercent, pSSM->pvUser);
             pSSM->uPercent++;
             pSSM->offEstProgress = (pSSM->uPercent - pSSM->uPercentPrepare - pSSM->uPercentLive) * pSSM->cbEstTotal
@@ -4318 +4318 @@
         Assert(pSSM->enmOp == SSMSTATE_SAVE_DONE);
         if (pSSM->pfnProgress)
-            pSSM->pfnProgress(pVM, 100, pSSM->pvUser);
+            pSSM->pfnProgress(pVM->pUVM, 100, pSSM->pvUser);
         LogRel(("SSM: Successfully saved the VM state to '%s'\n",
                 pSSM->pszFilename ? pSSM->pszFilename : "<remote-machine>"));
@@ -4534 +4534 @@
             ssmR3LiveControlEmit(pSSM, lrdPct, SSM_PASS_FINAL);
             pSSM->uPercent =  uPct;
-            pSSM->pfnProgress(pSSM->pVM, uPct, pSSM->pvUser);
+            pSSM->pfnProgress(pSSM->pVM->pUVM, uPct, pSSM->pvUser);
         }
     }
@@ -4734 +4734 @@
      */
     if (pSSM->pfnProgress)
-        pSSM->pfnProgress(pVM, pSSM->uPercentPrepare + pSSM->uPercentLive - 1, pSSM->pvUser);
+        pSSM->pfnProgress(pVM->pUVM, pSSM->uPercentPrepare + pSSM->uPercentLive - 1, pSSM->pvUser);
     pSSM->uPercent = pSSM->uPercentPrepare + pSSM->uPercentLive;
 
@@ -5106 +5106 @@
                 ssmR3LiveControlEmit(pSSM, lrdPct, uPass);
                 pSSM->uPercent = uPct;
-                pSSM->pfnProgress(pVM, uPct, pSSM->pvUser);
+                pSSM->pfnProgress(pVM->pUVM, uPct, pSSM->pvUser);
             }
         }
@@ -5370 +5370 @@
      */
     if (pSSM->pfnProgress)
-        pSSM->pfnProgress(pVM, 2, pSSM->pvUser);
+        pSSM->pfnProgress(pVM->pUVM, 2, pSSM->pvUser);
     pSSM->uPercent = 2;
 
@@ -8331 +8331 @@
 
         if (pfnProgress)
-            pfnProgress(pVM, Handle.uPercent, pvProgressUser);
+            pfnProgress(pVM->pUVM, Handle.uPercent, pvProgressUser);
 
         /*
@@ -8384 +8384 @@
         /* end of prepare % */
         if (pfnProgress)
-            pfnProgress(pVM, Handle.uPercentPrepare - 1, pvProgressUser);
+            pfnProgress(pVM->pUVM, Handle.uPercentPrepare - 1, pvProgressUser);
         Handle.uPercent      = Handle.uPercentPrepare;
         Handle.cbEstTotal    = Handle.u.Read.cbLoadFile;
@@ -8458 +8458 @@
         /* progress */
         if (pfnProgress)
-            pfnProgress(pVM, 99, pvProgressUser);
+            pfnProgress(pVM->pUVM, 99, pvProgressUser);
 
         ssmR3SetCancellable(pVM, &Handle, false);
@@ -8472 +8472 @@
         /* progress */
         if (pfnProgress)
-            pfnProgress(pVM, 100, pvProgressUser);
+            pfnProgress(pVM->pUVM, 100, pvProgressUser);
         Log(("SSM: Load of '%s' completed!\n", pszFilename));
     }

trunk/src/VBox/VMM/VMMR3/VM.cpp

@@ -3199 +3199 @@
     for (PVMATSTATE pCur = pUVM->vm.s.pAtState; pCur; pCur = pCur->pNext)
     {
-        pCur->pfnAtState(pVM, enmStateNew, enmStateOld, pCur->pvUser);
+        pCur->pfnAtState(pUVM, enmStateNew, enmStateOld, pCur->pvUser);
         if (    enmStateNew     != VMSTATE_DESTROYING
             &&  pVM->enmVMState == VMSTATE_DESTROYING)
@@ -3636 +3636 @@
     va_list va;
     va_start(va, pszFormat);
-    pCur->pfnAtError(pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
+    pCur->pfnAtError(pVM->pUVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va);
     va_end(va);
 }
@@ -3775 +3775 @@
         va_list va2;
         va_copy(va2, *pArgs);
-        pCur->pfnAtError(pUVM->pVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
+        pCur->pfnAtError(pUVM, pCur->pvUser, rc, RT_SRC_POS_ARGS, pszFormat, va2);
         va_end(va2);
         fCalledSomeone = true;
@@ -3946 +3946 @@
 {
     LogRel(("VM: Raising runtime error '%s' (fFlags=%#x)\n", pszErrorId, fFlags));
+    PUVM pUVM = pVM->pUVM;
 
     /*
@@ -3955 +3956 @@
                                 vmR3SetRuntimeErrorChangeState, NULL);
     else if (fFlags & VMSETRTERR_FLAGS_SUSPEND)
-        rc = VMR3Suspend(pVM->pUVM);
+        rc = VMR3Suspend(pUVM);
     else
         rc = VINF_SUCCESS;
@@ -3962 +3963 @@
      * Do the callback round.
      */
-    PUVM pUVM = pVM->pUVM;
     RTCritSectEnter(&pUVM->vm.s.AtErrorCritSect);
     ASMAtomicIncU32(&pUVM->vm.s.cRuntimeErrors);
@@ -3969 +3969 @@
         va_list va;
         va_copy(va, *pVa);
-        pCur->pfnAtRuntimeError(pVM, pCur->pvUser, fFlags, pszErrorId, pszFormat, va);
+        pCur->pfnAtRuntimeError(pUVM, pCur->pvUser, fFlags, pszErrorId, pszFormat, va);
         va_end(va);
     }

trunk/src/VBox/VMM/testcase/tstVMREQ.cpp

@@ -49 +49 @@
  * Testings va_list passing in VMSetRuntimeError.
  */
-static DECLCALLBACK(void) MyAtRuntimeError(PVM pVM, void *pvUser, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
-{
-    NOREF(pVM);
+static DECLCALLBACK(void) MyAtRuntimeError(PUVM pUVM, void *pvUser, uint32_t fFlags, const char *pszErrorId, const char *pszFormat, va_list va)
+{
+    NOREF(pUVM);
     if (strcmp((const char *)pvUser, "user argument"))
     {