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

Timestamp:

Jan 23, 2013 4:20:07 PM (12 years ago)

Author:

vboxsync

Message:

VMM,Main,Debugger,REM: VM API cleanup, prefering PUVM over PVM so we can use real reference counting and not have the memory backing the VM structure disappear on us.

Location:

trunk/src/VBox/Main

Files:

• idl/VirtualBox.xidl (modified) (1 diff)
• include/ConsoleImpl.h (modified) (8 diffs)
• src-client/ConsoleImpl.cpp (modified) (103 diffs)
• src-client/ConsoleImpl2.cpp (modified) (29 diffs)
• src-client/ConsoleImplTeleporter.cpp (modified) (4 diffs)
• src-client/DisplayImpl.cpp (modified) (19 diffs)
• src-client/MachineDebuggerImpl.cpp (modified) (4 diffs)

trunk/src/VBox/Main/idl/VirtualBox.xidl

@@ -15424 +15424 @@
     <attribute name="VM" type="long long" readonly="yes" wsmap="suppress">
       <desc>
-        Gets the VM handle. This is only for internal use while
-        we carve the details of this interface.
+        Gets the user-mode VM handle, with a reference.  Must be passed to
+        VMR3ReleaseUVM when done.  This is only for internal use while we carve
+        the details of this interface.
       </desc>
     </attribute>

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

@@ -544 +544 @@
                                bool fForceUnmount,
                                bool fHotplug,
-                               PVM pVM,
+                               PUVM pUVM,
                                DeviceType_T *paLedDevType);
     int configMedium(PCFGMNODE pLunL0,
@@ -560 +560 @@
                      HRESULT *phrc);
     static DECLCALLBACK(int) reconfigureMediumAttachment(Console *pConsole,
-                                                         PVM pVM,
+                                                         PUVM pUVM,
                                                          const char *pcszDevice,
                                                          unsigned uInstance,
@@ -573 +573 @@
                                                          HRESULT *phrc);
     static DECLCALLBACK(int) changeRemovableMedium(Console *pThis,
-                                                   PVM pVM,
+                                                   PUVM pUVM,
                                                    const char *pcszDevice,
                                                    unsigned uInstance,
@@ -592 +592 @@
                       bool fAttachDetach, bool fIgnoreConnectFailure);
 
-    static DECLCALLBACK(int) configGuestProperties(void *pvConsole, PVM pVM);
+    static DECLCALLBACK(int) configGuestProperties(void *pvConsole, PUVM pUVM);
     static DECLCALLBACK(int) configGuestControl(void *pvConsole);
     static DECLCALLBACK(void) vmstateChangeCallback(PVM aVM, VMSTATE aState,
@@ -598 +598 @@
     static DECLCALLBACK(int) unplugCpu(Console *pThis, PVM pVM, unsigned uCpu);
     static DECLCALLBACK(int) plugCpu(Console *pThis, PVM pVM, unsigned uCpu);
-    HRESULT doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PVM pVM);
+    HRESULT doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM);
     HRESULT doCPURemove(ULONG aCpu, PVM pVM);
     HRESULT doCPUAdd(ULONG aCpu, PVM pVM);
 
-    HRESULT doNetworkAdapterChange(PVM pVM, const char *pszDevice, unsigned uInstance,
+    HRESULT doNetworkAdapterChange(PUVM pUVM, const char *pszDevice, unsigned uInstance,
                                    unsigned uLun, INetworkAdapter *aNetworkAdapter);
-    static DECLCALLBACK(int) changeNetworkAttachment(Console *pThis, PVM pVM, const char *pszDevice,
+    static DECLCALLBACK(int) changeNetworkAttachment(Console *pThis, PUVM pUVM, const char *pszDevice,
                                                      unsigned uInstance, unsigned uLun,
                                                      INetworkAdapter *aNetworkAdapter);
@@ -615 +615 @@
     HRESULT detachUSBDevice(const ComObjPtr<OUSBDevice> &aHostDevice);
 
-    static DECLCALLBACK(int) usbAttachCallback(Console *that, PVM pVM, IUSBDevice *aHostDevice, PCRTUUID aUuid,
+    static DECLCALLBACK(int) usbAttachCallback(Console *that, PUVM pUVM, IUSBDevice *aHostDevice, PCRTUUID aUuid,
                        bool aRemote, const char *aAddress, void *pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs);
-    static DECLCALLBACK(int) usbDetachCallback(Console *that, PVM pVM, PCRTUUID aUuid);
+    static DECLCALLBACK(int) usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid);
 #endif
 
     static DECLCALLBACK(int) attachStorageDevice(Console *pThis,
-                                                 PVM pVM,
+                                                 PUVM pUVM,
                                                  const char *pcszDevice,
                                                  unsigned uInstance,
@@ -628 +628 @@
                                                  IMediumAttachment *aMediumAtt);
     static DECLCALLBACK(int) detachStorageDevice(Console *pThis,
-                                                 PVM pVM,
+                                                 PUVM pUVM,
                                                  const char *pcszDevice,
                                                  unsigned uInstance,
                                                  StorageBus_T enmBus,
                                                  IMediumAttachment *aMediumAtt);
-    HRESULT doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PVM pVM);
-    HRESULT doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PVM pVM);
+    HRESULT doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM);
+    HRESULT doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM);
 
     static DECLCALLBACK(int)    fntTakeSnapshotWorker(RTTHREAD Thread, void *pvUser);
@@ -648 +648 @@
                                                           const char *pszErrorId, const char *pszFormat, va_list va);
 
-    HRESULT                     captureUSBDevices(PVM pVM);
+    HRESULT                     captureUSBDevices(PUVM pUVM);
     void                        detachAllUSBDevices(bool aDone);
 

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

@@ -157 +157 @@
           mServerProgress(aServerProgress),
           mpVM(NULL),
+          mpUVM(NULL),
           mRC(E_FAIL),
           mpSafeVMPtr(NULL)
@@ -168 +169 @@
             mpSafeVMPtr = new Console::SafeVMPtr(aConsole);
             if (mpSafeVMPtr->isOk())
+            {
                 mpVM = mpSafeVMPtr->raw();
+                mpUVM = mpSafeVMPtr->rawUVM();
+            }
             else
                 mRC = mpSafeVMPtr->rc();
@@ -198 +202 @@
     const ComPtr<IProgress>     mServerProgress;
     PVM                         mpVM;
+    PUVM                        mpUVM;
 
 private:
@@ -2229 +2234 @@
     alock.release();
 
-    int vrc = VMR3Reset(ptrVM);
+    int vrc = VMR3Reset(ptrVM.rawUVM());
 
     HRESULT rc = RT_SUCCESS(vrc) ? S_OK :
@@ -2255 +2260 @@
 HRESULT Console::doCPURemove(ULONG aCpu, PVM pVM)
 {
+    PUVM pUVM = VMR3GetUVM(pVM);
     HRESULT rc = S_OK;
 
@@ -2297 +2303 @@
         /* Notify the guest if possible. */
         uint32_t idCpuCore, idCpuPackage;
-        vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(pVM, aCpu, &idCpuCore, &idCpuPackage); AssertRC(vrc);
+        vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(pUVM, aCpu, &idCpuCore, &idCpuPackage); AssertRC(vrc);
         if (RT_SUCCESS(vrc))
             vrc = pVmmDevPort->pfnCpuHotUnplug(pVmmDevPort, idCpuCore, idCpuPackage);
@@ -2329 +2335 @@
          */
         PVMREQ pReq;
-        vrc = VMR3ReqCall(pVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
-                          (PFNRT)Console::unplugCpu, 3,
-                          this, pVM, aCpu);
+        vrc = VMR3ReqCallU(pUVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
+                           (PFNRT)Console::unplugCpu, 3,
+                           this, pVM, aCpu);
         if (vrc == VERR_TIMEOUT || RT_SUCCESS(vrc))
         {
@@ -2344 +2350 @@
         {
             /* Detach it from the VM  */
-            vrc = VMR3HotUnplugCpu(pVM, aCpu);
+            vrc = VMR3HotUnplugCpu(pUVM, aCpu);
             AssertRC(vrc);
         }
@@ -2362 +2368 @@
 /*static*/ DECLCALLBACK(int) Console::plugCpu(Console *pThis, PVM pVM, unsigned uCpu)
 {
+    PUVM pUVM = VMR3GetUVM(pVM);
     LogFlowFunc(("pThis=%p uCpu=%u\n", pThis, uCpu));
 
     AssertReturn(pThis, VERR_INVALID_PARAMETER);
 
-    int rc = VMR3HotPlugCpu(pVM, uCpu);
+    int rc = VMR3HotPlugCpu(pUVM, uCpu);
     AssertRC(rc);
 
-    PCFGMNODE pInst = CFGMR3GetChild(CFGMR3GetRoot(pVM), "Devices/acpi/0/");
+    PCFGMNODE pInst = CFGMR3GetChild(CFGMR3GetRootU(pUVM), "Devices/acpi/0/");
     AssertRelease(pInst);
     /* nuke anything which might have been left behind. */
@@ -2399 +2406 @@
 HRESULT Console::doCPUAdd(ULONG aCpu, PVM pVM)
 {
+    PUVM pUVM = VMR3GetUVM(pVM);
     HRESULT rc = S_OK;
 
@@ -2435 +2443 @@
      */
     PVMREQ pReq;
-    int vrc = VMR3ReqCall(pVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
-                          (PFNRT)Console::plugCpu, 3,
-                          this, pVM, aCpu);
+    int vrc = VMR3ReqCallU(pUVM, 0, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
+                           (PFNRT)Console::plugCpu, 3,
+                           this, pVM, aCpu);
 
     /* release the lock before a VMR3* call (EMT will call us back)! */
@@ -2460 +2468 @@
         /* Notify the guest if possible. */
         uint32_t idCpuCore, idCpuPackage;
-        vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(pVM, aCpu, &idCpuCore, &idCpuPackage); AssertRC(vrc);
+        vrc = VMR3GetCpuCoreAndPackageIdFromCpuId(pUVM, aCpu, &idCpuCore, &idCpuPackage); AssertRC(vrc);
         if (RT_SUCCESS(vrc))
             vrc = pDevPort->pfnCpuHotPlug(pDevPort, idCpuCore, idCpuPackage);
@@ -2506 +2514 @@
     alock.release();
 
-    int vrc = VMR3Suspend(ptrVM);
+    int vrc = VMR3Suspend(ptrVM.rawUVM());
 
     HRESULT hrc = S_OK;
@@ -2548 +2556 @@
     if (RT_SUCCESS(vrc))
     {
-        if (VMR3GetState(ptrVM) == VMSTATE_CREATED)
-            vrc = VMR3PowerOn(ptrVM); /* (PowerUpPaused) */
+        if (VMR3GetStateU(ptrVM.rawUVM()) == VMSTATE_CREATED)
+            vrc = VMR3PowerOn(ptrVM.rawUVM()); /* (PowerUpPaused) */
         else
-            vrc = VMR3Resume(ptrVM);
+            vrc = VMR3Resume(ptrVM.rawUVM());
     }
 
@@ -2785 +2793 @@
         /* release the lock before a VMR3* call (EMT will call us back)! */
         alock.release();
-        int vrc = VMR3Suspend(ptrVM);
+        int vrc = VMR3Suspend(ptrVM.rawUVM());
         alock.acquire();
 
@@ -2893 +2901 @@
             {
                 alock.release();
-                VMR3Resume(ptrVM);
+                VMR3Resume(ptrVM.rawUVM());
                 alock.acquire();
             }
@@ -3660 +3668 @@
  * @param aMediumAttachment The medium attachment with the new medium state.
  * @param fForce            Force medium chance, if it is locked or not.
- * @param pVM               Safe VM handle.
+ * @param pUVM              Safe VM handle.
  *
  * @note Locks this object for writing.
  */
-HRESULT Console::doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PVM pVM)
+HRESULT Console::doMediumChange(IMediumAttachment *aMediumAttachment, bool fForce, PUVM pUVM)
 {
     AutoCaller autoCaller(this);
@@ -3728 +3736 @@
      */
     PVMREQ pReq;
-    int vrc = VMR3ReqCall(pVM,
-                          VMCPUID_ANY,
-                          &pReq,
-                          0 /* no wait! */,
-                          VMREQFLAGS_VBOX_STATUS,
-                          (PFNRT)Console::changeRemovableMedium,
-                          8,
-                          this,
-                          pVM,
-                          pszDevice,
-                          uInstance,
-                          enmBus,
-                          fUseHostIOCache,
-                          aMediumAttachment,
-                          fForce);
+    int vrc = VMR3ReqCallU(pUVM,
+                           VMCPUID_ANY,
+                           &pReq,
+                           0 /* no wait! */,
+                           VMREQFLAGS_VBOX_STATUS,
+                           (PFNRT)Console::changeRemovableMedium,
+                           8,
+                           this,
+                           pUVM,
+                           pszDevice,
+                           uInstance,
+                           enmBus,
+                           fUseHostIOCache,
+                           aMediumAttachment,
+                           fForce);
 
     /* release the lock before waiting for a result (EMT will call us back!) */
@@ -3778 +3786 @@
  *
  * @param   pThis           Pointer to the Console object.
- * @param   pVM             The VM handle.
+ * @param   pUVM            The VM handle.
  * @param   pcszDevice      The PDM device name.
  * @param   uInstance       The PDM device instance.
@@ -3793 +3801 @@
  */
 DECLCALLBACK(int) Console::changeRemovableMedium(Console *pConsole,
-                                                 PVM pVM,
+                                                 PUVM pUVM,
                                                  const char *pcszDevice,
                                                  unsigned uInstance,
@@ -3816 +3824 @@
      */
     bool fResume;
-    VMSTATE enmVMState = VMR3GetState(pVM);
+    VMSTATE enmVMState = VMR3GetStateU(pUVM);
     switch (enmVMState)
     {
@@ -3825 +3833 @@
             /* disable the callback to prevent Console-level state change */
             pConsole->mVMStateChangeCallbackDisabled = true;
-            int rc = VMR3Suspend(pVM);
+            int rc = VMR3Suspend(pUVM);
             pConsole->mVMStateChangeCallbackDisabled = false;
             AssertRCReturn(rc, rc);
@@ -3853 +3861 @@
     /* Determine the base path for the device instance. */
     PCFGMNODE pCtlInst;
-    pCtlInst = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/", pcszDevice, uInstance);
+    pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
     AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
 
@@ -3874 +3882 @@
                                              fForce /* fForceUnmount */,
                                              false  /* fHotplug */,
-                                             pVM,
+                                             pUVM,
                                              NULL /* paLedDevType */);
     /** @todo this dumps everything attached to this device instance, which
@@ -3888 +3896 @@
         /* disable the callback to prevent Console-level state change */
         pConsole->mVMStateChangeCallbackDisabled = true;
-        rc = VMR3Resume(pVM);
+        rc = VMR3Resume(pUVM);
         pConsole->mVMStateChangeCallbackDisabled = false;
         AssertRC(rc);
@@ -3894 +3902 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(pVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
+            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pConsole);
         }
         /// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
@@ -3914 +3922 @@
  *
  * @param aMediumAttachment The medium attachment which is added.
- * @param pVM               Safe VM handle.
+ * @param pUVM              Safe VM handle.
  *
  * @note Locks this object for writing.
  */
-HRESULT Console::doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PVM pVM)
+HRESULT Console::doStorageDeviceAttach(IMediumAttachment *aMediumAttachment, PUVM pUVM)
 {
     AutoCaller autoCaller(this);
@@ -3982 +3990 @@
      */
     PVMREQ pReq;
-    int vrc = VMR3ReqCall(pVM,
-                          VMCPUID_ANY,
-                          &pReq,
-                          0 /* no wait! */,
-                          VMREQFLAGS_VBOX_STATUS,
-                          (PFNRT)Console::attachStorageDevice,
-                          7,
-                          this,
-                          pVM,
-                          pszDevice,
-                          uInstance,
-                          enmBus,
-                          fUseHostIOCache,
-                          aMediumAttachment);
+    int vrc = VMR3ReqCallU(pUVM,
+                           VMCPUID_ANY,
+                           &pReq,
+                           0 /* no wait! */,
+                           VMREQFLAGS_VBOX_STATUS,
+                           (PFNRT)Console::attachStorageDevice,
+                           7,
+                           this,
+                           pUVM,
+                           pszDevice,
+                           uInstance,
+                           enmBus,
+                           fUseHostIOCache,
+                           aMediumAttachment);
 
     /* release the lock before waiting for a result (EMT will call us back!) */
@@ -4032 +4040 @@
  *
  * @param   pThis           Pointer to the Console object.
- * @param   pVM             The VM handle.
+ * @param   pUVM            The VM handle.
  * @param   pcszDevice      The PDM device name.
  * @param   uInstance       The PDM device instance.
@@ -4039 +4047 @@
  */
 DECLCALLBACK(int) Console::attachStorageDevice(Console *pConsole,
-                                               PVM pVM,
+                                               PUVM pUVM,
                                                const char *pcszDevice,
                                                unsigned uInstance,
@@ -4061 +4069 @@
      */
     bool fResume;
-    VMSTATE enmVMState = VMR3GetState(pVM);
+    VMSTATE enmVMState = VMR3GetStateU(pUVM);
     switch (enmVMState)
     {
@@ -4070 +4078 @@
             /* disable the callback to prevent Console-level state change */
             pConsole->mVMStateChangeCallbackDisabled = true;
-            int rc = VMR3Suspend(pVM);
+            int rc = VMR3Suspend(pUVM);
             pConsole->mVMStateChangeCallbackDisabled = false;
             AssertRCReturn(rc, rc);
@@ -4098 +4106 @@
     /* Determine the base path for the device instance. */
     PCFGMNODE pCtlInst;
-    pCtlInst = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/", pcszDevice, uInstance);
+    pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
     AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
 
@@ -4119 +4127 @@
                                              false /* fForceUnmount */,
                                              true   /* fHotplug */,
-                                             pVM,
+                                             pUVM,
                                              NULL /* paLedDevType */);
     /** @todo this dumps everything attached to this device instance, which
@@ -4133 +4141 @@
         /* disable the callback to prevent Console-level state change */
         pConsole->mVMStateChangeCallbackDisabled = true;
-        rc = VMR3Resume(pVM);
+        rc = VMR3Resume(pUVM);
         pConsole->mVMStateChangeCallbackDisabled = false;
         AssertRC(rc);
@@ -4139 +4147 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(pVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
+            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pConsole);
         }
         /** @todo: if we failed with drive mount, then the VMR3Resume
@@ -4159 +4167 @@
  *
  * @param aMediumAttachment The medium attachment which is added.
- * @param pVM               Safe VM handle.
+ * @param pUVM              Safe VM handle.
  *
  * @note Locks this object for writing.
  */
-HRESULT Console::doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PVM pVM)
+HRESULT Console::doStorageDeviceDetach(IMediumAttachment *aMediumAttachment, PUVM pUVM)
 {
     AutoCaller autoCaller(this);
@@ -4224 +4232 @@
      */
     PVMREQ pReq;
-    int vrc = VMR3ReqCall(pVM,
-                          VMCPUID_ANY,
-                          &pReq,
-                          0 /* no wait! */,
-                          VMREQFLAGS_VBOX_STATUS,
-                          (PFNRT)Console::detachStorageDevice,
-                          6,
-                          this,
-                          pVM,
-                          pszDevice,
-                          uInstance,
-                          enmBus,
-                          aMediumAttachment);
+    int vrc = VMR3ReqCallU(pUVM,
+                           VMCPUID_ANY,
+                           &pReq,
+                           0 /* no wait! */,
+                           VMREQFLAGS_VBOX_STATUS,
+                           (PFNRT)Console::detachStorageDevice,
+                           6,
+                           this,
+                           pUVM,
+                           pszDevice,
+                           uInstance,
+                           enmBus,
+                           aMediumAttachment);
 
     /* release the lock before waiting for a result (EMT will call us back!) */
@@ -4272 +4280 @@
  *
  * @param   pThis           Pointer to the Console object.
- * @param   pVM             The VM handle.
+ * @param   pUVM            The VM handle.
  * @param   pcszDevice      The PDM device name.
  * @param   uInstance       The PDM device instance.
@@ -4279 +4287 @@
  */
 DECLCALLBACK(int) Console::detachStorageDevice(Console *pConsole,
-                                               PVM pVM,
+                                               PUVM pUVM,
                                                const char *pcszDevice,
                                                unsigned uInstance,
@@ -4300 +4308 @@
      */
     bool fResume;
-    VMSTATE enmVMState = VMR3GetState(pVM);
+    VMSTATE enmVMState = VMR3GetStateU(pUVM);
     switch (enmVMState)
     {
@@ -4309 +4317 @@
             /* disable the callback to prevent Console-level state change */
             pConsole->mVMStateChangeCallbackDisabled = true;
-            int rc = VMR3Suspend(pVM);
+            int rc = VMR3Suspend(pUVM);
             pConsole->mVMStateChangeCallbackDisabled = false;
             AssertRCReturn(rc, rc);
@@ -4337 +4345 @@
     /* Determine the base path for the device instance. */
     PCFGMNODE pCtlInst;
-    pCtlInst = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/", pcszDevice, uInstance);
+    pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
     AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
 
@@ -4363 +4371 @@
     if (pLunL0)
     {
-        rc = PDMR3DeviceDetach(pVM, pcszDevice, uInstance, uLUN, 0);
+        rc = PDMR3DeviceDetach(VMR3GetVM(pUVM), pcszDevice, uInstance, uLUN, 0);
         if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
             rc = VINF_SUCCESS;
@@ -4386 +4394 @@
         /* disable the callback to prevent Console-level state change */
         pConsole->mVMStateChangeCallbackDisabled = true;
-        rc = VMR3Resume(pVM);
+        rc = VMR3Resume(pUVM);
         pConsole->mVMStateChangeCallbackDisabled = false;
         AssertRC(rc);
@@ -4392 +4400 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(pVM, VMSTATE_SUSPENDED, enmVMState, pConsole);
+            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pConsole);
         }
         /** @todo: if we failed with drive mount, then the VMR3Resume
@@ -4474 +4482 @@
                     if (RT_SUCCESS(vrc) && changeAdapter)
                     {
-                        VMSTATE enmVMState = VMR3GetState(ptrVM);
+                        VMSTATE enmVMState = VMR3GetStateU(ptrVM.rawUVM());
                         if (    enmVMState == VMSTATE_RUNNING    /** @todo LiveMigration: Forbid or deal correctly with the _LS variants */
                             ||  enmVMState == VMSTATE_SUSPENDED)
@@ -4484 +4492 @@
                             }
 
-                            rc = doNetworkAdapterChange(ptrVM, pszAdapterName, ulInstance, 0, aNetworkAdapter);
+                            rc = doNetworkAdapterChange(ptrVM.rawUVM(), pszAdapterName, ulInstance, 0, aNetworkAdapter);
 
                             if (fTraceEnabled && fCableConnected && pINetCfg)
@@ -4615 +4623 @@
  * @returns COM status code.
  *
- * @parma   pVM                 The VM handle (caller hold this safely).
+ * @parma   pUVM                The VM handle (caller hold this safely).
  * @param   pszDevice           The PDM device name.
  * @param   uInstance           The PDM device instance.
@@ -4621 +4629 @@
  * @param   aNetworkAdapter     The network adapter whose attachment needs to be changed
  */
-HRESULT Console::doNetworkAdapterChange(PVM pVM,
+HRESULT Console::doNetworkAdapterChange(PUVM pUVM,
                                         const char *pszDevice,
                                         unsigned uInstance,
@@ -4632 +4640 @@
     AutoCaller autoCaller(this);
     AssertComRCReturnRC(autoCaller.rc());
-
-    /* Get the VM handle. */
-    SafeVMPtr ptrVM(this);
-    if (!ptrVM.isOk())
-        return ptrVM.rc();
 
     /*
@@ -4644 +4647 @@
      */
     PVMREQ pReq;
-    int vrc = VMR3ReqCall(pVM, 0 /*idDstCpu*/, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
-                          (PFNRT) Console::changeNetworkAttachment, 6,
-                          this, ptrVM.raw(), pszDevice, uInstance, uLun, aNetworkAdapter);
+    int vrc = VMR3ReqCallU(pUVM, 0 /*idDstCpu*/, &pReq, 0 /* no wait! */, VMREQFLAGS_VBOX_STATUS,
+                           (PFNRT)Console::changeNetworkAttachment, 6,
+                           this, pUVM, pszDevice, uInstance, uLun, aNetworkAdapter);
 
     if (vrc == VERR_TIMEOUT || RT_SUCCESS(vrc))
@@ -4675 +4678 @@
  *
  * @param   pThis               Pointer to the Console object.
- * @param   pVM                 The VM handle.
+ * @param   pUVM                The VM handle.
  * @param   pszDevice           The PDM device name.
  * @param   uInstance           The PDM device instance.
@@ -4685 +4688 @@
  */
 DECLCALLBACK(int) Console::changeNetworkAttachment(Console *pThis,
-                                                   PVM pVM,
+                                                   PUVM pUVM,
                                                    const char *pszDevice,
                                                    unsigned uInstance,
@@ -4724 +4727 @@
      */
     bool fResume;
-    VMSTATE enmVMState = VMR3GetState(pVM);
+    VMSTATE enmVMState = VMR3GetStateU(pUVM);
     switch (enmVMState)
     {
@@ -4733 +4736 @@
             /* disable the callback to prevent Console-level state change */
             pThis->mVMStateChangeCallbackDisabled = true;
-            int rc = VMR3Suspend(pVM);
+            int rc = VMR3Suspend(pUVM);
             pThis->mVMStateChangeCallbackDisabled = false;
             AssertRCReturn(rc, rc);
@@ -4755 +4758 @@
     PCFGMNODE pCfg = NULL;          /* /Devices/Dev/.../Config/ */
     PCFGMNODE pLunL0 = NULL;        /* /Devices/Dev/0/LUN#0/ */
-    PCFGMNODE pInst = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%d/", pszDevice, uInstance);
+    PCFGMNODE pInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%d/", pszDevice, uInstance);
     AssertRelease(pInst);
 
@@ -4769 +4772 @@
         /* disable the callback to prevent Console-level state change */
         pThis->mVMStateChangeCallbackDisabled = true;
-        rc = VMR3Resume(pVM);
+        rc = VMR3Resume(pUVM);
         pThis->mVMStateChangeCallbackDisabled = false;
         AssertRC(rc);
@@ -4775 +4778 @@
         {
             /* too bad, we failed. try to sync the console state with the VMM state */
-            vmstateChangeCallback(pVM, VMSTATE_SUSPENDED, enmVMState, pThis);
+            vmstateChangeCallback(VMR3GetVM(pUVM), VMSTATE_SUSPENDED, enmVMState, pThis);
         }
         /// @todo (r=dmik) if we failed with drive mount, then the VMR3Resume
@@ -4855 +4858 @@
     if (ptrVM.isOk())
     {
-        rc = doMediumChange(aMediumAttachment, !!aForce, ptrVM);
+        rc = doMediumChange(aMediumAttachment, !!aForce, ptrVM.rawUVM());
         ptrVM.release();
     }
@@ -4926 +4929 @@
         {
             /* No need to call in the EMT thread. */
-            rc = VMR3SetCpuExecutionCap(ptrVM, aExecutionCap);
+            rc = VMR3SetCpuExecutionCap(ptrVM.rawUVM(), aExecutionCap);
         }
         else
@@ -5389 +5392 @@
     {
         if (aRemove)
-            rc = doStorageDeviceDetach(aMediumAttachment, ptrVM);
+            rc = doStorageDeviceDetach(aMediumAttachment, ptrVM.rawUVM());
         else
-            rc = doStorageDeviceAttach(aMediumAttachment, ptrVM);
+            rc = doStorageDeviceAttach(aMediumAttachment, ptrVM.rawUVM());
         ptrVM.release();
     }
@@ -5712 +5715 @@
 
     /* Pause the VM, as it might have pending IO on this drive */
-    VMSTATE enmVMState = VMR3GetState(ptrVM);
+    VMSTATE enmVMState = VMR3GetStateU(ptrVM.rawUVM());
     if (mMachineState == MachineState_DeletingSnapshotOnline)
     {
@@ -5718 +5721 @@
         /* disable the callback to prevent Console-level state change */
         mVMStateChangeCallbackDisabled = true;
-        int vrc2 = VMR3Suspend(ptrVM);
+        int vrc2 = VMR3Suspend(ptrVM.rawUVM());
         mVMStateChangeCallbackDisabled = false;
         AssertRCReturn(vrc2, E_FAIL);
     }
 
-    vrc = VMR3ReqCallWait(ptrVM,
-                          VMCPUID_ANY,
-                          (PFNRT)reconfigureMediumAttachment,
-                          13,
-                          this,
-                          ptrVM.raw(),
-                          pcszDevice,
-                          uInstance,
-                          enmBus,
-                          fUseHostIOCache,
-                          fBuiltinIOCache,
-                          true /* fSetupMerge */,
-                          aSourceIdx,
-                          aTargetIdx,
-                          aMediumAttachment,
-                          mMachineState,
-                          &rc);
+    vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
+                           VMCPUID_ANY,
+                           (PFNRT)reconfigureMediumAttachment,
+                           13,
+                           this,
+                           ptrVM.rawUVM(),
+                           pcszDevice,
+                           uInstance,
+                           enmBus,
+                           fUseHostIOCache,
+                           fBuiltinIOCache,
+                           true /* fSetupMerge */,
+                           aSourceIdx,
+                           aTargetIdx,
+                           aMediumAttachment,
+                           mMachineState,
+                           &rc);
     /* error handling is after resuming the VM */
 
@@ -5747 +5750 @@
         /* disable the callback to prevent Console-level state change */
         mVMStateChangeCallbackDisabled = true;
-        int vrc2 = VMR3Resume(ptrVM);
+        int vrc2 = VMR3Resume(ptrVM.rawUVM());
         mVMStateChangeCallbackDisabled = false;
         if (RT_FAILURE(vrc2))
@@ -5783 +5786 @@
 
     /* Pause the VM, as it might have pending IO on this drive */
-    enmVMState = VMR3GetState(ptrVM);
+    enmVMState = VMR3GetStateU(ptrVM.rawUVM());
     if (mMachineState == MachineState_DeletingSnapshotOnline)
     {
@@ -5789 +5792 @@
         /* disable the callback to prevent Console-level state change */
         mVMStateChangeCallbackDisabled = true;
-        int vrc2 = VMR3Suspend(ptrVM);
+        int vrc2 = VMR3Suspend(ptrVM.rawUVM());
         mVMStateChangeCallbackDisabled = false;
         AssertRCReturn(vrc2, E_FAIL);
@@ -5799 +5802 @@
                                            ComSafeArrayInArg(aChildrenToReparent));
 
-    vrc = VMR3ReqCallWait(ptrVM,
-                          VMCPUID_ANY,
-                          (PFNRT)reconfigureMediumAttachment,
-                          13,
-                          this,
-                          ptrVM.raw(),
-                          pcszDevice,
-                          uInstance,
-                          enmBus,
-                          fUseHostIOCache,
-                          fBuiltinIOCache,
-                          false /* fSetupMerge */,
-                          0 /* uMergeSource */,
-                          0 /* uMergeTarget */,
-                          aMediumAttachment,
-                          mMachineState,
-                          &rc);
+    vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
+                           VMCPUID_ANY,
+                           (PFNRT)reconfigureMediumAttachment,
+                           13,
+                           this,
+                           ptrVM.rawUVM(),
+                           pcszDevice,
+                           uInstance,
+                           enmBus,
+                           fUseHostIOCache,
+                           fBuiltinIOCache,
+                           false /* fSetupMerge */,
+                           0 /* uMergeSource */,
+                           0 /* uMergeTarget */,
+                           aMediumAttachment,
+                           mMachineState,
+                           &rc);
     /* error handling is after resuming the VM */
 
@@ -5823 +5826 @@
         /* disable the callback to prevent Console-level state change */
         mVMStateChangeCallbackDisabled = true;
-        int vrc2 = VMR3Resume(ptrVM);
+        int vrc2 = VMR3Resume(ptrVM.rawUVM());
         mVMStateChangeCallbackDisabled = false;
         AssertRC(vrc2);
@@ -6198 +6201 @@
         return a_Quiet
             ? E_ACCESSDENIED
-            : setError(E_ACCESSDENIED, tr("The virtual machine is was powered off"));
+            : setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
 
     /*
@@ -6207 +6210 @@
         return a_Quiet
             ? E_ACCESSDENIED
-            : setError(E_ACCESSDENIED, tr("The virtual machine is was powered off"));
+            : setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
 
     PVM pVM = VMR3GetVM(pUVM);
@@ -6215 +6218 @@
         return a_Quiet
             ? E_ACCESSDENIED
-            : setError(E_ACCESSDENIED, tr("The virtual machine is was powered off"));
+            : setError(E_ACCESSDENIED, tr("The virtual machine is powered off"));
     }
 
@@ -6936 +6939 @@
         LogFlowThisFunc(("Powering off the VM...\n"));
         alock.release();
-        vrc = VMR3PowerOff(VMR3GetVM(pUVM));
+        vrc = VMR3PowerOff(pUVM);
 #ifdef VBOX_WITH_EXTPACK
         mptrExtPackManager->callAllVmPowerOffHooks(this, VMR3GetVM(pUVM));
@@ -7004 +7007 @@
         alock.release();
 
-        vrc = VMR3Destroy(VMR3GetVM(pUVM));
+        vrc = VMR3Destroy(pUVM);
 
         /* take the lock again */
@@ -7958 +7961 @@
     Assert(portVersion == 1 || portVersion == 2);
 
-    int vrc = VMR3ReqCallWait(ptrVM, 0 /* idDstCpu (saved state, see #6232) */,
-                              (PFNRT)usbAttachCallback, 9,
-                              this, ptrVM.raw(), aHostDevice, uuid.raw(), fRemote, Address.c_str(), pvRemoteBackend, portVersion, aMaskedIfs);
+    int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
+                               (PFNRT)usbAttachCallback, 9,
+                               this, ptrVM.rawUVM(), aHostDevice, uuid.raw(), fRemote,
+                               Address.c_str(), pvRemoteBackend, portVersion, aMaskedIfs);
 
     if (RT_SUCCESS(vrc))
@@ -7986 +7990 @@
         {
             case VERR_VUSB_NO_PORTS:
-                hrc = setError(E_FAIL,
-                    tr("Failed to attach the USB device. (No available ports on the USB controller)."));
+                hrc = setError(E_FAIL, tr("Failed to attach the USB device. (No available ports on the USB controller)."));
                 break;
             case VERR_VUSB_USBFS_PERMISSION:
-                hrc = setError(E_FAIL,
-                    tr("Not permitted to open the USB device, check usbfs options"));
+                hrc = setError(E_FAIL, tr("Not permitted to open the USB device, check usbfs options"));
                 break;
             default:
-                hrc = setError(E_FAIL,
-                    tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"),
-                    vrc);
+                hrc = setError(E_FAIL, tr("Failed to create a proxy device for the USB device. (Error: %Rrc)"), vrc);
                 break;
         }
@@ -8015 +8015 @@
 //static
 DECLCALLBACK(int)
-Console::usbAttachCallback(Console *that, PVM pVM, IUSBDevice *aHostDevice, PCRTUUID aUuid, bool aRemote, const char *aAddress, void *pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs)
+Console::usbAttachCallback(Console *that, PUVM pUVM, IUSBDevice *aHostDevice, PCRTUUID aUuid, bool aRemote,
+                           const char *aAddress, void *pvRemoteBackend, USHORT aPortVersion, ULONG aMaskedIfs)
 {
     LogFlowFuncEnter();
@@ -8023 +8024 @@
     AssertReturn(!that->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
 
-    int vrc = PDMR3USBCreateProxyDevice(pVM, aUuid, aRemote, aAddress, pvRemoteBackend,
+    int vrc = PDMR3USBCreateProxyDevice(VMR3GetVM(pUVM), aUuid, aRemote, aAddress, pvRemoteBackend,
                                         aPortVersion == 1 ? VUSB_STDVER_11 : VUSB_STDVER_20, aMaskedIfs);
     LogFlowFunc(("vrc=%Rrc\n", vrc));
@@ -8073 +8074 @@
 
     alock.release();
-    int vrc = VMR3ReqCallWait(ptrVM, 0 /* idDstCpu (saved state, see #6232) */,
-                              (PFNRT)usbDetachCallback, 5,
-                              this, ptrVM.raw(), pUuid);
+    int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), 0 /* idDstCpu (saved state, see #6232) */,
+                               (PFNRT)usbDetachCallback, 5,
+                               this, ptrVM.rawUVM(), pUuid);
     if (RT_SUCCESS(vrc))
     {
@@ -8091 +8092 @@
 /**
  * USB device detach callback used by DetachUSBDevice().
+ *
  * Note that DetachUSBDevice() doesn't return until this callback is executed,
  * so we don't use AutoCaller and don't care about reference counters of
@@ -8099 +8101 @@
 //static
 DECLCALLBACK(int)
-Console::usbDetachCallback(Console *that, PVM pVM, PCRTUUID aUuid)
+Console::usbDetachCallback(Console *that, PUVM pUVM, PCRTUUID aUuid)
 {
     LogFlowFuncEnter();
@@ -8107 +8109 @@
     AssertReturn(!that->isWriteLockOnCurrentThread(), VERR_GENERAL_FAILURE);
 
-    int vrc = PDMR3USBDetachDevice(pVM, aUuid);
+    int vrc = PDMR3USBDetachDevice(VMR3GetVM(pUVM), aUuid);
 
     LogFlowFunc(("vrc=%Rrc\n", vrc));
@@ -8493 +8495 @@
  * Called at VM startup.
  *
- * @param   pVM     The VM handle.
+ * @param   pUVM    The VM handle.
  */
-HRESULT Console::captureUSBDevices(PVM pVM)
+HRESULT Console::captureUSBDevices(PUVM pUVM)
 {
     LogFlowThisFunc(("\n"));
@@ -8506 +8508 @@
      * capture devices */
     PPDMIBASE pBase;
-    int vrc = PDMR3QueryLun(pVM, "usb-ohci", 0, 0, &pBase);
+    int vrc = PDMR3QueryLun(VMR3GetVM(pUVM), "usb-ohci", 0, 0, &pBase);
     if (RT_SUCCESS(vrc))
     {
@@ -8871 +8873 @@
         /*
          * Create the VM
-         */
-        PVM pVM;
-        /*
-         * release the lock since EMT will call Console. It's safe because
-         * mMachineState is either Starting or Restoring state here.
+         *
+         * Note! Release the lock since EMT will call Console. It's safe because
+         *       mMachineState is either Starting or Restoring state here.
          */
         alock.release();
 
+        PVM pVM;
         vrc = VMR3Create(cCpus,
                          pConsole->mpVmm2UserMethods,
@@ -8885 +8886 @@
                          task->mConfigConstructor,
                          static_cast<Console *>(pConsole),
-                         &pVM);
+                         &pVM, NULL);
 
         alock.acquire();
@@ -8955 +8956 @@
                  * Capture USB devices.
                  */
-                rc = pConsole->captureUSBDevices(pVM);
-                if (FAILED(rc)) break;
+                rc = pConsole->captureUSBDevices(pConsole->mpUVM);
+                if (FAILED(rc))
+                    break;
 
                 /* Load saved state? */
@@ -8964 +8966 @@
                                  task->mSavedStateFile.c_str()));
 
-                    vrc = VMR3LoadFromFile(pVM,
+                    vrc = VMR3LoadFromFile(pConsole->mpUVM,
                                            task->mSavedStateFile.c_str(),
                                            Console::stateProgressCallback,
@@ -8981 +8983 @@
 #endif
                             if (RT_SUCCESS(vrc))
-                                vrc = VMR3Resume(pVM);
+                                vrc = VMR3Resume(pConsole->mpUVM);
                             AssertLogRelRC(vrc);
                         }
@@ -8989 +8991 @@
                     if (RT_FAILURE(vrc))
                     {
-                        int vrc2 = VMR3PowerOff(pVM); AssertLogRelRC(vrc2);
+                        int vrc2 = VMR3PowerOff(pConsole->mpUVM); AssertLogRelRC(vrc2);
 #ifdef VBOX_WITH_EXTPACK
                         pConsole->mptrExtPackManager->callAllVmPowerOffHooks(pConsole, pVM);
@@ -8999 +9001 @@
                     /* -> ConsoleImplTeleporter.cpp */
                     bool fPowerOffOnFailure;
-                    rc = pConsole->teleporterTrg(VMR3GetUVM(pVM), pMachine, &task->mErrorMsg, task->mStartPaused,
+                    rc = pConsole->teleporterTrg(pConsole->mpUVM, pMachine, &task->mErrorMsg, task->mStartPaused,
                                                  task->mProgress, &fPowerOffOnFailure);
                     if (FAILED(rc) && fPowerOffOnFailure)
                     {
                         ErrorInfoKeeper eik;
-                        int vrc2 = VMR3PowerOff(pVM); AssertLogRelRC(vrc2);
+                        int vrc2 = VMR3PowerOff(pConsole->mpUVM); AssertLogRelRC(vrc2);
 #ifdef VBOX_WITH_EXTPACK
                         pConsole->mptrExtPackManager->callAllVmPowerOffHooks(pConsole, pVM);
@@ -9065 +9067 @@
 #endif
                     if (RT_SUCCESS(vrc))
-                        vrc = VMR3PowerOn(pVM);
+                        vrc = VMR3PowerOn(pConsole->mpUVM);
                     AssertLogRelRC(vrc);
                 }
@@ -9095 +9097 @@
                  */
                 alock.release();
-                VMR3AtErrorDeregister(pVM, Console::genericVMSetErrorCallback, &task->mErrorMsg);
+                VMR3AtErrorDeregister(pConsole->mpUVM, Console::genericVMSetErrorCallback, &task->mErrorMsg);
                 /** @todo register another VMSetError callback? */
                 alock.acquire();
@@ -9196 +9198 @@
  *
  * @param   pConsole      Reference to the console object.
- * @param   pVM           The VM handle.
+ * @param   pUVM          The VM handle.
  * @param   lInstance     The instance of the controller.
  * @param   pcszDevice    The name of the controller type.
@@ -9210 +9212 @@
 /* static */
 DECLCALLBACK(int) Console::reconfigureMediumAttachment(Console *pConsole,
-                                                       PVM pVM,
+                                                       PUVM pUVM,
                                                        const char *pcszDevice,
                                                        unsigned uInstance,
@@ -9223 +9225 @@
                                                        HRESULT *phrc)
 {
-    LogFlowFunc(("pVM=%p aMediumAtt=%p phrc=%p\n", pVM, aMediumAtt, phrc));
+    LogFlowFunc(("pUVM=%p aMediumAtt=%p phrc=%p\n", pUVM, aMediumAtt, phrc));
 
     int             rc;
@@ -9241 +9243 @@
     /* Determine the base path for the device instance. */
     PCFGMNODE pCtlInst;
-    pCtlInst = CFGMR3GetChildF(CFGMR3GetRoot(pVM), "Devices/%s/%u/", pcszDevice, uInstance);
+    pCtlInst = CFGMR3GetChildF(CFGMR3GetRootU(pUVM), "Devices/%s/%u/", pcszDevice, uInstance);
     AssertReturn(pCtlInst, VERR_INTERNAL_ERROR);
 
@@ -9260 +9262 @@
                                           false /* fForceUnmount */,
                                           false /* fHotplug */,
-                                          pVM,
+                                          pUVM,
                                           NULL /* paLedDevType */);
     /** @todo this dumps everything attached to this device instance, which
@@ -9368 +9370 @@
                 alock.release();
                 LogFlowFunc(("VMR3Save...\n"));
-                vrc = VMR3Save(ptrVM,
+                vrc = VMR3Save(ptrVM.rawUVM(),
                                strSavedStateFile.c_str(),
                                true /*fContinueAfterwards*/,
@@ -9449 +9451 @@
                  * isn't going to need the Console lock.
                  */
-                vrc = VMR3ReqCallWait(ptrVM,
-                                      VMCPUID_ANY,
-                                      (PFNRT)reconfigureMediumAttachment,
-                                      13,
-                                      that,
-                                      ptrVM.raw(),
-                                      pcszDevice,
-                                      lInstance,
-                                      enmBus,
-                                      fUseHostIOCache,
-                                      fBuiltinIOCache,
-                                      false /* fSetupMerge */,
-                                      0 /* uMergeSource */,
-                                      0 /* uMergeTarget */,
-                                      atts[i],
-                                      that->mMachineState,
-                                      &rc);
+                vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(),
+                                       VMCPUID_ANY,
+                                       (PFNRT)reconfigureMediumAttachment,
+                                       13,
+                                       that,
+                                       ptrVM.rawUVM(),
+                                       pcszDevice,
+                                       lInstance,
+                                       enmBus,
+                                       fUseHostIOCache,
+                                       fBuiltinIOCache,
+                                       false /* fSetupMerge */,
+                                       0 /* uMergeSource */,
+                                       0 /* uMergeTarget */,
+                                       atts[i],
+                                       that->mMachineState,
+                                       &rc);
                 if (RT_FAILURE(vrc))
                     throw setErrorStatic(E_FAIL, Console::tr("%Rrc"), vrc);
@@ -9522 +9524 @@
                 SafeVMPtr ptrVM(that);
                 alock.release();
-                int vrc = VMR3Resume(ptrVM);
+                int vrc = VMR3Resume(ptrVM.rawUVM());
                 alock.acquire();
                 if (RT_FAILURE(vrc))
@@ -9580 +9582 @@
                         SafeVMPtr ptrVM(that);
                         alock.release();
-                        int vrc = VMR3Resume(ptrVM); AssertLogRelRC(vrc);
+                        int vrc = VMR3Resume(ptrVM.rawUVM()); AssertLogRelRC(vrc);
                         alock.acquire();
                         if (RT_FAILURE(vrc))
@@ -9640 +9642 @@
 
     bool fSuspenededBySave;
-    int vrc = VMR3Save(task->mpVM,
+    int vrc = VMR3Save(task->mpUVM,
                        task->mSavedStateFile.c_str(),
                        false, /*fContinueAfterwards*/

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

@@ -707 +707 @@
 int Console::configConstructorInner(PVM pVM, AutoWriteLock *pAlock)
 {
-    VMMDev *pVMMDev = m_pVMMDev;
-    Assert(pVMMDev);
-
+    PUVM            pUVM      = VMR3GetUVM(pVM);
+    VMMDev         *pVMMDev   = m_pVMMDev; Assert(pVMMDev);
     ComPtr<IMachine> pMachine = machine();
 
@@ -1795 +1794 @@
                                             false /* fForceUnmount */,
                                             false /* fHotplug */,
-                                            pVM,
+                                            pUVM,
                                             paLedDevType);
                 if (RT_FAILURE(rc))
@@ -2659 +2658 @@
          */
 
-        rc = configGuestProperties(this, pVM);
+        rc = configGuestProperties(this, pUVM);
 #endif /* VBOX_WITH_GUEST_PROPS defined */
 
@@ -2835 +2834 @@
      * Register VM state change handler.
      */
-    int rc2 = VMR3AtStateRegister(pVM, Console::vmstateChangeCallback, this);
+    int rc2 = VMR3AtStateRegister(pUVM, Console::vmstateChangeCallback, this);
     AssertRC(rc2);
     if (RT_SUCCESS(rc))
@@ -2843 +2842 @@
      * Register VM runtime error handler.
      */
-    rc2 = VMR3AtRuntimeErrorRegister(pVM, Console::setVMRuntimeErrorCallback, this);
+    rc2 = VMR3AtRuntimeErrorRegister(pUVM, Console::setVMRuntimeErrorCallback, this);
     AssertRC(rc2);
     if (RT_SUCCESS(rc))
@@ -3120 +3119 @@
                                     bool fForceUnmount,
                                     bool fHotplug,
-                                    PVM pVM,
+                                    PUVM pUVM,
                                     DeviceType_T *paLedDevType)
 {
@@ -3158 +3157 @@
                     /* Unmount existing media only for floppy and DVD drives. */
                     PPDMIBASE pBase;
-                    rc = PDMR3QueryLun(pVM, pcszDevice, uInstance, uLUN, &pBase);
+                    rc = PDMR3QueryLun(VMR3GetVM(pUVM), pcszDevice, uInstance, uLUN, &pBase);
                     if (RT_FAILURE(rc))
                     {
@@ -3180 +3179 @@
                 }
 
-                rc = PDMR3DeviceDetach(pVM, pcszDevice, uInstance, uLUN, fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
+                rc = PDMR3DeviceDetach(VMR3GetVM(pUVM), pcszDevice, uInstance, uLUN, fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG);
                 if (rc == VERR_PDM_NO_DRIVER_ATTACHED_TO_LUN)
                     rc = VINF_SUCCESS;
@@ -3284 +3283 @@
                     const char *pszUnit;
                     uint64_t u64Print = formatDiskSize((uint64_t)i64Size, &pszUnit);
-                    setVMRuntimeErrorCallbackF(pVM, this, 0,
+                    setVMRuntimeErrorCallbackF(VMR3GetVM(pUVM), this, 0,
                             "FatPartitionDetected",
                             N_("The medium '%ls' has a logical size of %RU64%s "
@@ -3316 +3315 @@
                             uint64_t u64PrintSiz = formatDiskSize((LONG64)i64Size, &pszUnitSiz);
                             uint64_t u64PrintMax = formatDiskSize(maxSize, &pszUnitMax);
-                            setVMRuntimeErrorCallbackF(pVM, this, 0,
+                            setVMRuntimeErrorCallbackF(VMR3GetVM(pUVM), this, 0,
                                     "FatPartitionDetected", /* <= not exact but ... */
                                     N_("The medium '%ls' has a logical size of %RU64%s "
@@ -3340 +3339 @@
                     const char *pszUnit;
                     uint64_t u64Print = formatDiskSize(i64Size, &pszUnit);
-                    setVMRuntimeErrorCallbackF(pVM, this, 0,
+                    setVMRuntimeErrorCallbackF(VMR3GetVM(pUVM), this, 0,
                             "FatPartitionDetected",
 #ifdef RT_OS_WINDOWS
@@ -3382 +3381 @@
                         || enmFsTypeFile == RTFSTYPE_XFS)
                     {
-                        setVMRuntimeErrorCallbackF(pVM, this, 0,
+                        setVMRuntimeErrorCallbackF(VMR3GetVM(pUVM), this, 0,
                                 "Ext4PartitionDetected",
                                 N_("The host I/O cache for at least one controller is disabled "
@@ -3400 +3399 @@
                              && !mfSnapshotFolderExt4WarningShown)
                     {
-                        setVMRuntimeErrorCallbackF(pVM, this, 0,
+                        setVMRuntimeErrorCallbackF(VMR3GetVM(pUVM), this, 0,
                                 "Ext4PartitionDetected",
                                 N_("The host I/O cache for at least one controller is disabled "
@@ -3475 +3474 @@
         {
             /* Attach the new driver. */
-            rc = PDMR3DeviceAttach(pVM, pcszDevice, uInstance, uLUN,
-                                fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /*ppBase*/);
+            rc = PDMR3DeviceAttach(VMR3GetVM(pUVM), pcszDevice, uInstance, uLUN,
+                                   fHotplug ? 0 : PDM_TACH_FLAGS_NOT_HOT_PLUG, NULL /*ppBase*/);
             AssertRCReturn(rc, rc);
 
@@ -3849 +3848 @@
         AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-        PVM pVM = VMR3GetVM(mpUVM);     /* We're on an EMT, so this is safe. */
-
         ComPtr<IMachine> pMachine = machine();
 
@@ -3875 +3872 @@
         if (fAttachDetach)
         {
-            rc = PDMR3DeviceDetach(pVM, pszDevice, uInstance, uLun, 0 /*fFlags*/);
+            rc = PDMR3DeviceDetach(VMR3GetVM(mpUVM), pszDevice, uInstance, uLun, 0 /*fFlags*/);
             if (rc == VINF_PDM_NO_DRIVER_ATTACHED_TO_LUN)
                 rc = VINF_SUCCESS;
@@ -4081 +4078 @@
                     {
                         case VERR_ACCESS_DENIED:
-                            return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,  N_(
+                            return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,  N_(
                                             "Failed to open '/dev/net/tun' for read/write access. Please check the "
                                             "permissions of that node. Either run 'chmod 0666 /dev/net/tun' or "
@@ -4089 +4086 @@
                         default:
                             AssertMsgFailed(("Could not attach to host interface! Bad!\n"));
-                            return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
+                            return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
                                             "Failed to initialize Host Interface Networking"));
                     }
@@ -4132 +4129 @@
 //                     * hrc = aNetworkAdapter->Detach();                                   H();
 //                     */
-//                     return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
+//                     return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
 //                                       N_("Malformed host interface networking name '%ls'"),
 //                                       BridgedIfName.raw());
@@ -4168 +4165 @@
                 {
                     AssertLogRelMsgFailed(("NetworkAttachmentType_Bridged: FindByName failed, rc=%Rhrc (0x%x)", hrc, hrc));
-                    return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
+                    return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
                                       N_("Nonexistent host networking interface, name '%ls'"),
                                       BridgedIfName.raw());
@@ -4183 +4180 @@
                 if (eIfType != HostNetworkInterfaceType_Bridged)
                 {
-                    return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
+                    return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
                                       N_("Interface ('%ls') is not a Bridged Adapter interface"),
                                       BridgedIfName.raw());
@@ -4280 +4277 @@
                         {
                             case VERR_ACCESS_DENIED:
-                                return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,  N_(
+                                return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS,  N_(
                                                 "Failed to open '/dev/%s' for read/write access.  Please check the "
                                                 "permissions of that node, and that the net.link.tap.user_open "
@@ -4288 +4285 @@
                             default:
                                 AssertMsgFailed(("Could not attach to tap interface! Bad!\n"));
-                                return VMSetError(pVM, VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
+                                return VMSetError(VMR3GetVM(mpUVM), VERR_HOSTIF_INIT_FAILED, RT_SRC_POS, N_(
                                                 "Failed to initialize Host Interface Networking"));
                         }
@@ -4316 +4313 @@
                         if (ioctl(iSock, SIOCGIFFLAGS, &Req) >= 0)
                             if ((Req.ifr_flags & IFF_UP) == 0)
-                                setVMRuntimeErrorCallbackF(pVM, this, 0, "BridgedInterfaceDown",
+                                setVMRuntimeErrorCallbackF(VMR3GetVM(mpUVM), this, 0, "BridgedInterfaceDown",
                                                            "Bridged interface %s is down. Guest will not be able to use this interface",
                                                            pszBridgedIfName);
@@ -4539 +4536 @@
                 {
                     LogRel(("NetworkAttachmentType_HostOnly: FindByName failed, rc (0x%x)\n", rc));
-                    return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
+                    return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
                                       N_("Nonexistent host networking interface, name '%ls'"),
                                       HostOnlyName.raw());
@@ -4564 +4561 @@
 
                 if (eIfType != HostNetworkInterfaceType_HostOnly)
-                    return VMSetError(pVM, VERR_INTERNAL_ERROR, RT_SRC_POS,
+                    return VMSetError(VMR3GetVM(mpUVM), VERR_INTERNAL_ERROR, RT_SRC_POS,
                                       N_("Interface ('%ls') is not a Host-Only Adapter interface"),
                                       HostOnlyName.raw());
@@ -4763 +4760 @@
                     if (fAttachDetach)
                     {
-                        rc = PDMR3DriverAttach(pVM, pszDevice, uInstance, uLun, 0 /*fFlags*/, NULL /* ppBase */);
+                        rc = PDMR3DriverAttach(VMR3GetVM(mpUVM), pszDevice, uInstance, uLun, 0 /*fFlags*/, NULL /* ppBase */);
                         //AssertRC(rc);
                     }
@@ -4915 +4912 @@
  * the machine XML and set a couple of initial properties.
  */
-/* static */ int Console::configGuestProperties(void *pvConsole, PVM pVM)
+/* static */ int Console::configGuestProperties(void *pvConsole, PUVM pUVM)
 {
 #ifdef VBOX_WITH_GUEST_PROPS
@@ -4947 +4944 @@
                 PFNDBGFHANDLEREXT pfnHandler = (PFNDBGFHANDLEREXT)(uintptr_t)Params[0].u.pointer.addr;
                 void *pService = (void*)Params[1].u.pointer.addr;
-                DBGFR3InfoRegisterExternal(pVM, "guestprops", "Display the guest properties", pfnHandler, pService);
+                DBGFR3InfoRegisterExternal(VMR3GetVM(pUVM), "guestprops", "Display the guest properties", pfnHandler, pService);
             }
         }

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

@@ -686 +686 @@
     RTSocketRetain(pState->mhSocket);
     void *pvUser = static_cast<void *>(static_cast<TeleporterState *>(pState));
-    vrc = VMR3Teleport(VMR3GetVM(pState->mpUVM),
+    vrc = VMR3Teleport(pState->mpUVM,
                        pState->mcMsMaxDowntime,
                        &g_teleporterTcpOps,         pvUser,
@@ -887 +887 @@
                         {
                             autoLock.release();
-                            int rc = VMR3Resume(VMR3GetVM(pState->mpUVM));
+                            int rc = VMR3Resume(pState->mpUVM);
                             AssertLogRelMsgRC(rc, ("VMR3Resume -> %Rrc\n", rc));
                             autoLock.acquire();
@@ -1338 +1338 @@
                 break;
 
-            int vrc2 = VMR3AtErrorRegisterU(pState->mpUVM,
-                                            Console::genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
+            int vrc2 = VMR3AtErrorRegister(pState->mpUVM,
+                                           Console::genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
             RTSocketRetain(pState->mhSocket); /* For concurrent access by I/O thread and EMT. */
             pState->moffStream = 0;
 
             void *pvUser2 = static_cast<void *>(static_cast<TeleporterState *>(pState));
-            vrc = VMR3LoadFromStream(VMR3GetVM(pState->mpUVM),
+            vrc = VMR3LoadFromStream(pState->mpUVM,
                                      &g_teleporterTcpOps, pvUser2,
                                      teleporterProgressCallback, pvUser2);
 
             RTSocketRelease(pState->mhSocket);
-            vrc2 = VMR3AtErrorDeregister(VMR3GetVM(pState->mpUVM), Console::genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
+            vrc2 = VMR3AtErrorDeregister(pState->mpUVM, Console::genericVMSetErrorCallback, &pState->mErrorText); AssertRC(vrc2);
 
             if (RT_FAILURE(vrc))
@@ -1412 +1412 @@
                 {
                     if (!strcmp(szCmd, "hand-over-resume"))
-                        vrc = VMR3Resume(VMR3GetVM(pState->mpUVM));
+                        vrc = VMR3Resume(pState->mpUVM);
                     else
                         pState->mptrConsole->setMachineState(MachineState_Paused);

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

@@ -223 +223 @@
     uint32_t cyPNG = 0;
 
-    Console::SafeVMPtr pVM (that->mParent);
-    if (SUCCEEDED(pVM.rc()))
+    Console::SafeVMPtr ptrVM(that->mParent);
+    if (ptrVM.isOk())
     {
         /* Query RGB bitmap. */
@@ -264 +264 @@
     else
     {
-        LogFunc(("Failed to get VM pointer 0x%x\n", pVM.rc()));
+        LogFunc(("Failed to get VM pointer 0x%x\n", ptrVM.rc()));
     }
 
@@ -859 +859 @@
         {
             /* protect mpVM */
-            Console::SafeVMPtr pVM (mParent);
-            AssertComRC (pVM.rc());
-
-            STAM_REG(pVM, &StatDisplayRefresh, STAMTYPE_PROFILE, "/PROF/Display/Refresh", STAMUNIT_TICKS_PER_CALL, "Time spent in EMT for display updates.");
+            Console::SafeVMPtr ptrVM (mParent);
+            AssertComRC (ptrVM.rc());
+
+            STAM_REG(ptrVM.raw(), &StatDisplayRefresh, STAMTYPE_PROFILE, "/PROF/Display/Refresh", STAMUNIT_TICKS_PER_CALL, "Time spent in EMT for display updates.");
             stam = 1;
         }
@@ -2069 +2069 @@
 }
 
-STDMETHODIMP Display::SetFramebuffer (ULONG aScreenId,
-    IFramebuffer *aFramebuffer)
+STDMETHODIMP Display::SetFramebuffer(ULONG aScreenId, IFramebuffer *aFramebuffer)
 {
     LogRelFlowFunc (("\n"));
@@ -2078 +2077 @@
 
     AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
+    if (FAILED(autoCaller.rc()))
+        return autoCaller.rc();
 
     AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
-    Console::SafeVMPtrQuiet pVM (mParent);
-    if (pVM.isOk())
+    Console::SafeVMPtrQuiet ptrVM(mParent);
+    if (ptrVM.isOk())
     {
         /* Must release the lock here because the changeFramebuffer will
@@ -2090 +2090 @@
 
         /* send request to the EMT thread */
-        int vrc = VMR3ReqCallWait (pVM, VMCPUID_ANY,
-                                   (PFNRT) changeFramebuffer, 3, this, aFramebuffer, aScreenId);
+        int vrc = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY,
+                                   (PFNRT)changeFramebuffer, 3, this, aFramebuffer, aScreenId);
 
         alock.acquire();
@@ -2323 +2323 @@
 }
 
-static int displayTakeScreenshot(PVM pVM, Display *pDisplay, struct DRVMAINDISPLAY *pDrv, ULONG aScreenId, BYTE *address, ULONG width, ULONG height)
+static int displayTakeScreenshot(PUVM pUVM, Display *pDisplay, struct DRVMAINDISPLAY *pDrv, ULONG aScreenId,
+                                 BYTE *address, ULONG width, ULONG height)
 {
     uint8_t *pu8Data = NULL;
@@ -2338 +2339 @@
                  it would be nice to have an accurate screenshot for the bug
                  report if the VM deadlocks. */
-        vrc = VMR3ReqPriorityCallWait(pVM, VMCPUID_ANY, (PFNRT)Display::displayTakeScreenshotEMT, 6,
-                                      pDisplay, aScreenId, &pu8Data, &cbData, &cx, &cy);
+        vrc = VMR3ReqPriorityCallWaitU(pUVM, VMCPUID_ANY, (PFNRT)Display::displayTakeScreenshotEMT, 6,
+                                       pDisplay, aScreenId, &pu8Data, &cbData, &cx, &cy);
         if (vrc != VERR_TRY_AGAIN)
         {
@@ -2417 +2418 @@
     CHECK_CONSOLE_DRV(mpDrv);
 
-    Console::SafeVMPtr pVM(mParent);
-    if (FAILED(pVM.rc())) return pVM.rc();
+    Console::SafeVMPtr ptrVM(mParent);
+    if (!ptrVM.isOk())
+        return ptrVM.rc();
 
     HRESULT rc = S_OK;
@@ -2431 +2433 @@
     alock.release();
 
-    int vrc = displayTakeScreenshot(pVM, this, mpDrv, aScreenId, address, width, height);
+    int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, address, width, height);
 
     if (vrc == VERR_NOT_IMPLEMENTED)
@@ -2469 +2471 @@
     CHECK_CONSOLE_DRV(mpDrv);
 
-    Console::SafeVMPtr pVM(mParent);
-    if (FAILED(pVM.rc())) return pVM.rc();
+    Console::SafeVMPtr ptrVM(mParent);
+    if (!ptrVM.isOk())
+        return ptrVM.rc();
 
     HRESULT rc = S_OK;
@@ -2489 +2492 @@
         return E_OUTOFMEMORY;
 
-    int vrc = displayTakeScreenshot(pVM, this, mpDrv, aScreenId, pu8Data, width, height);
+    int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, width, height);
 
     if (RT_SUCCESS(vrc))
@@ -2545 +2548 @@
     CHECK_CONSOLE_DRV(mpDrv);
 
-    Console::SafeVMPtr pVM(mParent);
-    if (FAILED(pVM.rc())) return pVM.rc();
+    Console::SafeVMPtr ptrVM(mParent);
+    if (!ptrVM.isOk())
+        return ptrVM.rc();
 
     HRESULT rc = S_OK;
@@ -2565 +2569 @@
         return E_OUTOFMEMORY;
 
-    int vrc = displayTakeScreenshot(pVM, this, mpDrv, aScreenId, pu8Data, width, height);
+    int vrc = displayTakeScreenshot(ptrVM.rawUVM(), this, mpDrv, aScreenId, pu8Data, width, height);
 
     if (RT_SUCCESS(vrc))
@@ -2732 +2736 @@
     CHECK_CONSOLE_DRV (mpDrv);
 
-    Console::SafeVMPtr pVM(mParent);
-    if (FAILED(pVM.rc())) return pVM.rc();
+    Console::SafeVMPtr ptrVM(mParent);
+    if (!ptrVM.isOk())
+        return ptrVM.rc();
 
     /* Release lock because the call scheduled on EMT may also try to take it. */
@@ -2742 +2747 @@
      * dirty conversion work.
      */
-    int rcVBox = VMR3ReqCallWait(pVM, VMCPUID_ANY, (PFNRT)Display::drawToScreenEMT, 7,
-                                 this, aScreenId, address, x, y, width, height);
+    int rcVBox = VMR3ReqCallWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::drawToScreenEMT, 7,
+                                  this, aScreenId, address, x, y, width, height);
 
     /*
@@ -2852 +2857 @@
     CHECK_CONSOLE_DRV (mpDrv);
 
-    Console::SafeVMPtr pVM(mParent);
-    if (FAILED(pVM.rc())) return pVM.rc();
+    Console::SafeVMPtr ptrVM(mParent);
+    if (!ptrVM.isOk())
+        return ptrVM.rc();
 
     HRESULT rc = S_OK;
@@ -2863 +2869 @@
 
     /* pdm.h says that this has to be called from the EMT thread */
-    int rcVBox = VMR3ReqCallVoidWait(pVM, VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
-                                     1, this);
+    int rcVBox = VMR3ReqCallVoidWaitU(ptrVM.rawUVM(), VMCPUID_ANY, (PFNRT)Display::InvalidateAndUpdateEMT,
+                                      1, this);
     alock.acquire();
 
@@ -2979 +2985 @@
      *  time-critical method.
      */
-    Console::SafeVMPtrQuiet pVM (mParent);
-    if (pVM.isOk())
-        VM_ASSERT_EMT (pVM.raw());
+    Console::SafeVMPtrQuiet ptrVM (mParent);
+    if (ptrVM.isOk())
+        Assert(VM_IS_EMT(ptrVM.raw()));
 #endif
 

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

@@ -28 +28 @@
 #include <VBox/vmm/csam.h>
 #include <VBox/vmm/vm.h>
+#include <VBox/vmm/uvm.h>
 #include <VBox/vmm/tm.h>
 #include <VBox/vmm/hm.h>
@@ -826 +827 @@
 
 /**
- * Hack for getting the VM handle.
+ * Hack for getting the user mode VM handle (UVM).
  *
  * This is only temporary (promise) while prototyping the debugger.
@@ -834 +835 @@
  *                      uintptr_t in COM, we're using the max integer.
  *                      (No, ULONG is not pointer sized!)
- */
-STDMETHODIMP MachineDebugger::COMGETTER(VM)(LONG64 *a_u64Vm)
-{
-    CheckComArgOutPointerValid(a_u64Vm);
+ * @remarks The returned handle must be passed to VMR3ReleaseUVM()!
+ * @remarks Prior to 4.3 this returned PVM.
+ */
+STDMETHODIMP MachineDebugger::COMGETTER(VM)(LONG64 *a_i64Vm)
+{
+    CheckComArgOutPointerValid(a_i64Vm);
 
     AutoCaller autoCaller(this);
@@ -848 +851 @@
         hrc = ptrVM.rc();
         if (SUCCEEDED(hrc))
-            *a_u64Vm = (intptr_t)ptrVM.raw();
+        {
+            VMR3RetainUVM(ptrVM.rawUVM());
+            *a_i64Vm = (intptr_t)ptrVM.rawUVM();
+        }
 
         /*