Changeset 47561 in vbox for trunk/src/VBox

Timestamp:

Aug 6, 2013 3:18:17 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

87761

Message:

Main/VirtualBox+Machine+Session: separate out the client death detection functionality into separate objects

Location:

trunk/src/VBox/Main

Files:

• Makefile.kmk (modified) (2 diffs)
• idl/VirtualBox.xidl (modified) (4 diffs)
• include/ClientToken.h (added)
• include/ClientTokenHolder.h (added)
• include/ClientWatcher.h (added)
• include/MachineImpl.h (modified) (6 diffs)
• include/SessionImpl.h (modified) (4 diffs)
• include/VirtualBoxImpl.h (modified) (9 diffs)
• src-client/ClientTokenHolder.cpp (copied) (copied from trunk/src/VBox/Main/src-client/SessionImpl.cpp ) (6 diffs)
• src-client/SessionImpl.cpp (modified) (9 diffs)
• src-server/ClientToken.cpp (copied) (copied from trunk/src/VBox/Main/src-server/MachineImpl.cpp ) (6 diffs)
• src-server/ClientWatcher.cpp (copied) (copied from trunk/src/VBox/Main/src-server/VirtualBoxImpl.cpp ) (25 diffs)
• src-server/MachineImpl.cpp (modified) (26 diffs)
• src-server/VirtualBoxImpl.cpp (modified) (18 diffs)

trunk/src/VBox/Main/Makefile.kmk

@@ -334 +334 @@
         src-server/BandwidthGroupImpl.cpp \
         src-server/BIOSSettingsImpl.cpp \
+        src-server/ClientWatcher.cpp \
+        src-server/ClientToken.cpp \
         src-server/DHCPServerImpl.cpp \
         src-server/NetworkServiceRunner.cpp \
@@ -634 +636 @@
         src-client/BusAssignmentManager.cpp \
         $(if $(VBOX_WITH_PCI_PASSTHROUGH),src-client/PCIRawDevImpl.cpp,) \
+        src-client/ClientTokenHolder.cpp \
         src-client/ConsoleImpl.cpp \
         src-client/ConsoleImpl2.cpp \

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

@@ -3364 +3364 @@
   <interface
     name="IInternalMachineControl" extends="$unknown"
-    uuid="dca36a92-703c-4649-98a4-f40c1ef0c336"
+    uuid="aca30121-e06b-4ace-bc22-d18506a8ba2b"
     internal="yes"
     wsmap="suppress"
@@ -3386 +3386 @@
       </desc>
       <param name="state" type="MachineState" dir="in"/>
-    </method>
-
-    <method name="getIPCId">
-      <param name="id" type="wstring" dir="return"/>
     </method>
 
@@ -17331 +17327 @@
   <interface
     name="IInternalSessionControl" extends="$unknown"
-    uuid="cddf451c-a006-4c33-8245-63b3c9ae6586"
+    uuid="3eeeb8e7-374f-4e0a-a5fd-f548742da8d4"
     internal="yes"
     wsmap="suppress"
@@ -17372 +17368 @@
       <param name="machine" type="IMachine" dir="in"/>
       <param name="lockType" type="LockType" dir="in"/>
+      <param name="tokenId" type="wstring" dir="in"/>
     </method>
 

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

@@ -783 +783 @@
     }
 
-#if defined(RT_OS_WINDOWS)
-
-    bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                       ComPtr<IInternalSessionControl> *aControl = NULL,
-                       HANDLE *aIPCSem = NULL, bool aAllowClosing = false);
-    bool isSessionSpawning(RTPROCESS *aPID = NULL);
-
-    bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
-                                ComPtr<IInternalSessionControl> *aControl = NULL,
-                                HANDLE *aIPCSem = NULL)
-    { return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
-
-#elif defined(RT_OS_OS2)
-
-    bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                       ComPtr<IInternalSessionControl> *aControl = NULL,
-                       HMTX *aIPCSem = NULL, bool aAllowClosing = false);
-
-    bool isSessionSpawning(RTPROCESS *aPID = NULL);
-
-    bool isSessionOpenOrClosing(ComObjPtr<SessionMachine> &aMachine,
-                                 ComPtr<IInternalSessionControl> *aControl = NULL,
-                                 HMTX *aIPCSem = NULL)
-    { return isSessionOpen(aMachine, aControl, aIPCSem, true /* aAllowClosing */); }
-
-#else
-
     bool isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
                        ComPtr<IInternalSessionControl> *aControl = NULL,
@@ -819 +792 @@
     { return isSessionOpen(aMachine, aControl, true /* aAllowClosing */); }
 
-#endif
-
     bool checkForSpawnFailure();
 
@@ -848 +819 @@
 
 protected:
+
+    class ClientToken;
 
     HRESULT checkStateDependency(StateDependency aDepType);
@@ -1075 +1048 @@
     STDMETHOD(SetRemoveSavedStateFile)(BOOL aRemove);
     STDMETHOD(UpdateState)(MachineState_T machineState);
-    STDMETHOD(GetIPCId)(BSTR *id);
     STDMETHOD(BeginPowerUp)(IProgress *aProgress);
     STDMETHOD(EndPowerUp)(LONG iResult);
@@ -1134 +1106 @@
     bool checkForDeath();
 
+    void getTokenId(Utf8Str &strTokenId);
+    // getClientToken must be only used by callers who can guarantee that
+    // the object cannot be deleted in the mean time, i.e. have a caller/lock.
+    ClientToken *getClientToken();
+
     HRESULT onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter);
     HRESULT onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
@@ -1236 +1213 @@
     ConsoleTaskData mConsoleTaskData;
 
-    /** interprocess semaphore handle for this machine */
-#if defined(RT_OS_WINDOWS)
-    HANDLE mIPCSem;
-    Bstr mIPCSemName;
-    friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                                       ComPtr<IInternalSessionControl> *aControl,
-                                       HANDLE *aIPCSem, bool aAllowClosing);
-#elif defined(RT_OS_OS2)
-    HMTX mIPCSem;
-    Bstr mIPCSemName;
-    friend bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                                       ComPtr<IInternalSessionControl> *aControl,
-                                       HMTX *aIPCSem, bool aAllowClosing);
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    int mIPCSem;
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    Bstr mIPCKey;
-# endif /*VBOX_WITH_NEW_SYS_V_KEYGEN */
-#else
-# error "Port me!"
-#endif
+    /** client token for this machine */
+    ClientToken *mClientToken;
 
     static DECLCALLBACK(int) taskHandler(RTTHREAD thread, void *pvUser);

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

@@ -24 +24 @@
 #ifdef RT_OS_WINDOWS
 # include "win/resource.h"
-#endif
-
-/** @def VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
- *  Use SYS V IPC for watching a session.
- *  This is defined in the Makefile since it's also used by MachineImpl.h/cpp.
- */
-#ifdef DOXYGEN_RUNNING
-# define VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
 #endif
 
@@ -81 +73 @@
     STDMETHOD(GetPID)(ULONG *aPid);
     STDMETHOD(GetRemoteConsole)(IConsole **aConsole);
-    STDMETHOD(AssignMachine)(IMachine *aMachine, LockType_T aLockType);
+    STDMETHOD(AssignMachine)(IMachine *aMachine, LockType_T aLockType, IN_BSTR aTokenId);
     STDMETHOD(AssignRemoteMachine)(IMachine *aMachine, IConsole *aConsole);
     STDMETHOD(UpdateMachineState)(MachineState_T aMachineState);
@@ -124 +116 @@
 
     HRESULT unlockMachine(bool aFinalRelease, bool aFromServer);
-    HRESULT grabIPCSemaphore();
-    void releaseIPCSemaphore();
 
     SessionState_T mState;
@@ -139 +129 @@
     ComPtr<IVirtualBox> mVirtualBox;
 
-    /* interprocess semaphore handle (id) for the opened machine */
-#if defined(RT_OS_WINDOWS)
-    HANDLE mIPCSem;
-    HANDLE mIPCThreadSem;
-#elif defined(RT_OS_OS2)
-    RTTHREAD mIPCThread;
-    RTSEMEVENT mIPCThreadSem;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    int mIPCSem;
-#else
-# error "Port me!"
-#endif
+    class ClientTokenHolder;
+
+    ClientTokenHolder *mClientTokenHolder;
 };
 

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

@@ -20 +20 @@
 
 #include "VirtualBoxBase.h"
+#include "objectslist.h"
 
 #ifdef RT_OS_WINDOWS
@@ -33 +34 @@
 class SessionMachine;
 class GuestOSType;
-class SharedFolder;
 class Progress;
 class Host;
@@ -39 +39 @@
 class DHCPServer;
 class PerformanceCollector;
-class VirtualBoxCallbackRegistration; /* see VirtualBoxImpl.cpp */
 #ifdef VBOX_WITH_EXTPACK
 class ExtPackManager;
@@ -52 +51 @@
 class SVCHlpClient;
 #endif
-
-struct VMClientWatcherData;
 
 namespace settings
@@ -71 +68 @@
 
     typedef std::list<ComPtr<IInternalSessionControl> > InternalControlList;
+    typedef ObjectsList<Machine> MachinesOList;
 
     class CallbackEvent;
@@ -216 +214 @@
     void onGuestPropertyChange(const Guid &aMachineId, IN_BSTR aName, IN_BSTR aValue,
                                IN_BSTR aFlags);
-    void onMachineUninit(Machine *aMachine);
     void onNatRedirectChange(const Guid &aMachineId, ULONG ulSlot, bool fRemove, IN_BSTR aName,
                                    NATProtocol_T aProto, IN_BSTR aHostIp, uint16_t aHostPort,
@@ -234 +231 @@
     void getOpenedMachines(SessionMachinesList &aMachines,
                            InternalControlList *aControls = NULL);
+    MachinesOList &getMachinesList();
 
     HRESULT findMachine(const Guid &aId,
@@ -322 +320 @@
 
 private:
+    class ClientWatcher;
 
     static HRESULT setErrorStatic(HRESULT aResultCode,
@@ -361 +360 @@
     static Bstr sAPIVersion;
 
-    static DECLCALLBACK(int) ClientWatcher(RTTHREAD thread, void *pvUser);
     static DECLCALLBACK(int) AsyncEventHandler(RTTHREAD thread, void *pvUser);
 

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

@@ -1 @@
-/* $Id$ */
 /** @file
- * VBox Client Session COM Class implementation in VBoxC.
+ *
+ * VirtualBox API client token holder (in the client process)
  */
 
 /*
- * Copyright (C) 2006-2012 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -16 +16 @@
  */
 
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/log.h>
+#include <iprt/semaphore.h>
+#include <iprt/process.h>
+
 #ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-#   include <errno.h>
-#   include <sys/types.h>
-#   include <sys/stat.h>
-#   include <sys/ipc.h>
-#   include <sys/sem.h>
-#endif
-
+# include <errno.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+# include <sys/ipc.h>
+# include <sys/sem.h>
+#endif
+
+#include <VBox/com/defs.h>
+
+#include "ClientTokenHolder.h"
 #include "SessionImpl.h"
-#include "ConsoleImpl.h"
-#include "Global.h"
-
-#include "AutoCaller.h"
-#include "Logging.h"
-
-#include <VBox/err.h>
-#include <iprt/process.h>
-
-#if defined(RT_OS_WINDOWS) || defined (RT_OS_OS2)
-/** VM IPC mutex holder thread */
-static DECLCALLBACK(int) IPCMutexHolderThread(RTTHREAD Thread, void *pvUser);
-#endif
-
-/**
- *  Local macro to check whether the session is open and return an error if not.
- *  @note Don't forget to do |Auto[Reader]Lock alock (this);| before using this
- *  macro.
- */
-#define CHECK_OPEN() \
-    do { \
-        if (mState != SessionState_Locked) \
-            return setError(E_UNEXPECTED, tr ("The session is not locked (session state: %s)"), Global::stringifySessionState(mState)); \
-    } while (0)
-
-// constructor / destructor
-/////////////////////////////////////////////////////////////////////////////
-
-HRESULT Session::FinalConstruct()
-{
-    LogFlowThisFunc(("\n"));
-
-    HRESULT rc = init();
-
-    BaseFinalConstruct();
-
-    return rc;
-}
-
-void Session::FinalRelease()
-{
-    LogFlowThisFunc(("\n"));
-
-    uninit();
-
-    BaseFinalRelease();
-}
-
-// public initializer/uninitializer for internal purposes only
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Initializes the Session object.
- */
-HRESULT Session::init()
-{
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    LogFlowThisFuncEnter();
-
-    mState = SessionState_Unlocked;
-    mType = SessionType_Null;
-
+
+
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+/** client token holder thread */
+static DECLCALLBACK(int) ClientTokenHolderThread(RTTHREAD Thread, void *pvUser);
+#endif
+
+
+Session::ClientTokenHolder::ClientTokenHolder()
+{
+    AssertReleaseFailed();
+}
+
+Session::ClientTokenHolder::~ClientTokenHolder()
+{
+    /* release the client token */
 #if defined(RT_OS_WINDOWS)
-    mIPCSem = NULL;
-    mIPCThreadSem = NULL;
+
+    if (mSem && mThreadSem)
+    {
+        /*
+         *  tell the thread holding the token to release it;
+         *  it will close mSem handle
+         */
+        ::SetEvent(mSem);
+        /* wait for the thread to finish */
+        ::WaitForSingleObject(mThreadSem, INFINITE);
+        ::CloseHandle(mThreadSem);
+
+        mThreadSem = NULL;
+        mSem = NULL;
+        mThread = NIL_RTTHREAD;
+    }
+
 #elif defined(RT_OS_OS2)
-    mIPCThread = NIL_RTTHREAD;
-    mIPCThreadSem = NIL_RTSEMEVENT;
+
+    if (mThread != NIL_RTTHREAD)
+    {
+        Assert(mSem != NIL_RTSEMEVENT);
+
+        /* tell the thread holding the token to release it */
+        int vrc = RTSemEventSignal(mSem);
+        AssertRC(vrc == NO_ERROR);
+
+        /* wait for the thread to finish */
+        vrc = RTThreadUserWait(mThread, RT_INDEFINITE_WAIT);
+        Assert(RT_SUCCESS(vrc) || vrc == VERR_INTERRUPTED);
+
+        mThread = NIL_RTTHREAD;
+    }
+
+    if (mSem != NIL_RTSEMEVENT)
+    {
+        RTSemEventDestroy(mSem);
+        mSem = NIL_RTSEMEVENT;
+    }
+
 #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    mIPCSem = -1;
+
+    if (mSem >= 0)
+    {
+        ::sembuf sop = { 0, 1, SEM_UNDO };
+        ::semop(mSem, &sop, 1);
+
+        mSem = -1;
+    }
+
 #else
 # error "Port me!"
 #endif
-
-    /* Confirm a successful initialization when it's the case */
-    autoInitSpan.setSucceeded();
-
-    LogFlowThisFuncLeave();
-
-    return S_OK;
-}
-
-/**
- *  Uninitializes the Session object.
- *
- *  @note Locks this object for writing.
- */
-void Session::uninit()
-{
-    LogFlowThisFuncEnter();
-
-    /* Enclose the state transition Ready->InUninit->NotReady */
-    AutoUninitSpan autoUninitSpan(this);
-    if (autoUninitSpan.uninitDone())
-    {
-        LogFlowThisFunc(("Already uninitialized.\n"));
-        LogFlowThisFuncLeave();
-        return;
-    }
-
-    /* close() needs write lock */
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mState != SessionState_Unlocked)
-    {
-        Assert(mState == SessionState_Locked ||
-               mState == SessionState_Spawning);
-
-        HRESULT rc = unlockMachine(true /* aFinalRelease */, false /* aFromServer */);
-        AssertComRC(rc);
-    }
-
-    LogFlowThisFuncLeave();
-}
-
-// ISession properties
-/////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP Session::COMGETTER(State)(SessionState_T *aState)
-{
-    CheckComArgOutPointerValid(aState);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aState = mState;
-
-    return S_OK;
-}
-
-STDMETHODIMP Session::COMGETTER(Type)(SessionType_T *aType)
-{
-    CheckComArgOutPointerValid(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    CHECK_OPEN();
-
-    *aType = mType;
-    return S_OK;
-}
-
-STDMETHODIMP Session::COMGETTER(Machine)(IMachine **aMachine)
-{
-    CheckComArgOutPointerValid(aMachine);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    CHECK_OPEN();
-
-    HRESULT rc;
-    if (mConsole)
-       rc = mConsole->machine().queryInterfaceTo(aMachine);
+}
+
+Session::ClientTokenHolder::ClientTokenHolder(const Utf8Str &strTokenId) :
+    mClientTokenId(strTokenId)
+{
+    mSem = CTHSEMARG;
+    mThread = NIL_RTTHREAD;
+
+#if defined(RT_OS_WINDOWS)
+    mThreadSem = CTHTHREADSEMARG;
+
+    Bstr bstrTokenId(strTokenId);
+
+    /*
+     * Since there is no guarantee that the constructor and destructor will be
+     * called in the same thread, we need a separate thread to hold the token.
+     */
+
+    mThreadSem = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+    AssertMsgReturnVoid(mThreadSem,
+                        ("Cannot create an event sem, err=%d", ::GetLastError()));
+
+    void *data[3];
+    data[0] = (void*)(BSTR)bstrTokenId.raw();
+    data[1] = (void*)mThreadSem;
+    data[2] = 0; /* will get an output from the thread */
+
+    /* create a thread to hold the token until signalled to release it */
+    int vrc = RTThreadCreate(&mThread, ClientTokenHolderThread, (void*)data, 0, RTTHREADTYPE_MAIN_WORKER, 0, "IPCHolder");
+    AssertRCReturnVoid(vrc);
+
+    /* wait until thread init is completed */
+    DWORD wrc = ::WaitForSingleObject(mThreadSem, INFINITE);
+    AssertMsg(wrc == WAIT_OBJECT_0, ("Wait failed, err=%d\n", ::GetLastError()));
+    Assert(data[2]);
+
+    if (wrc == WAIT_OBJECT_0 && data[2])
+    {
+        /* memorize the event sem we should signal in close() */
+        mSem = (HANDLE)data[2];
+    }
     else
-       rc = mRemoteMachine.queryInterfaceTo(aMachine);
-    if (FAILED(rc))
-    {
-        /** @todo VBox 3.3: replace E_FAIL with rc here. */
-        if (mConsole)
-            setError(E_FAIL, tr("Failed to query the session machine (%Rhrc)"), rc);
-        else if (FAILED_DEAD_INTERFACE(rc))
-            setError(E_FAIL, tr("Peer process crashed"));
-        else
-            setError(E_FAIL, tr("Failed to query the remote session machine (%Rhrc)"), rc);
-    }
-
-    return rc;
-}
-
-STDMETHODIMP Session::COMGETTER(Console)(IConsole **aConsole)
-{
-    CheckComArgOutPointerValid(aConsole);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    CHECK_OPEN();
-
-    HRESULT rc;
-    if (mConsole)
-        rc = mConsole.queryInterfaceTo(aConsole);
-    else
-        rc = mRemoteConsole.queryInterfaceTo(aConsole);
-
-    if (FAILED(rc))
-    {
-        /** @todo VBox 3.3: replace E_FAIL with rc here. */
-        if (mConsole)
-            setError(E_FAIL, tr("Failed to query the console (%Rhrc)"), rc);
-        else if (FAILED_DEAD_INTERFACE(rc))
-            setError(E_FAIL, tr("Peer process crashed"));
-        else
-            setError(E_FAIL, tr("Failed to query the remote console (%Rhrc)"), rc);
-    }
-
-    return rc;
-}
-
-// ISession methods
-/////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP Session::UnlockMachine()
-{
-    LogFlowThisFunc(("mState=%d, mType=%d\n", mState, mType));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* close() needs write lock */
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    CHECK_OPEN();
-
-    return unlockMachine(false /* aFinalRelease */, false /* aFromServer */);
-}
-
-// IInternalSessionControl methods
-/////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP Session::GetPID(ULONG *aPid)
-{
-    AssertReturn(aPid, E_POINTER);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aPid = (ULONG)RTProcSelf();
-    AssertCompile(sizeof(*aPid) == sizeof(RTPROCESS));
-
-    return S_OK;
-}
-
-STDMETHODIMP Session::GetRemoteConsole(IConsole **aConsole)
-{
-    LogFlowThisFuncEnter();
-    AssertReturn(aConsole, E_POINTER);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(mState != SessionState_Unlocked, VBOX_E_INVALID_VM_STATE);
-
-    AssertMsgReturn(mType == SessionType_WriteLock && !!mConsole,
-                    ("This is not a direct session!\n"),
-                    VBOX_E_INVALID_OBJECT_STATE);
-
-    /* return a failure if the session already transitioned to Closing
-     * but the server hasn't processed Machine::OnSessionEnd() yet. */
-    if (mState != SessionState_Locked)
-        return VBOX_E_INVALID_VM_STATE;
-
-    mConsole.queryInterfaceTo(aConsole);
-
-    LogFlowThisFuncLeave();
-
-    return S_OK;
-}
-
-STDMETHODIMP Session::AssignMachine(IMachine *aMachine, LockType_T aLockType)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aMachine=%p\n", aMachine));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(mState == SessionState_Unlocked, VBOX_E_INVALID_VM_STATE);
-
-    if (!aMachine)
-    {
-        /*
-         *  A special case: the server informs us that this session has been
-         *  passed to IMachine::launchVMProcess() so this session will become
-         *  remote (but not existing) when AssignRemoteMachine() is called.
-         */
-
-        AssertReturn(mType == SessionType_Null, VBOX_E_INVALID_OBJECT_STATE);
-        mType = SessionType_Remote;
-        mState = SessionState_Spawning;
-
-        LogFlowThisFuncLeave();
-        return S_OK;
-    }
-
-    HRESULT rc = E_FAIL;
-
-    /* query IInternalMachineControl interface */
-    mControl = aMachine;
-    AssertReturn(!!mControl, E_FAIL);
-
-    rc = mConsole.createObject();
-    AssertComRCReturn(rc, rc);
-
-    rc = mConsole->init(aMachine, mControl, aLockType);
-    AssertComRCReturn(rc, rc);
-
-    rc = grabIPCSemaphore();
+    {
+        ::CloseHandle(mThreadSem);
+        mThreadSem = NULL;
+    }
+#elif defined(RT_OS_OS2)
+    Bstr bstrTokenId(strTokenId);
 
     /*
-     *  Reference the VirtualBox object to ensure the server is up
-     *  until the session is closed
+     * Since there is no guarantee that the constructor and destructor will be
+     * called in the same thread, we need a separate thread to hold the token.
      */
-    if (SUCCEEDED(rc))
-       rc = aMachine->COMGETTER(Parent)(mVirtualBox.asOutParam());
-
-    if (SUCCEEDED(rc))
-    {
-        mType = SessionType_WriteLock;
-        mState = SessionState_Locked;
-    }
-    else
-    {
-        /* some cleanup */
-        mControl.setNull();
-        if (!mConsole.isNull())
-        {
-            mConsole->uninit();
-            mConsole.setNull();
-        }
-    }
-
-    LogFlowThisFunc(("rc=%08X\n", rc));
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-STDMETHODIMP Session::AssignRemoteMachine(IMachine *aMachine, IConsole *aConsole)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aMachine=%p, aConsole=%p\n", aMachine, aConsole));
-
-    AssertReturn(aMachine && aConsole, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(mState == SessionState_Unlocked ||
-                  mState == SessionState_Spawning, VBOX_E_INVALID_VM_STATE);
-
-    HRESULT rc = E_FAIL;
-
-    /* query IInternalMachineControl interface */
-    mControl = aMachine;
-    AssertReturn(!!mControl, E_FAIL);
-
-    /// @todo (dmik)
-    //      currently, the remote session returns the same machine and
-    //      console objects as the direct session, thus giving the
-    //      (remote) client full control over the direct session. For the
-    //      console, it is the desired behavior (the ability to control
-    //      VM execution is a must for the remote session). What about
-    //      the machine object, we may want to prevent the remote client
-    //      from modifying machine data. In this case, we must:
-    //      1)  assign the Machine object (instead of the SessionMachine
-    //          object that is passed to this method) to mRemoteMachine;
-    //      2)  remove GetMachine() property from the IConsole interface
-    //          because it always returns the SessionMachine object
-    //          (alternatively, we can supply a separate IConsole
-    //          implementation that will return the Machine object in
-    //          response to GetMachine()).
-
-    mRemoteMachine = aMachine;
-    mRemoteConsole = aConsole;
-
-    /*
-     *  Reference the VirtualBox object to ensure the server is up
-     *  until the session is closed
-     */
-    rc = aMachine->COMGETTER(Parent)(mVirtualBox.asOutParam());
-
-    if (SUCCEEDED(rc))
-    {
-        /*
-         *  RemoteSession type can be already set by AssignMachine() when its
-         *  argument is NULL (a special case)
-         */
-        if (mType != SessionType_Remote)
-            mType = SessionType_Shared;
-        else
-            Assert(mState == SessionState_Spawning);
-
-        mState = SessionState_Locked;
-    }
-    else
-    {
-        /* some cleanup */
-        mControl.setNull();
-        mRemoteMachine.setNull();
-        mRemoteConsole.setNull();
-    }
-
-    LogFlowThisFunc(("rc=%08X\n", rc));
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-STDMETHODIMP Session::UpdateMachineState(MachineState_T aMachineState)
-{
-    AutoCaller autoCaller(this);
-
-    if (autoCaller.state() != Ready)
-    {
-        /*
-         *  We might have already entered Session::uninit() at this point, so
-         *  return silently (not interested in the state change during uninit)
-         */
-        LogFlowThisFunc(("Already uninitialized.\n"));
-        return S_OK;
-    }
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mState == SessionState_Unlocking)
-    {
-        LogFlowThisFunc(("Already being unlocked.\n"));
-        return S_OK;
-    }
-
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-
-    AssertReturn(!mControl.isNull(), E_FAIL);
-    AssertReturn(!mConsole.isNull(), E_FAIL);
-
-    return mConsole->updateMachineState(aMachineState);
-}
-
-STDMETHODIMP Session::Uninitialize()
-{
-    LogFlowThisFuncEnter();
-
-    AutoCaller autoCaller(this);
-
-    HRESULT rc = S_OK;
-
-    if (autoCaller.state() == Ready)
-    {
-        /* close() needs write lock */
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        LogFlowThisFunc(("mState=%s, mType=%d\n", Global::stringifySessionState(mState), mType));
-
-        if (mState == SessionState_Unlocking)
-        {
-            LogFlowThisFunc(("Already being unlocked.\n"));
-            return S_OK;
-        }
-
-#ifndef DEBUG_andy /* Don't bug me -- now time to fix this at the moment. */
-        AssertReturn(mState == SessionState_Locked ||
-                     mState == SessionState_Spawning, VBOX_E_INVALID_VM_STATE);
-#endif
-
-        /* close ourselves */
-        rc = unlockMachine(false /* aFinalRelease */, true /* aFromServer */);
-    }
-    else if (autoCaller.state() == InUninit)
-    {
-        /*
-         *  We might have already entered Session::uninit() at this point,
-         *  return silently
-         */
-        LogFlowThisFunc(("Already uninitialized.\n"));
-    }
-    else
-    {
-        LogWarningThisFunc(("UNEXPECTED uninitialization!\n"));
-        rc = autoCaller.rc();
-    }
-
-    LogFlowThisFunc(("rc=%08X\n", rc));
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-STDMETHODIMP Session::OnNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onNetworkAdapterChange(networkAdapter, changeAdapter);
-}
-
-STDMETHODIMP Session::OnSerialPortChange(ISerialPort *serialPort)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onSerialPortChange(serialPort);
-}
-
-STDMETHODIMP Session::OnParallelPortChange(IParallelPort *parallelPort)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onParallelPortChange(parallelPort);
-}
-
-STDMETHODIMP Session::OnStorageControllerChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onStorageControllerChange();
-}
-
-STDMETHODIMP Session::OnMediumChange(IMediumAttachment *aMediumAttachment, BOOL aForce)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onMediumChange(aMediumAttachment, aForce);
-}
-
-STDMETHODIMP Session::OnCPUChange(ULONG aCPU, BOOL aRemove)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onCPUChange(aCPU, aRemove);
-}
-
-STDMETHODIMP Session::OnCPUExecutionCapChange(ULONG aExecutionCap)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onCPUExecutionCapChange(aExecutionCap);
-}
-
-STDMETHODIMP Session::OnVRDEServerChange(BOOL aRestart)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onVRDEServerChange(aRestart);
-}
-
-STDMETHODIMP Session::OnVideoCaptureChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onVideoCaptureChange();
-}
-
-STDMETHODIMP Session::OnUSBControllerChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onUSBControllerChange();
-}
-
-STDMETHODIMP Session::OnSharedFolderChange(BOOL aGlobal)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onSharedFolderChange(aGlobal);
-}
-
-STDMETHODIMP Session::OnClipboardModeChange(ClipboardMode_T aClipboardMode)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onClipboardModeChange(aClipboardMode);
-}
-
-STDMETHODIMP Session::OnDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onDragAndDropModeChange(aDragAndDropMode);
-}
-
-STDMETHODIMP Session::OnUSBDeviceAttach(IUSBDevice *aDevice,
-                                        IVirtualBoxErrorInfo *aError,
-                                        ULONG aMaskedIfs)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onUSBDeviceAttach(aDevice, aError, aMaskedIfs);
-}
-
-STDMETHODIMP Session::OnUSBDeviceDetach(IN_BSTR aId,
-                                        IVirtualBoxErrorInfo *aError)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onUSBDeviceDetach(aId, aError);
-}
-
-STDMETHODIMP Session::OnShowWindow(BOOL aCheck, BOOL *aCanShow, LONG64 *aWinId)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    if (mState != SessionState_Locked)
-    {
-        /* the call from Machine issued when the session is open can arrive
-         * after the session starts closing or gets closed. Note that when
-         * aCheck is false, we return E_FAIL to indicate that aWinId we return
-         * is not valid */
-        *aCanShow = FALSE;
-        *aWinId = 0;
-        return aCheck ? S_OK : E_FAIL;
-    }
-
-    return mConsole->onShowWindow(aCheck, aCanShow, aWinId);
-}
-
-STDMETHODIMP Session::OnBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onBandwidthGroupChange(aBandwidthGroup);
-}
-
-STDMETHODIMP Session::OnStorageDeviceChange(IMediumAttachment *aMediumAttachment, BOOL aRemove, BOOL aSilent)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->onStorageDeviceChange(aMediumAttachment, aRemove, aSilent);
-}
-
-STDMETHODIMP Session::AccessGuestProperty(IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags,
-                                          BOOL aIsSetter, BSTR *aRetValue, LONG64 *aRetTimestamp, BSTR *aRetFlags)
-{
-#ifdef VBOX_WITH_GUEST_PROPS
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    if (mState != SessionState_Locked)
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Machine is not locked by session (session state: %s)."),
-                        Global::stringifySessionState(mState));
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    CheckComArgStrNotEmptyOrNull(aName);
-    if (!aIsSetter && !VALID_PTR(aRetValue))
-        return E_POINTER;
-    if (!aIsSetter && !VALID_PTR(aRetTimestamp))
-        return E_POINTER;
-    if (!aIsSetter && !VALID_PTR(aRetFlags))
-        return E_POINTER;
-    /* aValue can be NULL for a setter call if the property is to be deleted. */
-    if (aIsSetter && (aValue != NULL) && !VALID_PTR(aValue))
-        return setError(E_INVALIDARG, tr("Invalid value pointer"));
-    /* aFlags can be null if it is to be left as is */
-    if (aIsSetter && (aFlags != NULL) && !VALID_PTR(aFlags))
-        return setError(E_INVALIDARG, tr("Invalid flags pointer"));
-
-    /* If this session is not in a VM process fend off the call. The caller
-     * handles this correctly, by doing the operation in VBoxSVC. */
-    if (!mConsole)
-        return E_ACCESSDENIED;
-
-    if (!aIsSetter)
-        return mConsole->getGuestProperty(aName, aRetValue, aRetTimestamp, aRetFlags);
-    else
-        return mConsole->setGuestProperty(aName, aValue, aFlags);
-#else /* VBOX_WITH_GUEST_PROPS not defined */
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_GUEST_PROPS not defined */
-}
-
-STDMETHODIMP Session::EnumerateGuestProperties(IN_BSTR aPatterns,
-                                               ComSafeArrayOut(BSTR, aNames),
-                                               ComSafeArrayOut(BSTR, aValues),
-                                               ComSafeArrayOut(LONG64, aTimestamps),
-                                               ComSafeArrayOut(BSTR, aFlags))
-{
-#ifdef VBOX_WITH_GUEST_PROPS
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    if (mState != SessionState_Locked)
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Machine is not locked by session (session state: %s)."),
-                        Global::stringifySessionState(mState));
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    if (!VALID_PTR(aPatterns) && (aPatterns != NULL))
-        return E_POINTER;
-    if (ComSafeArrayOutIsNull(aNames))
-        return E_POINTER;
-    if (ComSafeArrayOutIsNull(aValues))
-        return E_POINTER;
-    if (ComSafeArrayOutIsNull(aTimestamps))
-        return E_POINTER;
-    if (ComSafeArrayOutIsNull(aFlags))
-        return E_POINTER;
-
-    /* If this session is not in a VM process fend off the call. The caller
-     * handles this correctly, by doing the operation in VBoxSVC. */
-    if (!mConsole)
-        return E_ACCESSDENIED;
-
-    return mConsole->enumerateGuestProperties(aPatterns,
-                                              ComSafeArrayOutArg(aNames),
-                                              ComSafeArrayOutArg(aValues),
-                                              ComSafeArrayOutArg(aTimestamps),
-                                              ComSafeArrayOutArg(aFlags));
-#else /* VBOX_WITH_GUEST_PROPS not defined */
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_GUEST_PROPS not defined */
-}
-
-STDMETHODIMP Session::OnlineMergeMedium(IMediumAttachment *aMediumAttachment,
-                                        ULONG aSourceIdx, ULONG aTargetIdx,
-                                        IMedium *aSource, IMedium *aTarget,
-                                        BOOL aMergeForward,
-                                        IMedium *aParentForTarget,
-                                        ComSafeArrayIn(IMedium *, aChildrenToReparent),
-                                        IProgress *aProgress)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    if (mState != SessionState_Locked)
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Machine is not locked by session (session state: %s)."),
-                        Global::stringifySessionState(mState));
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-    CheckComArgNotNull(aMediumAttachment);
-    CheckComArgSafeArrayNotNull(aChildrenToReparent);
-
-    return mConsole->onlineMergeMedium(aMediumAttachment, aSourceIdx,
-                                       aTargetIdx, aSource, aTarget,
-                                       aMergeForward, aParentForTarget,
-                                       ComSafeArrayInArg(aChildrenToReparent),
-                                       aProgress);
-}
-
-STDMETHODIMP Session::EnableVMMStatistics(BOOL aEnable)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    mConsole->enableVMMStatistics(aEnable);
-
-    return S_OK;
-}
-
-STDMETHODIMP Session::PauseWithReason(Reason_T aReason)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->pause(aReason);
-}
-
-STDMETHODIMP Session::ResumeWithReason(Reason_T aReason)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->resume(aReason);
-}
-
-STDMETHODIMP Session::SaveStateWithReason(Reason_T aReason, IProgress **aProgress)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    AssertReturn(mState == SessionState_Locked, VBOX_E_INVALID_VM_STATE);
-    AssertReturn(mType == SessionType_WriteLock, VBOX_E_INVALID_OBJECT_STATE);
-    AssertReturn(mConsole, VBOX_E_INVALID_OBJECT_STATE);
-
-    return mConsole->saveState(aReason, aProgress);
-}
-
-// private methods
-///////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Unlocks a machine associated with the current session.
- *
- *  @param aFinalRelease    called as a result of FinalRelease()
- *  @param aFromServer      called as a result of Uninitialize()
- *
- *  @note To be called only from #uninit(), #UnlockMachine() or #Uninitialize().
- *  @note Locks this object for writing.
- */
-HRESULT Session::unlockMachine(bool aFinalRelease, bool aFromServer)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aFinalRelease=%d, isFromServer=%d\n",
-                      aFinalRelease, aFromServer));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    LogFlowThisFunc(("mState=%s, mType=%d\n", Global::stringifySessionState(mState), mType));
-
-    if (mState != SessionState_Locked)
-    {
-        Assert(mState == SessionState_Spawning);
-
-        /* The session object is going to be uninitialized before it has been
-         * assigned a direct console of the machine the client requested to open
-         * a remote session to using IVirtualBox:: openRemoteSession(). It is OK
-         * only if this close request comes from the server (for example, it
-         * detected that the VM process it started terminated before opening a
-         * direct session). Otherwise, it means that the client is too fast and
-         * trying to close the session before waiting for the progress object it
-         * got from IVirtualBox:: openRemoteSession() to complete, so assert. */
-        Assert(aFromServer);
-
-        mState = SessionState_Unlocked;
-        mType = SessionType_Null;
-#if defined(RT_OS_WINDOWS)
-        Assert(!mIPCSem && !mIPCThreadSem);
-#elif defined(RT_OS_OS2)
-        Assert(mIPCThread == NIL_RTTHREAD &&
-               mIPCThreadSem == NIL_RTSEMEVENT);
+
+    int vrc = RTSemEventCreate(&mSem);
+    AssertRCReturnVoid(vrc);
+
+    void *data[3];
+    data[0] = (void*)bstrTokenId.raw();
+    data[1] = (void*)mSem;
+    data[2] = (void*)false; /* will get the thread result here */
+
+    /* create a thread to hold the token until signalled to release it */
+    vrc = RTThreadCreate(&mThread, ClientTokenHolderThread, (void *) data,
+                         0, RTTHREADTYPE_MAIN_WORKER, 0, "IPCHolder");
+    AssertRCReturnVoid(vrc);
+    /* wait until thread init is completed */
+    vrc = RTThreadUserWait(mThread, RT_INDEFINITE_WAIT);
+    AssertReturnVoid(RT_SUCCESS(vrc) || vrc == VERR_INTERRUPTED);
+
+    /* the thread must succeed */
+    AssertReturnVoid((bool)data[2]);
+
 #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-        Assert(mIPCSem == -1);
+
+# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
+    key_t key = RTStrToUInt32(strTokenId.c_str());
+    AssertMsgReturnVoid(key != 0,
+                        ("Key value of 0 is not valid for client token"));
+# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
+    char *pszSemName = NULL;
+    RTStrUtf8ToCurrentCP(&pszSemName, strTokenId);
+    key_t key = ::ftok(pszSemName, 'V');
+    RTStrFree(pszSemName);
+# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
+    int s = ::semget(key, 0, 0);
+    AssertMsgReturnVoid(s >= 0,
+                        ("Cannot open semaphore, errno=%d", errno));
+
+    /* grab the semaphore */
+    ::sembuf sop = { 0,  -1, SEM_UNDO };
+    int rv = ::semop(s, &sop, 1);
+    AssertMsgReturnVoid(rv == 0,
+                        ("Cannot grab semaphore, errno=%d", errno));
+    mSem = s;
+
 #else
 # error "Port me!"
 #endif
-        LogFlowThisFuncLeave();
-        return S_OK;
-    }
-
-    /* go to the closing state */
-    mState = SessionState_Unlocking;
-
-    if (mType == SessionType_WriteLock)
-    {
-        if (!mConsole.isNull())
-        {
-            mConsole->uninit();
-            mConsole.setNull();
-        }
-    }
-    else
-    {
-        mRemoteMachine.setNull();
-        mRemoteConsole.setNull();
-    }
-
-    ComPtr<IProgress> progress;
-
-    if (!aFinalRelease && !aFromServer)
-    {
-        /*
-         *  We trigger OnSessionEnd() only when the session closes itself using
-         *  Close(). Note that if isFinalRelease = TRUE here, this means that
-         *  the client process has already initialized the termination procedure
-         *  without issuing Close() and the IPC channel is no more operational --
-         *  so we cannot call the server's method (it will definitely fail). The
-         *  server will instead simply detect the abnormal client death (since
-         *  OnSessionEnd() is not called) and reset the machine state to Aborted.
-         */
-
-        /*
-         *  while waiting for OnSessionEnd() to complete one of our methods
-         *  can be called by the server (for example, Uninitialize(), if the
-         *  direct session has initiated a closure just a bit before us) so
-         *  we need to release the lock to avoid deadlocks. The state is already
-         *  SessionState_Closing here, so it's safe.
-         */
-        alock.release();
-
-        LogFlowThisFunc(("Calling mControl->OnSessionEnd()...\n"));
-        HRESULT rc = mControl->OnSessionEnd(this, progress.asOutParam());
-        LogFlowThisFunc(("mControl->OnSessionEnd()=%08X\n", rc));
-
-        alock.acquire();
-
-        /*
-         *  If we get E_UNEXPECTED this means that the direct session has already
-         *  been closed, we're just too late with our notification and nothing more
-         *
-         *  bird: Seems E_ACCESSDENIED is what gets returned these days; see
-         *        VirtualBoxBase::addCaller.
-         */
-        if (mType != SessionType_WriteLock && (rc == E_UNEXPECTED || rc == E_ACCESSDENIED))
-            rc = S_OK;
-
-#ifndef DEBUG_bird /* I don't want clients crashing on me just because VBoxSVC went belly up. */
-        AssertComRC(rc);
-#endif
-    }
-
-    mControl.setNull();
-
-    if (mType == SessionType_WriteLock)
-    {
-        releaseIPCSemaphore();
-        if (!aFinalRelease && !aFromServer)
-        {
-            /*
-             *  Wait for the server to grab the semaphore and destroy the session
-             *  machine (allowing us to open a new session with the same machine
-             *  once this method returns)
-             */
-            Assert(!!progress);
-            if (progress)
-                progress->WaitForCompletion(-1);
-        }
-    }
-
-    mState = SessionState_Unlocked;
-    mType = SessionType_Null;
-
-    /* release the VirtualBox instance as the very last step */
-    mVirtualBox.setNull();
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-/** @note To be called only from #AssignMachine() */
-HRESULT Session::grabIPCSemaphore()
-{
-    HRESULT rc = E_FAIL;
-
-    /* open the IPC semaphore based on the sessionId and try to grab it */
-    Bstr ipcId;
-    rc = mControl->GetIPCId(ipcId.asOutParam());
-    AssertComRCReturnRC(rc);
-
-    LogFlowThisFunc(("ipcId='%ls'\n", ipcId.raw()));
-
-#if defined(RT_OS_WINDOWS)
-
-    /*
-     *  Since Session is an MTA object, this method can be executed on
-     *  any thread, and this thread will not necessarily match the thread on
-     *  which close() will be called later. Therefore, we need a separate
-     *  thread to hold the IPC mutex and then release it in close().
-     */
-
-    mIPCThreadSem = ::CreateEvent(NULL, FALSE, FALSE, NULL);
-    AssertMsgReturn(mIPCThreadSem,
-                    ("Cannot create an event sem, err=%d", ::GetLastError()),
-                    E_FAIL);
-
-    void *data[3];
-    data[0] = (void*)(BSTR)ipcId.raw();
-    data[1] = (void*)mIPCThreadSem;
-    data[2] = 0; /* will get an output from the thread */
-
-    /* create a thread to hold the IPC mutex until signalled to release it */
-    RTTHREAD tid;
-    int vrc = RTThreadCreate(&tid, IPCMutexHolderThread, (void*)data, 0, RTTHREADTYPE_MAIN_WORKER, 0, "IPCHolder");
-    AssertRCReturn(vrc, E_FAIL);
-
-    /* wait until thread init is completed */
-    DWORD wrc = ::WaitForSingleObject(mIPCThreadSem, INFINITE);
-    AssertMsg(wrc == WAIT_OBJECT_0, ("Wait failed, err=%d\n", ::GetLastError()));
-    Assert(data[2]);
-
-    if (wrc == WAIT_OBJECT_0 && data[2])
-    {
-        /* memorize the event sem we should signal in close() */
-        mIPCSem = (HANDLE)data[2];
-        rc = S_OK;
-    }
-    else
-    {
-        ::CloseHandle(mIPCThreadSem);
-        mIPCThreadSem = NULL;
-        rc = E_FAIL;
-    }
-
-#elif defined(RT_OS_OS2)
-
-    /* We use XPCOM where any message (including close()) can arrive on any
-     * worker thread (which will not necessarily match this thread that opens
-     * the mutex). Therefore, we need a separate thread to hold the IPC mutex
-     * and then release it in close(). */
-
-    int vrc = RTSemEventCreate(&mIPCThreadSem);
-    AssertRCReturn(vrc, E_FAIL);
-
-    void *data[3];
-    data[0] = (void*)ipcId.raw();
-    data[1] = (void*)mIPCThreadSem;
-    data[2] = (void*)false; /* will get the thread result here */
-
-    /* create a thread to hold the IPC mutex until signalled to release it */
-    vrc = RTThreadCreate(&mIPCThread, IPCMutexHolderThread, (void *) data,
-                         0, RTTHREADTYPE_MAIN_WORKER, 0, "IPCHolder");
-    AssertRCReturn(vrc, E_FAIL);
-
-    /* wait until thread init is completed */
-    vrc = RTThreadUserWait (mIPCThread, RT_INDEFINITE_WAIT);
-    AssertReturn(RT_SUCCESS(vrc) || vrc == VERR_INTERRUPTED, E_FAIL);
-
-    /* the thread must succeed */
-    AssertReturn((bool)data[2], E_FAIL);
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    Utf8Str ipcKey = ipcId;
-    key_t key = RTStrToUInt32(ipcKey.c_str());
-    AssertMsgReturn (key != 0,
-                    ("Key value of 0 is not valid for IPC semaphore"),
-                    E_FAIL);
-# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    Utf8Str semName = ipcId;
-    char *pszSemName = NULL;
-    RTStrUtf8ToCurrentCP (&pszSemName, semName);
-    key_t key = ::ftok (pszSemName, 'V');
-    RTStrFree (pszSemName);
-# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-
-    mIPCSem = ::semget (key, 0, 0);
-    AssertMsgReturn (mIPCSem >= 0,
-                    ("Cannot open IPC semaphore, errno=%d", errno),
-                    E_FAIL);
-
-    /* grab the semaphore */
-    ::sembuf sop = { 0,  -1, SEM_UNDO };
-    int rv = ::semop (mIPCSem, &sop, 1);
-    AssertMsgReturn (rv == 0,
-                    ("Cannot grab IPC semaphore, errno=%d", errno),
-                    E_FAIL);
-
-#else
-# error "Port me!"
-#endif
-
-    return rc;
-}
-
-/** @note To be called only from #close() */
-void Session::releaseIPCSemaphore()
-{
-    /* release the IPC semaphore */
-#if defined(RT_OS_WINDOWS)
-
-    if (mIPCSem && mIPCThreadSem)
-    {
-        /*
-         *  tell the thread holding the IPC mutex to release it;
-         *  it will close mIPCSem handle
-         */
-        ::SetEvent (mIPCSem);
-        /* wait for the thread to finish */
-        ::WaitForSingleObject (mIPCThreadSem, INFINITE);
-        ::CloseHandle (mIPCThreadSem);
-
-        mIPCThreadSem = NULL;
-        mIPCSem = NULL;
-    }
-
-#elif defined(RT_OS_OS2)
-
-    if (mIPCThread != NIL_RTTHREAD)
-    {
-        Assert (mIPCThreadSem != NIL_RTSEMEVENT);
-
-        /* tell the thread holding the IPC mutex to release it */
-        int vrc = RTSemEventSignal (mIPCThreadSem);
-        AssertRC(vrc == NO_ERROR);
-
-        /* wait for the thread to finish */
-        vrc = RTThreadUserWait (mIPCThread, RT_INDEFINITE_WAIT);
-        Assert (RT_SUCCESS(vrc) || vrc == VERR_INTERRUPTED);
-
-        mIPCThread = NIL_RTTHREAD;
-    }
-
-    if (mIPCThreadSem != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy (mIPCThreadSem);
-        mIPCThreadSem = NIL_RTSEMEVENT;
-    }
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-    if (mIPCSem >= 0)
-    {
-        ::sembuf sop = { 0, 1, SEM_UNDO };
-        ::semop (mIPCSem, &sop, 1);
-
-        mIPCSem = -1;
-    }
-
-#else
-# error "Port me!"
-#endif
-}
-
-#if defined(RT_OS_WINDOWS)
-/** VM IPC mutex holder thread */
-DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
+}
+
+bool Session::ClientTokenHolder::isReady()
+{
+    return mSem != CTHSEMARG;
+}
+
+#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
+/** client token holder thread */
+DECLCALLBACK(int) ClientTokenHolderThread(RTTHREAD Thread, void *pvUser)
 {
     LogFlowFuncEnter();
 
-    Assert (pvUser);
-    void **data = (void **) pvUser;
-
+    Assert(pvUser);
+
+    void **data = (void **)pvUser;
+
+# if defined(RT_OS_WINDOWS)
     BSTR sessionId = (BSTR)data[0];
     HANDLE initDoneSem = (HANDLE)data[1];
 
-    HANDLE ipcMutex = ::OpenMutex (MUTEX_ALL_ACCESS, FALSE, sessionId);
-    AssertMsg (ipcMutex, ("cannot open IPC mutex, err=%d\n", ::GetLastError()));
-
-    if (ipcMutex)
-    {
-        /* grab the mutex */
-        DWORD wrc = ::WaitForSingleObject (ipcMutex, 0);
-        AssertMsg (wrc == WAIT_OBJECT_0, ("cannot grab IPC mutex, err=%d\n", wrc));
+    HANDLE mutex = ::OpenMutex(MUTEX_ALL_ACCESS, FALSE, sessionId);
+    AssertMsg(mutex, ("cannot open token, err=%d\n", ::GetLastError()));
+
+    if (mutex)
+    {
+        /* grab the token */
+        DWORD wrc = ::WaitForSingleObject(mutex, 0);
+        AssertMsg(wrc == WAIT_OBJECT_0, ("cannot grab token, err=%d\n", wrc));
         if (wrc == WAIT_OBJECT_0)
         {
-            HANDLE finishSem = ::CreateEvent (NULL, FALSE, FALSE, NULL);
-            AssertMsg (finishSem, ("cannot create event sem, err=%d\n", ::GetLastError()));
+            HANDLE finishSem = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+            AssertMsg(finishSem, ("cannot create event sem, err=%d\n", ::GetLastError()));
             if (finishSem)
             {
                 data[2] = (void*)finishSem;
                 /* signal we're done with init */
-                ::SetEvent (initDoneSem);
-                /* wait until we're signaled to release the IPC mutex */
-                ::WaitForSingleObject (finishSem, INFINITE);
-                /* release the IPC mutex */
-                LogFlow (("IPCMutexHolderThread(): releasing IPC mutex...\n"));
-                BOOL success = ::ReleaseMutex (ipcMutex);
-                AssertMsg (success, ("cannot release mutex, err=%d\n", ::GetLastError()));
-                ::CloseHandle (ipcMutex);
-                ::CloseHandle (finishSem);
+                ::SetEvent(initDoneSem);
+                /* wait until we're signaled to release the token */
+                ::WaitForSingleObject(finishSem, INFINITE);
+                /* release the token */
+                LogFlow(("ClientTokenHolderThread(): releasing token...\n"));
+                BOOL success = ::ReleaseMutex(mutex);
+                AssertMsg(success, ("cannot release token, err=%d\n", ::GetLastError()));
+                ::CloseHandle(mutex);
+                ::CloseHandle(finishSem);
             }
         }
@@ -1328 +254 @@
 
     /* signal we're done */
-    ::SetEvent (initDoneSem);
-
-    LogFlowFuncLeave();
-
-    return 0;
-}
-#endif
-
-#if defined(RT_OS_OS2)
-/** VM IPC mutex holder thread */
-DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    Assert (pvUser);
-    void **data = (void **) pvUser;
-
-    Utf8Str ipcId = (BSTR)data[0];
+    ::SetEvent(initDoneSem);
+# elif defined(RT_OS_OS2)
+    Utf8Str sessionId = (BSTR)data[0];
     RTSEMEVENT finishSem = (RTSEMEVENT)data[1];
 
-    LogFlowFunc (("ipcId='%s', finishSem=%p\n", ipcId.raw(), finishSem));
-
-    HMTX ipcMutex = NULLHANDLE;
-    APIRET arc = ::DosOpenMutexSem ((PSZ) ipcId.raw(), &ipcMutex);
-    AssertMsg (arc == NO_ERROR, ("cannot open IPC mutex, arc=%ld\n", arc));
+    LogFlowFunc(("sessionId='%s', finishSem=%p\n", sessionId.raw(), finishSem));
+
+    HMTX mutex = NULLHANDLE;
+    APIRET arc = ::DosOpenMutexSem((PSZ)sessionId.raw(), &mutex);
+    AssertMsg(arc == NO_ERROR, ("cannot open token, arc=%ld\n", arc));
 
     if (arc == NO_ERROR)
     {
-        /* grab the mutex */
-        LogFlowFunc (("grabbing IPC mutex...\n"));
-        arc = ::DosRequestMutexSem (ipcMutex, SEM_IMMEDIATE_RETURN);
-        AssertMsg (arc == NO_ERROR, ("cannot grab IPC mutex, arc=%ld\n", arc));
+        /* grab the token */
+        LogFlowFunc(("grabbing token...\n"));
+        arc = ::DosRequestMutexSem(mutex, SEM_IMMEDIATE_RETURN);
+        AssertMsg(arc == NO_ERROR, ("cannot grab token, arc=%ld\n", arc));
         if (arc == NO_ERROR)
         {
@@ -1365 +276 @@
             data[2] = (void*)true;
             /* signal we're done */
-            int vrc = RTThreadUserSignal (Thread);
+            int vrc = RTThreadUserSignal(Thread);
             AssertRC(vrc);
 
-            /* wait until we're signaled to release the IPC mutex */
-            LogFlowFunc (("waiting for termination signal..\n"));
-            vrc = RTSemEventWait (finishSem, RT_INDEFINITE_WAIT);
-            Assert (arc == ERROR_INTERRUPT || ERROR_TIMEOUT);
-
-            /* release the IPC mutex */
-            LogFlowFunc (("releasing IPC mutex...\n"));
-            arc = ::DosReleaseMutexSem (ipcMutex);
-            AssertMsg (arc == NO_ERROR, ("cannot release mutex, arc=%ld\n", arc));
+            /* wait until we're signaled to release the token */
+            LogFlowFunc(("waiting for termination signal..\n"));
+            vrc = RTSemEventWait(finishSem, RT_INDEFINITE_WAIT);
+            Assert(arc == ERROR_INTERRUPT || ERROR_TIMEOUT);
+
+            /* release the token */
+            LogFlowFunc(("releasing token...\n"));
+            arc = ::DosReleaseMutexSem(mutex);
+            AssertMsg(arc == NO_ERROR, ("cannot release token, arc=%ld\n", arc));
         }
-
-        ::DosCloseMutexSem (ipcMutex);
+        ::DosCloseMutexSem(mutex);
     }
 
@@ -1385 +295 @@
     data[1] = (void*)false;
     /* signal we're done */
-    int vrc = RTThreadUserSignal (Thread);
+    int vrc = RTThreadUserSignal(Thread);
     AssertRC(vrc);
+# else
+#  error "Port me!"
+# endif
 
     LogFlowFuncLeave();
@@ -1393 +306 @@
 }
 #endif
+
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2012 Oracle Corporation
+ * Copyright (C) 2006-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -16 +16 @@
  */
 
-#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-#   include <errno.h>
-#   include <sys/types.h>
-#   include <sys/stat.h>
-#   include <sys/ipc.h>
-#   include <sys/sem.h>
-#endif
-
 #include "SessionImpl.h"
 #include "ConsoleImpl.h"
 #include "Global.h"
+#include "ClientTokenHolder.h"
 
 #include "AutoCaller.h"
@@ -33 +26 @@
 #include <VBox/err.h>
 #include <iprt/process.h>
-
-#if defined(RT_OS_WINDOWS) || defined (RT_OS_OS2)
-/** VM IPC mutex holder thread */
-static DECLCALLBACK(int) IPCMutexHolderThread(RTTHREAD Thread, void *pvUser);
-#endif
 
 /**
@@ -90 +78 @@
     mType = SessionType_Null;
 
-#if defined(RT_OS_WINDOWS)
-    mIPCSem = NULL;
-    mIPCThreadSem = NULL;
-#elif defined(RT_OS_OS2)
-    mIPCThread = NIL_RTTHREAD;
-    mIPCThreadSem = NIL_RTSEMEVENT;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    mIPCSem = -1;
-#else
-# error "Port me!"
-#endif
+    mClientTokenHolder = NULL;
 
     /* Confirm a successful initialization when it's the case */
@@ -300 +278 @@
 }
 
-STDMETHODIMP Session::AssignMachine(IMachine *aMachine, LockType_T aLockType)
+STDMETHODIMP Session::AssignMachine(IMachine *aMachine, LockType_T aLockType,
+                                    IN_BSTR aTokenId)
 {
     LogFlowThisFuncEnter();
@@ -340 +319 @@
     AssertComRCReturn(rc, rc);
 
-    rc = grabIPCSemaphore();
+    Utf8Str strTokenId(aTokenId);
+    Assert(!strTokenId.isEmpty());
+    /* create the machine client token */
+    try
+    {
+        mClientTokenHolder = new ClientTokenHolder(strTokenId);
+        if (!mClientTokenHolder->isReady())
+        {
+            delete mClientTokenHolder;
+            mClientTokenHolder = NULL;
+            rc = E_FAIL;
+        }
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = E_OUTOFMEMORY;
+    }
 
     /*
@@ -1008 +1003 @@
         mState = SessionState_Unlocked;
         mType = SessionType_Null;
-#if defined(RT_OS_WINDOWS)
-        Assert(!mIPCSem && !mIPCThreadSem);
-#elif defined(RT_OS_OS2)
-        Assert(mIPCThread == NIL_RTTHREAD &&
-               mIPCThreadSem == NIL_RTSEMEVENT);
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-        Assert(mIPCSem == -1);
-#else
-# error "Port me!"
-#endif
+
+        Assert(!mClientTokenHolder);
+
         LogFlowThisFuncLeave();
         return S_OK;
@@ -1087 +1075 @@
     if (mType == SessionType_WriteLock)
     {
-        releaseIPCSemaphore();
+        if (mClientTokenHolder)
+        {
+            delete mClientTokenHolder;
+            mClientTokenHolder = NULL;
+        }
+
         if (!aFinalRelease && !aFromServer)
         {
@@ -1111 +1104 @@
 }
 
-/** @note To be called only from #AssignMachine() */
-HRESULT Session::grabIPCSemaphore()
-{
-    HRESULT rc = E_FAIL;
-
-    /* open the IPC semaphore based on the sessionId and try to grab it */
-    Bstr ipcId;
-    rc = mControl->GetIPCId(ipcId.asOutParam());
-    AssertComRCReturnRC(rc);
-
-    LogFlowThisFunc(("ipcId='%ls'\n", ipcId.raw()));
-
-#if defined(RT_OS_WINDOWS)
-
-    /*
-     *  Since Session is an MTA object, this method can be executed on
-     *  any thread, and this thread will not necessarily match the thread on
-     *  which close() will be called later. Therefore, we need a separate
-     *  thread to hold the IPC mutex and then release it in close().
-     */
-
-    mIPCThreadSem = ::CreateEvent(NULL, FALSE, FALSE, NULL);
-    AssertMsgReturn(mIPCThreadSem,
-                    ("Cannot create an event sem, err=%d", ::GetLastError()),
-                    E_FAIL);
-
-    void *data[3];
-    data[0] = (void*)(BSTR)ipcId.raw();
-    data[1] = (void*)mIPCThreadSem;
-    data[2] = 0; /* will get an output from the thread */
-
-    /* create a thread to hold the IPC mutex until signalled to release it */
-    RTTHREAD tid;
-    int vrc = RTThreadCreate(&tid, IPCMutexHolderThread, (void*)data, 0, RTTHREADTYPE_MAIN_WORKER, 0, "IPCHolder");
-    AssertRCReturn(vrc, E_FAIL);
-
-    /* wait until thread init is completed */
-    DWORD wrc = ::WaitForSingleObject(mIPCThreadSem, INFINITE);
-    AssertMsg(wrc == WAIT_OBJECT_0, ("Wait failed, err=%d\n", ::GetLastError()));
-    Assert(data[2]);
-
-    if (wrc == WAIT_OBJECT_0 && data[2])
-    {
-        /* memorize the event sem we should signal in close() */
-        mIPCSem = (HANDLE)data[2];
-        rc = S_OK;
-    }
-    else
-    {
-        ::CloseHandle(mIPCThreadSem);
-        mIPCThreadSem = NULL;
-        rc = E_FAIL;
-    }
-
-#elif defined(RT_OS_OS2)
-
-    /* We use XPCOM where any message (including close()) can arrive on any
-     * worker thread (which will not necessarily match this thread that opens
-     * the mutex). Therefore, we need a separate thread to hold the IPC mutex
-     * and then release it in close(). */
-
-    int vrc = RTSemEventCreate(&mIPCThreadSem);
-    AssertRCReturn(vrc, E_FAIL);
-
-    void *data[3];
-    data[0] = (void*)ipcId.raw();
-    data[1] = (void*)mIPCThreadSem;
-    data[2] = (void*)false; /* will get the thread result here */
-
-    /* create a thread to hold the IPC mutex until signalled to release it */
-    vrc = RTThreadCreate(&mIPCThread, IPCMutexHolderThread, (void *) data,
-                         0, RTTHREADTYPE_MAIN_WORKER, 0, "IPCHolder");
-    AssertRCReturn(vrc, E_FAIL);
-
-    /* wait until thread init is completed */
-    vrc = RTThreadUserWait (mIPCThread, RT_INDEFINITE_WAIT);
-    AssertReturn(RT_SUCCESS(vrc) || vrc == VERR_INTERRUPTED, E_FAIL);
-
-    /* the thread must succeed */
-    AssertReturn((bool)data[2], E_FAIL);
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    Utf8Str ipcKey = ipcId;
-    key_t key = RTStrToUInt32(ipcKey.c_str());
-    AssertMsgReturn (key != 0,
-                    ("Key value of 0 is not valid for IPC semaphore"),
-                    E_FAIL);
-# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    Utf8Str semName = ipcId;
-    char *pszSemName = NULL;
-    RTStrUtf8ToCurrentCP (&pszSemName, semName);
-    key_t key = ::ftok (pszSemName, 'V');
-    RTStrFree (pszSemName);
-# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-
-    mIPCSem = ::semget (key, 0, 0);
-    AssertMsgReturn (mIPCSem >= 0,
-                    ("Cannot open IPC semaphore, errno=%d", errno),
-                    E_FAIL);
-
-    /* grab the semaphore */
-    ::sembuf sop = { 0,  -1, SEM_UNDO };
-    int rv = ::semop (mIPCSem, &sop, 1);
-    AssertMsgReturn (rv == 0,
-                    ("Cannot grab IPC semaphore, errno=%d", errno),
-                    E_FAIL);
-
-#else
-# error "Port me!"
-#endif
-
-    return rc;
-}
-
-/** @note To be called only from #close() */
-void Session::releaseIPCSemaphore()
-{
-    /* release the IPC semaphore */
-#if defined(RT_OS_WINDOWS)
-
-    if (mIPCSem && mIPCThreadSem)
-    {
-        /*
-         *  tell the thread holding the IPC mutex to release it;
-         *  it will close mIPCSem handle
-         */
-        ::SetEvent (mIPCSem);
-        /* wait for the thread to finish */
-        ::WaitForSingleObject (mIPCThreadSem, INFINITE);
-        ::CloseHandle (mIPCThreadSem);
-
-        mIPCThreadSem = NULL;
-        mIPCSem = NULL;
-    }
-
-#elif defined(RT_OS_OS2)
-
-    if (mIPCThread != NIL_RTTHREAD)
-    {
-        Assert (mIPCThreadSem != NIL_RTSEMEVENT);
-
-        /* tell the thread holding the IPC mutex to release it */
-        int vrc = RTSemEventSignal (mIPCThreadSem);
-        AssertRC(vrc == NO_ERROR);
-
-        /* wait for the thread to finish */
-        vrc = RTThreadUserWait (mIPCThread, RT_INDEFINITE_WAIT);
-        Assert (RT_SUCCESS(vrc) || vrc == VERR_INTERRUPTED);
-
-        mIPCThread = NIL_RTTHREAD;
-    }
-
-    if (mIPCThreadSem != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy (mIPCThreadSem);
-        mIPCThreadSem = NIL_RTSEMEVENT;
-    }
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-    if (mIPCSem >= 0)
-    {
-        ::sembuf sop = { 0, 1, SEM_UNDO };
-        ::semop (mIPCSem, &sop, 1);
-
-        mIPCSem = -1;
-    }
-
-#else
-# error "Port me!"
-#endif
-}
-
-#if defined(RT_OS_WINDOWS)
-/** VM IPC mutex holder thread */
-DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    Assert (pvUser);
-    void **data = (void **) pvUser;
-
-    BSTR sessionId = (BSTR)data[0];
-    HANDLE initDoneSem = (HANDLE)data[1];
-
-    HANDLE ipcMutex = ::OpenMutex (MUTEX_ALL_ACCESS, FALSE, sessionId);
-    AssertMsg (ipcMutex, ("cannot open IPC mutex, err=%d\n", ::GetLastError()));
-
-    if (ipcMutex)
-    {
-        /* grab the mutex */
-        DWORD wrc = ::WaitForSingleObject (ipcMutex, 0);
-        AssertMsg (wrc == WAIT_OBJECT_0, ("cannot grab IPC mutex, err=%d\n", wrc));
-        if (wrc == WAIT_OBJECT_0)
-        {
-            HANDLE finishSem = ::CreateEvent (NULL, FALSE, FALSE, NULL);
-            AssertMsg (finishSem, ("cannot create event sem, err=%d\n", ::GetLastError()));
-            if (finishSem)
-            {
-                data[2] = (void*)finishSem;
-                /* signal we're done with init */
-                ::SetEvent (initDoneSem);
-                /* wait until we're signaled to release the IPC mutex */
-                ::WaitForSingleObject (finishSem, INFINITE);
-                /* release the IPC mutex */
-                LogFlow (("IPCMutexHolderThread(): releasing IPC mutex...\n"));
-                BOOL success = ::ReleaseMutex (ipcMutex);
-                AssertMsg (success, ("cannot release mutex, err=%d\n", ::GetLastError()));
-                ::CloseHandle (ipcMutex);
-                ::CloseHandle (finishSem);
-            }
-        }
-    }
-
-    /* signal we're done */
-    ::SetEvent (initDoneSem);
-
-    LogFlowFuncLeave();
-
-    return 0;
-}
-#endif
-
-#if defined(RT_OS_OS2)
-/** VM IPC mutex holder thread */
-DECLCALLBACK(int) IPCMutexHolderThread (RTTHREAD Thread, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    Assert (pvUser);
-    void **data = (void **) pvUser;
-
-    Utf8Str ipcId = (BSTR)data[0];
-    RTSEMEVENT finishSem = (RTSEMEVENT)data[1];
-
-    LogFlowFunc (("ipcId='%s', finishSem=%p\n", ipcId.raw(), finishSem));
-
-    HMTX ipcMutex = NULLHANDLE;
-    APIRET arc = ::DosOpenMutexSem ((PSZ) ipcId.raw(), &ipcMutex);
-    AssertMsg (arc == NO_ERROR, ("cannot open IPC mutex, arc=%ld\n", arc));
-
-    if (arc == NO_ERROR)
-    {
-        /* grab the mutex */
-        LogFlowFunc (("grabbing IPC mutex...\n"));
-        arc = ::DosRequestMutexSem (ipcMutex, SEM_IMMEDIATE_RETURN);
-        AssertMsg (arc == NO_ERROR, ("cannot grab IPC mutex, arc=%ld\n", arc));
-        if (arc == NO_ERROR)
-        {
-            /* store the answer */
-            data[2] = (void*)true;
-            /* signal we're done */
-            int vrc = RTThreadUserSignal (Thread);
-            AssertRC(vrc);
-
-            /* wait until we're signaled to release the IPC mutex */
-            LogFlowFunc (("waiting for termination signal..\n"));
-            vrc = RTSemEventWait (finishSem, RT_INDEFINITE_WAIT);
-            Assert (arc == ERROR_INTERRUPT || ERROR_TIMEOUT);
-
-            /* release the IPC mutex */
-            LogFlowFunc (("releasing IPC mutex...\n"));
-            arc = ::DosReleaseMutexSem (ipcMutex);
-            AssertMsg (arc == NO_ERROR, ("cannot release mutex, arc=%ld\n", arc));
-        }
-
-        ::DosCloseMutexSem (ipcMutex);
-    }
-
-    /* store the answer */
-    data[1] = (void*)false;
-    /* signal we're done */
-    int vrc = RTThreadUserSignal (Thread);
-    AssertRC(vrc);
-
-    LogFlowFuncLeave();
-
-    return 0;
-}
-#endif
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -1 @@
-/* $Id$ */
 /** @file
- * Implementation of IMachine in VBoxSVC.
+ *
+ * VirtualBox API client crash token handling
  */
 
@@ -16 +16 @@
  */
 
-/* Make sure all the stdint.h macros are included - must come first! */
-#ifndef __STDC_LIMIT_MACROS
-# define __STDC_LIMIT_MACROS
-#endif
-#ifndef __STDC_CONSTANT_MACROS
-# define __STDC_CONSTANT_MACROS
-#endif
+#include <iprt/asm.h>
+#include <iprt/assert.h>
+#include <iprt/log.h>
+#include <iprt/semaphore.h>
+#include <iprt/process.h>
 
 #ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
@@ -32 +30 @@
 #endif
 
-#include "Logging.h"
-#include "VirtualBoxImpl.h"
+#include <VBox/com/defs.h>
+
+#include <vector>
+
+#include "VirtualBoxBase.h"
+#include "AutoCaller.h"
+#include "ClientToken.h"
 #include "MachineImpl.h"
-#include "ProgressImpl.h"
-#include "ProgressProxyImpl.h"
-#include "MediumAttachmentImpl.h"
-#include "MediumImpl.h"
-#include "MediumLock.h"
-#include "USBControllerImpl.h"
-#include "USBDeviceFiltersImpl.h"
-#include "HostImpl.h"
-#include "SharedFolderImpl.h"
-#include "GuestOSTypeImpl.h"
-#include "VirtualBoxErrorInfoImpl.h"
-#include "GuestImpl.h"
-#include "StorageControllerImpl.h"
-#include "DisplayImpl.h"
-#include "DisplayUtils.h"
-#include "MachineImplCloneVM.h"
-#include "AutostartDb.h"
-#include "SystemPropertiesImpl.h"
-
-// generated header
-#include "VBoxEvents.h"
-
-#ifdef VBOX_WITH_USB
-# include "USBProxyService.h"
-#endif
-
-#include "AutoCaller.h"
-#include "HashedPw.h"
-#include "Performance.h"
-
-#include <iprt/asm.h>
-#include <iprt/path.h>
-#include <iprt/dir.h>
-#include <iprt/env.h>
-#include <iprt/lockvalidator.h>
-#include <iprt/process.h>
-#include <iprt/cpp/utils.h>
-#include <iprt/cpp/xml.h>               /* xml::XmlFileWriter::s_psz*Suff. */
-#include <iprt/sha.h>
-#include <iprt/string.h>
-#include <iprt/base64.h>
-
-#include <VBox/com/array.h>
-#include <VBox/com/list.h>
-
-#include <VBox/err.h>
-#include <VBox/param.h>
-#include <VBox/settings.h>
-#include <VBox/vmm/ssm.h>
-
-#ifdef VBOX_WITH_GUEST_PROPS
-# include <VBox/HostServices/GuestPropertySvc.h>
-# include <VBox/com/array.h>
-#endif
-
-#include "VBox/com/MultiResult.h"
-
-#include <algorithm>
-
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-# define HOSTSUFF_EXE ".exe"
-#else /* !RT_OS_WINDOWS */
-# define HOSTSUFF_EXE ""
-#endif /* !RT_OS_WINDOWS */
-
-// defines / prototypes
-/////////////////////////////////////////////////////////////////////////////
-
-/////////////////////////////////////////////////////////////////////////////
-// Machine::Data structure
-/////////////////////////////////////////////////////////////////////////////
-
-Machine::Data::Data()
-{
-    mRegistered                = FALSE;
-    pMachineConfigFile         = NULL;
-    /* Contains hints on what has changed when the user is using the VM (config
-     * changes, running the VM, ...). This is used to decide if a config needs
-     * to be written to disk. */
-    flModifications            = 0;
-    /* VM modification usually also trigger setting the current state to
-     * "Modified". Although this is not always the case. An e.g. is the VM
-     * initialization phase or when snapshot related data is changed. The
-     * actually behavior is controlled by the following flag. */
-    m_fAllowStateModification  = false;
-    mAccessible                = FALSE;
-    /* mUuid is initialized in Machine::init() */
-
-    mMachineState              = MachineState_PoweredOff;
-    RTTimeNow(&mLastStateChange);
-
-    mMachineStateDeps          = 0;
-    mMachineStateDepsSem       = NIL_RTSEMEVENTMULTI;
-    mMachineStateChangePending = 0;
-
-    mCurrentStateModified      = TRUE;
-    mGuestPropertiesModified   = FALSE;
-
-    mSession.mPID              = NIL_RTPROCESS;
-    mSession.mState            = SessionState_Unlocked;
-}
-
-Machine::Data::~Data()
-{
-    if (mMachineStateDepsSem != NIL_RTSEMEVENTMULTI)
-    {
-        RTSemEventMultiDestroy(mMachineStateDepsSem);
-        mMachineStateDepsSem = NIL_RTSEMEVENTMULTI;
-    }
-    if (pMachineConfigFile)
-    {
-        delete pMachineConfigFile;
-        pMachineConfigFile = NULL;
-    }
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Machine::HWData structure
-/////////////////////////////////////////////////////////////////////////////
-
-Machine::HWData::HWData()
-{
-    /* default values for a newly created machine */
-    mHWVersion = "2"; /** @todo get the default from the schema if that is possible. */
-    mMemorySize = 128;
-    mCPUCount = 1;
-    mCPUHotPlugEnabled = false;
-    mMemoryBalloonSize = 0;
-    mPageFusionEnabled = false;
-    mGraphicsControllerType = GraphicsControllerType_VBoxVGA;
-    mVRAMSize = 8;
-    mAccelerate3DEnabled = false;
-    mAccelerate2DVideoEnabled = false;
-    mMonitorCount = 1;
-    mVideoCaptureWidth = 1024;
-    mVideoCaptureHeight = 768;
-    mVideoCaptureRate = 512;
-    mVideoCaptureFPS = 25;
-    mVideoCaptureEnabled = false;
-    for (unsigned i = 0; i < RT_ELEMENTS(maVideoCaptureScreens); i++)
-        maVideoCaptureScreens[i] = true;
-
-    mHWVirtExEnabled = true;
-    mHWVirtExNestedPagingEnabled = true;
-#if HC_ARCH_BITS == 64 && !defined(RT_OS_LINUX)
-    mHWVirtExLargePagesEnabled = true;
-#else
-    /* Not supported on 32 bits hosts. */
-    mHWVirtExLargePagesEnabled = false;
-#endif
-    mHWVirtExVPIDEnabled = true;
-    mHWVirtExUXEnabled = true;
-    mHWVirtExForceEnabled = false;
-#if defined(RT_OS_DARWIN) || defined(RT_OS_WINDOWS)
-    mHWVirtExExclusive = false;
-#else
-    mHWVirtExExclusive = true;
-#endif
-#if HC_ARCH_BITS == 64 || defined(RT_OS_WINDOWS) || defined(RT_OS_DARWIN)
-    mPAEEnabled = true;
-#else
-    mPAEEnabled = false;
-#endif
-    mLongMode =  HC_ARCH_BITS == 64 ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
-    mSyntheticCpu = false;
-    mHPETEnabled = false;
-
-    /* default boot order: floppy - DVD - HDD */
-    mBootOrder[0] = DeviceType_Floppy;
-    mBootOrder[1] = DeviceType_DVD;
-    mBootOrder[2] = DeviceType_HardDisk;
-    for (size_t i = 3; i < RT_ELEMENTS(mBootOrder); ++i)
-        mBootOrder[i] = DeviceType_Null;
-
-    mClipboardMode = ClipboardMode_Disabled;
-    mDragAndDropMode = DragAndDropMode_Disabled;
-    mGuestPropertyNotificationPatterns = "";
-
-    mFirmwareType = FirmwareType_BIOS;
-    mKeyboardHIDType = KeyboardHIDType_PS2Keyboard;
-    mPointingHIDType = PointingHIDType_PS2Mouse;
-    mChipsetType = ChipsetType_PIIX3;
-    mEmulatedUSBWebcamEnabled = FALSE;
-    mEmulatedUSBCardReaderEnabled = FALSE;
-
-    for (size_t i = 0; i < RT_ELEMENTS(mCPUAttached); i++)
-        mCPUAttached[i] = false;
-
-    mIOCacheEnabled = true;
-    mIOCacheSize    = 5; /* 5MB */
-
-    /* Maximum CPU execution cap by default. */
-    mCpuExecutionCap = 100;
-}
-
-Machine::HWData::~HWData()
-{
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Machine::HDData structure
-/////////////////////////////////////////////////////////////////////////////
-
-Machine::MediaData::MediaData()
-{
-}
-
-Machine::MediaData::~MediaData()
-{
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Machine class
-/////////////////////////////////////////////////////////////////////////////
-
-// constructor / destructor
-/////////////////////////////////////////////////////////////////////////////
-
-Machine::Machine() :
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-    mCollectorGuest(NULL),
-#endif
-    mPeer(NULL),
-    mParent(NULL),
-    mSerialPorts(),
-    mParallelPorts(),
-    uRegistryNeedsSaving(0)
-{}
-
-Machine::~Machine()
-{}
-
-HRESULT Machine::FinalConstruct()
-{
-    LogFlowThisFunc(("\n"));
-    return BaseFinalConstruct();
-}
-
-void Machine::FinalRelease()
-{
-    LogFlowThisFunc(("\n"));
-    uninit();
-    BaseFinalRelease();
-}
-
-/**
- *  Initializes a new machine instance; this init() variant creates a new, empty machine.
- *  This gets called from VirtualBox::CreateMachine().
- *
- *  @param aParent      Associated parent object
- *  @param strConfigFile  Local file system path to the VM settings file (can
- *                      be relative to the VirtualBox config directory).
- *  @param strName      name for the machine
- *  @param llGroups     list of groups for the machine
- *  @param aOsType      OS Type of this machine or NULL.
- *  @param aId          UUID for the new machine.
- *  @param fForceOverwrite Whether to overwrite an existing machine settings file.
- *
- *  @return  Success indicator. if not S_OK, the machine object is invalid
- */
-HRESULT Machine::init(VirtualBox *aParent,
-                      const Utf8Str &strConfigFile,
-                      const Utf8Str &strName,
-                      const StringsList &llGroups,
-                      GuestOSType *aOsType,
-                      const Guid &aId,
-                      bool fForceOverwrite,
-                      bool fDirectoryIncludesUUID)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("(Init_New) aConfigFile='%s'\n", strConfigFile.c_str()));
-
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    HRESULT rc = initImpl(aParent, strConfigFile);
-    if (FAILED(rc)) return rc;
-
-    rc = tryCreateMachineConfigFile(fForceOverwrite);
-    if (FAILED(rc)) return rc;
-
-    if (SUCCEEDED(rc))
-    {
-        // create an empty machine config
-        mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
-
-        rc = initDataAndChildObjects();
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
-        mData->mAccessible = TRUE;
-
-        unconst(mData->mUuid) = aId;
-
-        mUserData->s.strName = strName;
-
-        mUserData->s.llGroups = llGroups;
-
-        mUserData->s.fDirectoryIncludesUUID = fDirectoryIncludesUUID;
-        // the "name sync" flag determines whether the machine directory gets renamed along
-        // with the machine file; say so if the settings file name is the same as the
-        // settings file parent directory (machine directory)
-        mUserData->s.fNameSync = isInOwnDir();
-
-        // initialize the default snapshots folder
-        rc = COMSETTER(SnapshotFolder)(NULL);
-        AssertComRC(rc);
-
-        if (aOsType)
-        {
-            /* Store OS type */
-            mUserData->s.strOsType = aOsType->id();
-
-            /* Apply BIOS defaults */
-            mBIOSSettings->applyDefaults(aOsType);
-
-            /* Apply network adapters defaults */
-            for (ULONG slot = 0; slot < mNetworkAdapters.size(); ++slot)
-                mNetworkAdapters[slot]->applyDefaults(aOsType);
-
-            /* Apply serial port defaults */
-            for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); ++slot)
-                mSerialPorts[slot]->applyDefaults(aOsType);
-
-            /* Let the OS type select 64-bit ness. */
-            mHWData->mLongMode = aOsType->is64Bit()
-                               ? settings::Hardware::LongMode_Enabled : settings::Hardware::LongMode_Disabled;
-        }
-
-        /* At this point the changing of the current state modification
-         * flag is allowed. */
-        allowStateModification();
-
-        /* commit all changes made during the initialization */
-        commit();
-    }
-
-    /* Confirm a successful initialization when it's the case */
-    if (SUCCEEDED(rc))
-    {
-        if (mData->mAccessible)
-            autoInitSpan.setSucceeded();
-        else
-            autoInitSpan.setLimited();
-    }
-
-    LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool, rc=%08X\n",
-                     !!mUserData ? mUserData->s.strName.c_str() : "NULL",
-                     mData->mRegistered,
-                     mData->mAccessible,
-                     rc));
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-/**
- *  Initializes a new instance with data from machine XML (formerly Init_Registered).
- *  Gets called in two modes:
- *
- *      -- from VirtualBox::initMachines() during VirtualBox startup; in that case, the
- *         UUID is specified and we mark the machine as "registered";
- *
- *      -- from the public VirtualBox::OpenMachine() API, in which case the UUID is NULL
- *         and the machine remains unregistered until RegisterMachine() is called.
- *
- *  @param aParent      Associated parent object
- *  @param aConfigFile  Local file system path to the VM settings file (can
- *                      be relative to the VirtualBox config directory).
- *  @param aId          UUID of the machine or NULL (see above).
- *
- *  @return  Success indicator. if not S_OK, the machine object is invalid
- */
-HRESULT Machine::initFromSettings(VirtualBox *aParent,
-                                  const Utf8Str &strConfigFile,
-                                  const Guid *aId)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("(Init_Registered) aConfigFile='%s\n", strConfigFile.c_str()));
-
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    HRESULT rc = initImpl(aParent, strConfigFile);
-    if (FAILED(rc)) return rc;
-
-    if (aId)
-    {
-        // loading a registered VM:
-        unconst(mData->mUuid) = *aId;
-        mData->mRegistered = TRUE;
-        // now load the settings from XML:
-        rc = registeredInit();
-            // this calls initDataAndChildObjects() and loadSettings()
-    }
-    else
-    {
-        // opening an unregistered VM (VirtualBox::OpenMachine()):
-        rc = initDataAndChildObjects();
-
-        if (SUCCEEDED(rc))
-        {
-            // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
-            mData->mAccessible = TRUE;
-
-            try
-            {
-                // load and parse machine XML; this will throw on XML or logic errors
-                mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
-
-                // reject VM UUID duplicates, they can happen if someone
-                // tries to register an already known VM config again
-                if (aParent->findMachine(mData->pMachineConfigFile->uuid,
-                                         true /* fPermitInaccessible */,
-                                         false /* aDoSetError */,
-                                         NULL) != VBOX_E_OBJECT_NOT_FOUND)
-                {
-                    throw setError(E_FAIL,
-                                   tr("Trying to open a VM config '%s' which has the same UUID as an existing virtual machine"),
-                                   mData->m_strConfigFile.c_str());
-                }
-
-                // use UUID from machine config
-                unconst(mData->mUuid) = mData->pMachineConfigFile->uuid;
-
-                rc = loadMachineDataFromSettings(*mData->pMachineConfigFile,
-                                                 NULL /* puuidRegistry */);
-                if (FAILED(rc)) throw rc;
-
-                /* At this point the changing of the current state modification
-                 * flag is allowed. */
-                allowStateModification();
-
-                commit();
-            }
-            catch (HRESULT err)
-            {
-                /* we assume that error info is set by the thrower */
-                rc = err;
-            }
-            catch (...)
-            {
-                rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-            }
-        }
-    }
-
-    /* Confirm a successful initialization when it's the case */
-    if (SUCCEEDED(rc))
-    {
-        if (mData->mAccessible)
-            autoInitSpan.setSucceeded();
-        else
-        {
-            autoInitSpan.setLimited();
-
-            // uninit media from this machine's media registry, or else
-            // reloading the settings will fail
-            mParent->unregisterMachineMedia(getId());
-        }
-    }
-
-    LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
-                      "rc=%08X\n",
-                      !!mUserData ? mUserData->s.strName.c_str() : "NULL",
-                      mData->mRegistered, mData->mAccessible, rc));
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-/**
- *  Initializes a new instance from a machine config that is already in memory
- *  (import OVF case). Since we are importing, the UUID in the machine
- *  config is ignored and we always generate a fresh one.
- *
- *  @param strName  Name for the new machine; this overrides what is specified in config and is used
- *                  for the settings file as well.
- *  @param config   Machine configuration loaded and parsed from XML.
- *
- *  @return  Success indicator. if not S_OK, the machine object is invalid
- */
-HRESULT Machine::init(VirtualBox *aParent,
-                      const Utf8Str &strName,
-                      const settings::MachineConfigFile &config)
-{
-    LogFlowThisFuncEnter();
-
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    Utf8Str strConfigFile;
-    aParent->getDefaultMachineFolder(strConfigFile);
-    strConfigFile.append(RTPATH_DELIMITER);
-    strConfigFile.append(strName);
-    strConfigFile.append(RTPATH_DELIMITER);
-    strConfigFile.append(strName);
-    strConfigFile.append(".vbox");
-
-    HRESULT rc = initImpl(aParent, strConfigFile);
-    if (FAILED(rc)) return rc;
-
-    rc = tryCreateMachineConfigFile(false /* fForceOverwrite */);
-    if (FAILED(rc)) return rc;
-
-    rc = initDataAndChildObjects();
-
-    if (SUCCEEDED(rc))
-    {
-        // set to true now to cause uninit() to call uninitDataAndChildObjects() on failure
-        mData->mAccessible = TRUE;
-
-        // create empty machine config for instance data
-        mData->pMachineConfigFile = new settings::MachineConfigFile(NULL);
-
-        // generate fresh UUID, ignore machine config
-        unconst(mData->mUuid).create();
-
-        rc = loadMachineDataFromSettings(config,
-                                         &mData->mUuid); // puuidRegistry: initialize media with this registry ID
-
-        // override VM name as well, it may be different
-        mUserData->s.strName = strName;
-
-        if (SUCCEEDED(rc))
-        {
-            /* At this point the changing of the current state modification
-             * flag is allowed. */
-            allowStateModification();
-
-            /* commit all changes made during the initialization */
-            commit();
-        }
-    }
-
-    /* Confirm a successful initialization when it's the case */
-    if (SUCCEEDED(rc))
-    {
-        if (mData->mAccessible)
-            autoInitSpan.setSucceeded();
-        else
-        {
-            autoInitSpan.setLimited();
-
-            // uninit media from this machine's media registry, or else
-            // reloading the settings will fail
-            mParent->unregisterMachineMedia(getId());
-        }
-    }
-
-    LogFlowThisFunc(("mName='%s', mRegistered=%RTbool, mAccessible=%RTbool "
-                     "rc=%08X\n",
-                      !!mUserData ? mUserData->s.strName.c_str() : "NULL",
-                      mData->mRegistered, mData->mAccessible, rc));
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-/**
- * Shared code between the various init() implementations.
- * @param aParent
- * @return
- */
-HRESULT Machine::initImpl(VirtualBox *aParent,
-                          const Utf8Str &strConfigFile)
-{
-    LogFlowThisFuncEnter();
-
-    AssertReturn(aParent, E_INVALIDARG);
-    AssertReturn(!strConfigFile.isEmpty(), E_INVALIDARG);
-
-    HRESULT rc = S_OK;
-
-    /* share the parent weakly */
-    unconst(mParent) = aParent;
-
-    /* allocate the essential machine data structure (the rest will be
-     * allocated later by initDataAndChildObjects() */
-    mData.allocate();
-
-    /* memorize the config file name (as provided) */
-    mData->m_strConfigFile = strConfigFile;
-
-    /* get the full file name */
-    int vrc1 = mParent->calculateFullPath(strConfigFile, mData->m_strConfigFileFull);
-    if (RT_FAILURE(vrc1))
-        return setError(VBOX_E_FILE_ERROR,
-                        tr("Invalid machine settings file name '%s' (%Rrc)"),
-                        strConfigFile.c_str(),
-                        vrc1);
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-/**
- * Tries to create a machine settings file in the path stored in the machine
- * instance data. Used when a new machine is created to fail gracefully if
- * the settings file could not be written (e.g. because machine dir is read-only).
- * @return
- */
-HRESULT Machine::tryCreateMachineConfigFile(bool fForceOverwrite)
-{
-    HRESULT rc = S_OK;
-
-    // when we create a new machine, we must be able to create the settings file
-    RTFILE f = NIL_RTFILE;
-    int vrc = RTFileOpen(&f, mData->m_strConfigFileFull.c_str(), RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE);
-    if (    RT_SUCCESS(vrc)
-         || vrc == VERR_SHARING_VIOLATION
-       )
-    {
-        if (RT_SUCCESS(vrc))
-            RTFileClose(f);
-        if (!fForceOverwrite)
-            rc = setError(VBOX_E_FILE_ERROR,
-                          tr("Machine settings file '%s' already exists"),
-                          mData->m_strConfigFileFull.c_str());
-        else
-        {
-            /* try to delete the config file, as otherwise the creation
-             * of a new settings file will fail. */
-            int vrc2 = RTFileDelete(mData->m_strConfigFileFull.c_str());
-            if (RT_FAILURE(vrc2))
-                rc = setError(VBOX_E_FILE_ERROR,
-                              tr("Could not delete the existing settings file '%s' (%Rrc)"),
-                              mData->m_strConfigFileFull.c_str(), vrc2);
-        }
-    }
-    else if (    vrc != VERR_FILE_NOT_FOUND
-              && vrc != VERR_PATH_NOT_FOUND
-            )
-        rc = setError(VBOX_E_FILE_ERROR,
-                      tr("Invalid machine settings file name '%s' (%Rrc)"),
-                      mData->m_strConfigFileFull.c_str(),
-                      vrc);
-    return rc;
-}
-
-/**
- *  Initializes the registered machine by loading the settings file.
- *  This method is separated from #init() in order to make it possible to
- *  retry the operation after VirtualBox startup instead of refusing to
- *  startup the whole VirtualBox server in case if the settings file of some
- *  registered VM is invalid or inaccessible.
- *
- *  @note Must be always called from this object's write lock
- *        (unless called from #init() that doesn't need any locking).
- *  @note Locks the mUSBController method for writing.
- *  @note Subclasses must not call this method.
- */
-HRESULT Machine::registeredInit()
-{
-    AssertReturn(!isSessionMachine(), E_FAIL);
-    AssertReturn(!isSnapshotMachine(), E_FAIL);
-    AssertReturn(mData->mUuid.isValid(), E_FAIL);
-    AssertReturn(!mData->mAccessible, E_FAIL);
-
-    HRESULT rc = initDataAndChildObjects();
-
-    if (SUCCEEDED(rc))
-    {
-        /* Temporarily reset the registered flag in order to let setters
-         * potentially called from loadSettings() succeed (isMutable() used in
-         * all setters will return FALSE for a Machine instance if mRegistered
-         * is TRUE). */
-        mData->mRegistered = FALSE;
-
-        try
-        {
-            // load and parse machine XML; this will throw on XML or logic errors
-            mData->pMachineConfigFile = new settings::MachineConfigFile(&mData->m_strConfigFileFull);
-
-            if (mData->mUuid != mData->pMachineConfigFile->uuid)
-                throw setError(E_FAIL,
-                               tr("Machine UUID {%RTuuid} in '%s' doesn't match its UUID {%s} in the registry file '%s'"),
-                               mData->pMachineConfigFile->uuid.raw(),
-                               mData->m_strConfigFileFull.c_str(),
-                               mData->mUuid.toString().c_str(),
-                               mParent->settingsFilePath().c_str());
-
-            rc = loadMachineDataFromSettings(*mData->pMachineConfigFile,
-                                             NULL /* const Guid *puuidRegistry */);
-            if (FAILED(rc)) throw rc;
-        }
-        catch (HRESULT err)
-        {
-            /* we assume that error info is set by the thrower */
-            rc = err;
-        }
-        catch (...)
-        {
-            rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-        }
-
-        /* Restore the registered flag (even on failure) */
-        mData->mRegistered = TRUE;
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        /* Set mAccessible to TRUE only if we successfully locked and loaded
-         * the settings file */
-        mData->mAccessible = TRUE;
-
-        /* commit all changes made during loading the settings file */
-        commit(); // @todo r=dj why do we need a commit during init?!? this is very expensive
-        /// @todo r=klaus for some reason the settings loading logic backs up
-        // the settings, and therefore a commit is needed. Should probably be changed.
-    }
-    else
-    {
-        /* If the machine is registered, then, instead of returning a
-         * failure, we mark it as inaccessible and set the result to
-         * success to give it a try later */
-
-        /* fetch the current error info */
-        mData->mAccessError = com::ErrorInfo();
-        LogWarning(("Machine {%RTuuid} is inaccessible! [%ls]\n",
-                    mData->mUuid.raw(),
-                    mData->mAccessError.getText().raw()));
-
-        /* rollback all changes */
-        rollback(false /* aNotify */);
-
-        // uninit media from this machine's media registry, or else
-        // reloading the settings will fail
-        mParent->unregisterMachineMedia(getId());
-
-        /* uninitialize the common part to make sure all data is reset to
-         * default (null) values */
-        uninitDataAndChildObjects();
-
-        rc = S_OK;
-    }
-
-    return rc;
-}
-
-/**
- *  Uninitializes the instance.
- *  Called either from FinalRelease() or by the parent when it gets destroyed.
- *
- *  @note The caller of this method must make sure that this object
- *  a) doesn't have active callers on the current thread and b) is not locked
- *  by the current thread; otherwise uninit() will hang either a) due to
- *  AutoUninitSpan waiting for a number of calls to drop to zero or b) due to
- *  a dead-lock caused by this thread waiting for all callers on the other
- *  threads are done but preventing them from doing so by holding a lock.
- */
-void Machine::uninit()
-{
-    LogFlowThisFuncEnter();
-
-    Assert(!isWriteLockOnCurrentThread());
-
-    Assert(!uRegistryNeedsSaving);
-    if (uRegistryNeedsSaving)
-    {
-        AutoCaller autoCaller(this);
-        if (SUCCEEDED(autoCaller.rc()))
-        {
-            AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-            saveSettings(NULL, Machine::SaveS_Force);
-        }
-    }
-
-    /* Enclose the state transition Ready->InUninit->NotReady */
-    AutoUninitSpan autoUninitSpan(this);
-    if (autoUninitSpan.uninitDone())
-        return;
-
-    Assert(!isSnapshotMachine());
-    Assert(!isSessionMachine());
-    Assert(!!mData);
-
-    LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
-    LogFlowThisFunc(("mRegistered=%d\n", mData->mRegistered));
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mData->mSession.mMachine.isNull())
-    {
-        /* Theoretically, this can only happen if the VirtualBox server has been
-         * terminated while there were clients running that owned open direct
-         * sessions. Since in this case we are definitely called by
-         * VirtualBox::uninit(), we may be sure that SessionMachine::uninit()
-         * won't happen on the client watcher thread (because it does
-         * VirtualBox::addCaller() for the duration of the
-         * SessionMachine::checkForDeath() call, so that VirtualBox::uninit()
-         * cannot happen until the VirtualBox caller is released). This is
-         * important, because SessionMachine::uninit() cannot correctly operate
-         * after we return from this method (it expects the Machine instance is
-         * still valid). We'll call it ourselves below.
-         */
-        LogWarningThisFunc(("Session machine is not NULL (%p), the direct session is still open!\n",
-                            (SessionMachine*)mData->mSession.mMachine));
-
-        if (Global::IsOnlineOrTransient(mData->mMachineState))
-        {
-            LogWarningThisFunc(("Setting state to Aborted!\n"));
-            /* set machine state using SessionMachine reimplementation */
-            static_cast<Machine*>(mData->mSession.mMachine)->setMachineState(MachineState_Aborted);
-        }
-
-        /*
-         *  Uninitialize SessionMachine using public uninit() to indicate
-         *  an unexpected uninitialization.
-         */
-        mData->mSession.mMachine->uninit();
-        /* SessionMachine::uninit() must set mSession.mMachine to null */
-        Assert(mData->mSession.mMachine.isNull());
-    }
-
-    // uninit media from this machine's media registry, if they're still there
-    Guid uuidMachine(getId());
-
-    /* the lock is no more necessary (SessionMachine is uninitialized) */
-    alock.release();
-
-    /* XXX This will fail with
-     *   "cannot be closed because it is still attached to 1 virtual machines"
-     * because at this point we did not call uninitDataAndChildObjects() yet
-     * and therefore also removeBackReference() for all these mediums was not called! */
-
-    if (uuidMachine.isValid() && !uuidMachine.isZero())     // can be empty if we're called from a failure of Machine::init
-        mParent->unregisterMachineMedia(uuidMachine);
-
-    // has machine been modified?
-    if (mData->flModifications)
-    {
-        LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
-        rollback(false /* aNotify */);
-    }
-
-    if (mData->mAccessible)
-        uninitDataAndChildObjects();
-
-    /* free the essential data structure last */
-    mData.free();
-
-    LogFlowThisFuncLeave();
-}
-
-// IMachine properties
-/////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP Machine::COMGETTER(Parent)(IVirtualBox **aParent)
-{
-    CheckComArgOutPointerValid(aParent);
-
-    AutoLimitedCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mParent is constant during life time, no need to lock */
-    ComObjPtr<VirtualBox> pVirtualBox(mParent);
-    pVirtualBox.queryInterfaceTo(aParent);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(Accessible)(BOOL *aAccessible)
-{
-    CheckComArgOutPointerValid(aAccessible);
-
-    AutoLimitedCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    LogFlowThisFunc(("ENTER\n"));
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-
-    if (!mData->mAccessible)
-    {
-        /* try to initialize the VM once more if not accessible */
-
-        AutoReinitSpan autoReinitSpan(this);
-        AssertReturn(autoReinitSpan.isOk(), E_FAIL);
-
-#ifdef DEBUG
-        LogFlowThisFunc(("Dumping media backreferences\n"));
-        mParent->dumpAllBackRefs();
-#endif
-
-        if (mData->pMachineConfigFile)
-        {
-            // reset the XML file to force loadSettings() (called from registeredInit())
-            // to parse it again; the file might have changed
-            delete mData->pMachineConfigFile;
-            mData->pMachineConfigFile = NULL;
-        }
-
-        rc = registeredInit();
-
-        if (SUCCEEDED(rc) && mData->mAccessible)
-        {
-            autoReinitSpan.setSucceeded();
-
-            /* make sure interesting parties will notice the accessibility
-             * state change */
-            mParent->onMachineStateChange(mData->mUuid, mData->mMachineState);
-            mParent->onMachineDataChange(mData->mUuid);
-        }
-    }
-
-    if (SUCCEEDED(rc))
-        *aAccessible = mData->mAccessible;
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-STDMETHODIMP Machine::COMGETTER(AccessError)(IVirtualBoxErrorInfo **aAccessError)
-{
-    CheckComArgOutPointerValid(aAccessError);
-
-    AutoLimitedCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mData->mAccessible || !mData->mAccessError.isBasicAvailable())
-    {
-        /* return shortly */
-        aAccessError = NULL;
-        return S_OK;
-    }
-
-    HRESULT rc = S_OK;
-
-    ComObjPtr<VirtualBoxErrorInfo> errorInfo;
-    rc = errorInfo.createObject();
-    if (SUCCEEDED(rc))
-    {
-        errorInfo->init(mData->mAccessError.getResultCode(),
-                        mData->mAccessError.getInterfaceID().ref(),
-                        Utf8Str(mData->mAccessError.getComponent()).c_str(),
-                        Utf8Str(mData->mAccessError.getText()));
-        rc = errorInfo.queryInterfaceTo(aAccessError);
-    }
-
-    return rc;
-}
-
-STDMETHODIMP Machine::COMGETTER(Name)(BSTR *aName)
-{
-    CheckComArgOutPointerValid(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mUserData->s.strName.cloneTo(aName);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(Name)(IN_BSTR aName)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    // prohibit setting a UUID only as the machine name, or else it can
-    // never be found by findMachine()
-    Guid test(aName);
-
-    if (test.isValid())
-        return setError(E_INVALIDARG, tr("A machine cannot have a UUID as its name"));
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.strName = aName;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(Description)(BSTR *aDescription)
-{
-    CheckComArgOutPointerValid(aDescription);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mUserData->s.strDescription.cloneTo(aDescription);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(Description)(IN_BSTR aDescription)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    // this can be done in principle in any state as it doesn't affect the VM
-    // significantly, but play safe by not messing around while complex
-    // activities are going on
-    HRESULT rc = checkStateDependency(MutableOrSavedStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.strDescription = aDescription;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(Id)(BSTR *aId)
-{
-    CheckComArgOutPointerValid(aId);
-
-    AutoLimitedCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mData->mUuid.toUtf16().cloneTo(aId);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(Groups)(ComSafeArrayOut(BSTR, aGroups))
-{
-    CheckComArgOutSafeArrayPointerValid(aGroups);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    SafeArray<BSTR> groups(mUserData->s.llGroups.size());
-    size_t i = 0;
-    for (StringsList::const_iterator it = mUserData->s.llGroups.begin();
-         it != mUserData->s.llGroups.end();
-         ++it, i++)
-    {
-        Bstr tmp = *it;
-        tmp.cloneTo(&groups[i]);
-    }
-    groups.detachTo(ComSafeArrayOutArg(aGroups));
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(Groups)(ComSafeArrayIn(IN_BSTR, aGroups))
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    StringsList llGroups;
-    HRESULT rc = mParent->convertMachineGroups(ComSafeArrayInArg(aGroups), &llGroups);
-    if (FAILED(rc))
-        return rc;
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    // changing machine groups is possible while the VM is offline
-    rc = checkStateDependency(OfflineStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.llGroups = llGroups;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(OSTypeId)(BSTR *aOSTypeId)
-{
-    CheckComArgOutPointerValid(aOSTypeId);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mUserData->s.strOsType.cloneTo(aOSTypeId);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(OSTypeId)(IN_BSTR aOSTypeId)
-{
-    CheckComArgStrNotEmptyOrNull(aOSTypeId);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* look up the object by Id to check it is valid */
-    ComPtr<IGuestOSType> guestOSType;
-    HRESULT rc = mParent->GetGuestOSType(aOSTypeId, guestOSType.asOutParam());
-    if (FAILED(rc)) return rc;
-
-    /* when setting, always use the "etalon" value for consistency -- lookup
-     * by ID is case-insensitive and the input value may have different case */
-    Bstr osTypeId;
-    rc = guestOSType->COMGETTER(Id)(osTypeId.asOutParam());
-    if (FAILED(rc)) return rc;
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.strOsType = osTypeId;
-
-    return S_OK;
-}
-
-
-STDMETHODIMP Machine::COMGETTER(FirmwareType)(FirmwareType_T *aFirmwareType)
-{
-    CheckComArgOutPointerValid(aFirmwareType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aFirmwareType = mHWData->mFirmwareType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(FirmwareType)(FirmwareType_T aFirmwareType)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mFirmwareType = aFirmwareType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(KeyboardHIDType)(KeyboardHIDType_T *aKeyboardHIDType)
-{
-    CheckComArgOutPointerValid(aKeyboardHIDType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aKeyboardHIDType = mHWData->mKeyboardHIDType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(KeyboardHIDType)(KeyboardHIDType_T  aKeyboardHIDType)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mKeyboardHIDType = aKeyboardHIDType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(PointingHIDType)(PointingHIDType_T *aPointingHIDType)
-{
-    CheckComArgOutPointerValid(aPointingHIDType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aPointingHIDType = mHWData->mPointingHIDType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(PointingHIDType)(PointingHIDType_T  aPointingHIDType)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mPointingHIDType = aPointingHIDType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(ChipsetType)(ChipsetType_T *aChipsetType)
-{
-    CheckComArgOutPointerValid(aChipsetType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aChipsetType = mHWData->mChipsetType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(ChipsetType)(ChipsetType_T aChipsetType)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    if (aChipsetType != mHWData->mChipsetType)
-    {
-        setModified(IsModified_MachineData);
-        mHWData.backup();
-        mHWData->mChipsetType = aChipsetType;
-
-        // Resize network adapter array, to be finalized on commit/rollback.
-        // We must not throw away entries yet, otherwise settings are lost
-        // without a way to roll back.
-        size_t newCount = Global::getMaxNetworkAdapters(aChipsetType);
-        size_t oldCount = mNetworkAdapters.size();
-        if (newCount > oldCount)
-        {
-            mNetworkAdapters.resize(newCount);
-            for (ULONG slot = oldCount; slot < mNetworkAdapters.size(); slot++)
-            {
-                unconst(mNetworkAdapters[slot]).createObject();
-                mNetworkAdapters[slot]->init(this, slot);
-            }
-        }
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(HardwareVersion)(BSTR *aHWVersion)
-{
-    CheckComArgOutPointerValid(aHWVersion);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mHWData->mHWVersion.cloneTo(aHWVersion);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(HardwareVersion)(IN_BSTR aHWVersion)
-{
-    /* check known version */
-    Utf8Str hwVersion = aHWVersion;
-    if (    hwVersion.compare("1") != 0
-        &&  hwVersion.compare("2") != 0)
-        return setError(E_INVALIDARG,
-                        tr("Invalid hardware version: %ls\n"), aHWVersion);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mHWVersion = hwVersion;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(HardwareUUID)(BSTR *aUUID)
-{
-    CheckComArgOutPointerValid(aUUID);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mHWData->mHardwareUUID.isValid())
-        mHWData->mHardwareUUID.toUtf16().cloneTo(aUUID);
-    else
-        mData->mUuid.toUtf16().cloneTo(aUUID);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(HardwareUUID)(IN_BSTR aUUID)
-{
-    Guid hardwareUUID(aUUID);
-    if (!hardwareUUID.isValid())
-        return E_INVALIDARG;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    if (hardwareUUID == mData->mUuid)
-        mHWData->mHardwareUUID.clear();
-    else
-        mHWData->mHardwareUUID = hardwareUUID;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(MemorySize)(ULONG *memorySize)
-{
-    CheckComArgOutPointerValid(memorySize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *memorySize = mHWData->mMemorySize;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(MemorySize)(ULONG memorySize)
-{
-    /* check RAM limits */
-    if (    memorySize < MM_RAM_MIN_IN_MB
-         || memorySize > MM_RAM_MAX_IN_MB
-       )
-        return setError(E_INVALIDARG,
-                        tr("Invalid RAM size: %lu MB (must be in range [%lu, %lu] MB)"),
-                        memorySize, MM_RAM_MIN_IN_MB, MM_RAM_MAX_IN_MB);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mMemorySize = memorySize;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(CPUCount)(ULONG *CPUCount)
-{
-    CheckComArgOutPointerValid(CPUCount);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *CPUCount = mHWData->mCPUCount;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(CPUCount)(ULONG CPUCount)
-{
-    /* check CPU limits */
-    if (    CPUCount < SchemaDefs::MinCPUCount
-         || CPUCount > SchemaDefs::MaxCPUCount
-       )
-        return setError(E_INVALIDARG,
-                        tr("Invalid virtual CPU count: %lu (must be in range [%lu, %lu])"),
-                        CPUCount, SchemaDefs::MinCPUCount, SchemaDefs::MaxCPUCount);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* We cant go below the current number of CPUs attached if hotplug is enabled*/
-    if (mHWData->mCPUHotPlugEnabled)
-    {
-        for (unsigned idx = CPUCount; idx < SchemaDefs::MaxCPUCount; idx++)
-        {
-            if (mHWData->mCPUAttached[idx])
-                return setError(E_INVALIDARG,
-                                tr("There is still a CPU attached to socket %lu."
-                                   "Detach the CPU before removing the socket"),
-                                CPUCount, idx+1);
-        }
-    }
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mCPUCount = CPUCount;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(CPUExecutionCap)(ULONG *aExecutionCap)
-{
-    CheckComArgOutPointerValid(aExecutionCap);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aExecutionCap = mHWData->mCpuExecutionCap;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(CPUExecutionCap)(ULONG aExecutionCap)
-{
-    HRESULT rc = S_OK;
-
-    /* check throttle limits */
-    if (    aExecutionCap < 1
-         || aExecutionCap > 100
-       )
-        return setError(E_INVALIDARG,
-                        tr("Invalid CPU execution cap value: %lu (must be in range [%lu, %lu])"),
-                        aExecutionCap, 1, 100);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    alock.release();
-    rc = onCPUExecutionCapChange(aExecutionCap);
-    alock.acquire();
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mCpuExecutionCap = aExecutionCap;
-
-    /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-    if (Global::IsOnline(mData->mMachineState))
-        saveSettings(NULL);
-
-    return S_OK;
-}
-
-
-STDMETHODIMP Machine::COMGETTER(CPUHotPlugEnabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mCPUHotPlugEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(CPUHotPlugEnabled)(BOOL aEnabled)
-{
-    HRESULT rc = S_OK;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    if (mHWData->mCPUHotPlugEnabled != aEnabled)
-    {
-        if (aEnabled)
-        {
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-
-            /* Add the amount of CPUs currently attached */
-            for (unsigned i = 0; i < mHWData->mCPUCount; i++)
-            {
-                mHWData->mCPUAttached[i] = true;
-            }
-        }
-        else
-        {
-            /*
-             * We can disable hotplug only if the amount of maximum CPUs is equal
-             * to the amount of attached CPUs
-             */
-            unsigned cCpusAttached = 0;
-            unsigned iHighestId = 0;
-
-            for (unsigned i = 0; i < SchemaDefs::MaxCPUCount; i++)
-            {
-                if (mHWData->mCPUAttached[i])
-                {
-                    cCpusAttached++;
-                    iHighestId = i;
-                }
-            }
-
-            if (   (cCpusAttached != mHWData->mCPUCount)
-                || (iHighestId >= mHWData->mCPUCount))
-                return setError(E_INVALIDARG,
-                                tr("CPU hotplugging can't be disabled because the maximum number of CPUs is not equal to the amount of CPUs attached"));
-
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-        }
-    }
-
-    mHWData->mCPUHotPlugEnabled = aEnabled;
-
-    return rc;
-}
-
-STDMETHODIMP Machine::COMGETTER(EmulatedUSBCardReaderEnabled)(BOOL *aEnabled)
-{
-#ifdef VBOX_WITH_USB_CARDREADER
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mEmulatedUSBCardReaderEnabled;
-
-    return S_OK;
-#else
-    NOREF(aEnabled);
-    return E_NOTIMPL;
-#endif
-}
-
-STDMETHODIMP Machine::COMSETTER(EmulatedUSBCardReaderEnabled)(BOOL aEnabled)
-{
-#ifdef VBOX_WITH_USB_CARDREADER
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mEmulatedUSBCardReaderEnabled = aEnabled;
-
-    return S_OK;
-#else
-    NOREF(aEnabled);
-    return E_NOTIMPL;
-#endif
-}
-
-STDMETHODIMP Machine::COMGETTER(EmulatedUSBWebcameraEnabled)(BOOL *aEnabled)
-{
-#ifdef VBOX_WITH_USB_VIDEO
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mEmulatedUSBWebcamEnabled;
-
-    return S_OK;
-#else
-    NOREF(aEnabled);
-    return E_NOTIMPL;
-#endif
-}
-
-STDMETHODIMP Machine::COMSETTER(EmulatedUSBWebcameraEnabled)(BOOL aEnabled)
-{
-#ifdef VBOX_WITH_USB_VIDEO
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mEmulatedUSBWebcamEnabled = aEnabled;
-
-    return S_OK;
-#else
-    NOREF(aEnabled);
-    return E_NOTIMPL;
-#endif
-}
-
-STDMETHODIMP Machine::COMGETTER(HPETEnabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mHPETEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(HPETEnabled)(BOOL aEnabled)
-{
-    HRESULT rc = S_OK;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-
-    mHWData->mHPETEnabled = aEnabled;
-
-    return rc;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureEnabled)(BOOL *fEnabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *fEnabled = mHWData->mVideoCaptureEnabled;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureEnabled)(BOOL fEnabled)
-{
-    HRESULT rc = S_OK;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVideoCaptureEnabled = fEnabled;
-
-    alock.release();
-    rc = onVideoCaptureChange();
-    alock.acquire();
-    if (FAILED(rc))
-    {
-        /*
-         * Normally we would do the actual change _after_ onVideoCaptureChange() succeeded.
-         * We cannot do this because that function uses Machine::GetVideoCaptureEnabled to
-         * determine if it should start or stop capturing. Therefore we need to manually
-         * undo change.
-         */
-        mHWData->mVideoCaptureEnabled = mHWData.backedUpData()->mVideoCaptureEnabled;
-        return rc;
-    }
-
-    /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-    if (Global::IsOnline(mData->mMachineState))
-        saveSettings(NULL);
-
-    return rc;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureScreens)(ComSafeArrayOut(BOOL, aScreens))
-{
-    CheckComArgOutSafeArrayPointerValid(aScreens);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    SafeArray<BOOL> screens(mHWData->mMonitorCount);
-    for (unsigned i = 0; i < screens.size(); i++)
-        screens[i] = mHWData->maVideoCaptureScreens[i];
-    screens.detachTo(ComSafeArrayOutArg(aScreens));
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureScreens)(ComSafeArrayIn(BOOL, aScreens))
-{
-    SafeArray<BOOL> screens(ComSafeArrayInArg(aScreens));
-    AssertReturn(screens.size() <= RT_ELEMENTS(mHWData->maVideoCaptureScreens), E_INVALIDARG);
-    bool fChanged = false;
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    for (unsigned i = 0; i < screens.size(); i++)
-    {
-        if (mHWData->maVideoCaptureScreens[i] != RT_BOOL(screens[i]))
-        {
-            mHWData->maVideoCaptureScreens[i] = RT_BOOL(screens[i]);
-            fChanged = true;
-        }
-    }
-    if (fChanged)
-    {
-        alock.release();
-        HRESULT rc = onVideoCaptureChange();
-        alock.acquire();
-        if (FAILED(rc)) return rc;
-        setModified(IsModified_MachineData);
-
-        /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-        if (Global::IsOnline(mData->mMachineState))
-            saveSettings(NULL);
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureFile)(BSTR *apFile)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    if (mHWData->mVideoCaptureFile.isEmpty())
-    {
-        Utf8Str defaultFile;
-        getDefaultVideoCaptureFile(defaultFile);
-        defaultFile.cloneTo(apFile);
-    }
-    else
-        mHWData->mVideoCaptureFile.cloneTo(apFile);
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureFile)(IN_BSTR aFile)
-{
-    Utf8Str strFile(aFile);
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (   Global::IsOnline(mData->mMachineState)
-        && mHWData->mVideoCaptureEnabled)
-        return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
-
-    if (!RTPathStartsWithRoot(strFile.c_str()))
-        return setError(E_INVALIDARG, tr("Video capture file name '%s' is not absolute"), strFile.c_str());
-
-    if (!strFile.isEmpty())
-    {
-        Utf8Str defaultFile;
-        getDefaultVideoCaptureFile(defaultFile);
-        if (!RTPathCompare(strFile.c_str(), defaultFile.c_str()))
-            strFile.setNull();
-    }
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVideoCaptureFile = strFile;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureWidth)(ULONG *aHorzRes)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    *aHorzRes = mHWData->mVideoCaptureWidth;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureWidth)(ULONG aHorzRes)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (   Global::IsOnline(mData->mMachineState)
-        && mHWData->mVideoCaptureEnabled)
-        return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVideoCaptureWidth = aHorzRes;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureHeight)(ULONG *aVertRes)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-     *aVertRes = mHWData->mVideoCaptureHeight;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureHeight)(ULONG aVertRes)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (   Global::IsOnline(mData->mMachineState)
-        && mHWData->mVideoCaptureEnabled)
-        return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVideoCaptureHeight = aVertRes;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureRate)(ULONG *aRate)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-     *aRate = mHWData->mVideoCaptureRate;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureRate)(ULONG aRate)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (   Global::IsOnline(mData->mMachineState)
-        && mHWData->mVideoCaptureEnabled)
-        return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVideoCaptureRate = aRate;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VideoCaptureFPS)(ULONG *aFPS)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-     *aFPS = mHWData->mVideoCaptureFPS;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VideoCaptureFPS)(ULONG aFPS)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (   Global::IsOnline(mData->mMachineState)
-        && mHWData->mVideoCaptureEnabled)
-        return setError(E_INVALIDARG, tr("Cannot change parameters while capturing is enabled"));
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVideoCaptureFPS = aFPS;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(GraphicsControllerType)(GraphicsControllerType_T *aGraphicsControllerType)
-{
-    CheckComArgOutPointerValid(aGraphicsControllerType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aGraphicsControllerType = mHWData->mGraphicsControllerType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(GraphicsControllerType)(GraphicsControllerType_T aGraphicsControllerType)
-{
-    switch (aGraphicsControllerType)
-    {
-        case GraphicsControllerType_Null:
-        case GraphicsControllerType_VBoxVGA:
-            break;
-        default:
-            return setError(E_INVALIDARG, tr("The graphics controller type (%d) is invalid"), aGraphicsControllerType);
-    }
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mGraphicsControllerType = aGraphicsControllerType;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VRAMSize)(ULONG *memorySize)
-{
-    CheckComArgOutPointerValid(memorySize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *memorySize = mHWData->mVRAMSize;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(VRAMSize)(ULONG memorySize)
-{
-    /* check VRAM limits */
-    if (memorySize < SchemaDefs::MinGuestVRAM ||
-        memorySize > SchemaDefs::MaxGuestVRAM)
-        return setError(E_INVALIDARG,
-                        tr("Invalid VRAM size: %lu MB (must be in range [%lu, %lu] MB)"),
-                        memorySize, SchemaDefs::MinGuestVRAM, SchemaDefs::MaxGuestVRAM);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mVRAMSize = memorySize;
-
-    return S_OK;
-}
-
-/** @todo this method should not be public */
-STDMETHODIMP Machine::COMGETTER(MemoryBalloonSize)(ULONG *memoryBalloonSize)
-{
-    CheckComArgOutPointerValid(memoryBalloonSize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *memoryBalloonSize = mHWData->mMemoryBalloonSize;
-
-    return S_OK;
-}
-
-/**
- * Set the memory balloon size.
- *
- * This method is also called from IGuest::COMSETTER(MemoryBalloonSize) so
- * we have to make sure that we never call IGuest from here.
- */
-STDMETHODIMP Machine::COMSETTER(MemoryBalloonSize)(ULONG memoryBalloonSize)
-{
-    /* This must match GMMR0Init; currently we only support memory ballooning on all 64-bit hosts except Mac OS X */
-#if HC_ARCH_BITS == 64 && (defined(RT_OS_WINDOWS) || defined(RT_OS_SOLARIS) || defined(RT_OS_LINUX) || defined(RT_OS_FREEBSD))
-    /* check limits */
-    if (memoryBalloonSize >= VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize))
-        return setError(E_INVALIDARG,
-                        tr("Invalid memory balloon size: %lu MB (must be in range [%lu, %lu] MB)"),
-                        memoryBalloonSize, 0, VMMDEV_MAX_MEMORY_BALLOON(mHWData->mMemorySize));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mMemoryBalloonSize = memoryBalloonSize;
-
-    return S_OK;
-#else
-    NOREF(memoryBalloonSize);
-    return setError(E_NOTIMPL, tr("Memory ballooning is only supported on 64-bit hosts"));
-#endif
-}
-
-STDMETHODIMP Machine::COMGETTER(PageFusionEnabled) (BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mPageFusionEnabled;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(PageFusionEnabled) (BOOL aEnabled)
-{
-#ifdef VBOX_WITH_PAGE_SHARING
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /** @todo must support changes for running vms and keep this in sync with IGuest. */
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mPageFusionEnabled = aEnabled;
-    return S_OK;
-#else
-    NOREF(aEnabled);
-    return setError(E_NOTIMPL, tr("Page fusion is only supported on 64-bit hosts"));
-#endif
-}
-
-STDMETHODIMP Machine::COMGETTER(Accelerate3DEnabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mAccelerate3DEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(Accelerate3DEnabled)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    /** @todo check validity! */
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mAccelerate3DEnabled = enable;
-
-    return S_OK;
-}
-
-
-STDMETHODIMP Machine::COMGETTER(Accelerate2DVideoEnabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mAccelerate2DVideoEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(Accelerate2DVideoEnabled)(BOOL enable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    /** @todo check validity! */
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mAccelerate2DVideoEnabled = enable;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(MonitorCount)(ULONG *monitorCount)
-{
-    CheckComArgOutPointerValid(monitorCount);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *monitorCount = mHWData->mMonitorCount;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(MonitorCount)(ULONG monitorCount)
-{
-    /* make sure monitor count is a sensible number */
-    if (monitorCount < 1 || monitorCount > SchemaDefs::MaxGuestMonitors)
-        return setError(E_INVALIDARG,
-                        tr("Invalid monitor count: %lu (must be in range [%lu, %lu])"),
-                        monitorCount, 1, SchemaDefs::MaxGuestMonitors);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mMonitorCount = monitorCount;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(BIOSSettings)(IBIOSSettings **biosSettings)
-{
-    CheckComArgOutPointerValid(biosSettings);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mBIOSSettings is constant during life time, no need to lock */
-    mBIOSSettings.queryInterfaceTo(biosSettings);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetCPUProperty(CPUPropertyType_T property, BOOL *aVal)
-{
-    CheckComArgOutPointerValid(aVal);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    switch (property)
-    {
-        case CPUPropertyType_PAE:
-            *aVal = mHWData->mPAEEnabled;
-            break;
-
-        case CPUPropertyType_Synthetic:
-            *aVal = mHWData->mSyntheticCpu;
-            break;
-
-        case CPUPropertyType_LongMode:
-            if (mHWData->mLongMode == settings::Hardware::LongMode_Enabled)
-                *aVal = TRUE;
-            else if (mHWData->mLongMode == settings::Hardware::LongMode_Disabled)
-                *aVal = FALSE;
-#if HC_ARCH_BITS == 64
-            else
-                *aVal = TRUE;
-#else
-            else
-            {
-                *aVal = FALSE;
-
-                ComPtr<IGuestOSType> ptrGuestOSType;
-                HRESULT hrc2 = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(), ptrGuestOSType.asOutParam());
-                if (SUCCEEDED(hrc2))
-                {
-                    BOOL fIs64Bit = FALSE;
-                    hrc2 = ptrGuestOSType->COMGETTER(Is64Bit)(&fIs64Bit); AssertComRC(hrc2);
-                    if (SUCCEEDED(hrc2) && fIs64Bit)
-                    {
-                        ComObjPtr<Host> ptrHost = mParent->host();
-                        alock.release();
-
-                        hrc2 = ptrHost->GetProcessorFeature(ProcessorFeature_LongMode, aVal); AssertComRC(hrc2);
-                        if (FAILED(hrc2))
-                            *aVal = FALSE;
-                    }
-                }
-            }
-#endif
-            break;
-
-        default:
-            return E_INVALIDARG;
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SetCPUProperty(CPUPropertyType_T property, BOOL aVal)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    switch (property)
-    {
-        case CPUPropertyType_PAE:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mPAEEnabled = !!aVal;
-            break;
-
-        case CPUPropertyType_Synthetic:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mSyntheticCpu = !!aVal;
-            break;
-
-        case CPUPropertyType_LongMode:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mLongMode = !aVal ? settings::Hardware::LongMode_Disabled : settings::Hardware::LongMode_Enabled;
-            break;
-
-        default:
-            return E_INVALIDARG;
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetCPUIDLeaf(ULONG aId, ULONG *aValEax, ULONG *aValEbx, ULONG *aValEcx, ULONG *aValEdx)
-{
-    CheckComArgOutPointerValid(aValEax);
-    CheckComArgOutPointerValid(aValEbx);
-    CheckComArgOutPointerValid(aValEcx);
-    CheckComArgOutPointerValid(aValEdx);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    switch(aId)
-    {
-        case 0x0:
-        case 0x1:
-        case 0x2:
-        case 0x3:
-        case 0x4:
-        case 0x5:
-        case 0x6:
-        case 0x7:
-        case 0x8:
-        case 0x9:
-        case 0xA:
-            if (mHWData->mCpuIdStdLeafs[aId].ulId != aId)
-                return E_INVALIDARG;
-
-            *aValEax = mHWData->mCpuIdStdLeafs[aId].ulEax;
-            *aValEbx = mHWData->mCpuIdStdLeafs[aId].ulEbx;
-            *aValEcx = mHWData->mCpuIdStdLeafs[aId].ulEcx;
-            *aValEdx = mHWData->mCpuIdStdLeafs[aId].ulEdx;
-            break;
-
-        case 0x80000000:
-        case 0x80000001:
-        case 0x80000002:
-        case 0x80000003:
-        case 0x80000004:
-        case 0x80000005:
-        case 0x80000006:
-        case 0x80000007:
-        case 0x80000008:
-        case 0x80000009:
-        case 0x8000000A:
-            if (mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId != aId)
-                return E_INVALIDARG;
-
-            *aValEax = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax;
-            *aValEbx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx;
-            *aValEcx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx;
-            *aValEdx = mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx;
-            break;
-
-        default:
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SetCPUIDLeaf(ULONG aId, ULONG aValEax, ULONG aValEbx, ULONG aValEcx, ULONG aValEdx)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    switch(aId)
-    {
-        case 0x0:
-        case 0x1:
-        case 0x2:
-        case 0x3:
-        case 0x4:
-        case 0x5:
-        case 0x6:
-        case 0x7:
-        case 0x8:
-        case 0x9:
-        case 0xA:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xB);
-            AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mCpuIdStdLeafs[aId].ulId  = aId;
-            mHWData->mCpuIdStdLeafs[aId].ulEax = aValEax;
-            mHWData->mCpuIdStdLeafs[aId].ulEbx = aValEbx;
-            mHWData->mCpuIdStdLeafs[aId].ulEcx = aValEcx;
-            mHWData->mCpuIdStdLeafs[aId].ulEdx = aValEdx;
-            break;
-
-        case 0x80000000:
-        case 0x80000001:
-        case 0x80000002:
-        case 0x80000003:
-        case 0x80000004:
-        case 0x80000005:
-        case 0x80000006:
-        case 0x80000007:
-        case 0x80000008:
-        case 0x80000009:
-        case 0x8000000A:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xB);
-            AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId  = aId;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEax = aValEax;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEbx = aValEbx;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEcx = aValEcx;
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulEdx = aValEdx;
-            break;
-
-        default:
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::RemoveCPUIDLeaf(ULONG aId)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    switch(aId)
-    {
-        case 0x0:
-        case 0x1:
-        case 0x2:
-        case 0x3:
-        case 0x4:
-        case 0x5:
-        case 0x6:
-        case 0x7:
-        case 0x8:
-        case 0x9:
-        case 0xA:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdStdLeafs) == 0xB);
-            AssertRelease(aId < RT_ELEMENTS(mHWData->mCpuIdStdLeafs));
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            /* Invalidate leaf. */
-            mHWData->mCpuIdStdLeafs[aId].ulId = UINT32_MAX;
-            break;
-
-        case 0x80000000:
-        case 0x80000001:
-        case 0x80000002:
-        case 0x80000003:
-        case 0x80000004:
-        case 0x80000005:
-        case 0x80000006:
-        case 0x80000007:
-        case 0x80000008:
-        case 0x80000009:
-        case 0x8000000A:
-            AssertCompile(RT_ELEMENTS(mHWData->mCpuIdExtLeafs) == 0xB);
-            AssertRelease(aId - 0x80000000 < RT_ELEMENTS(mHWData->mCpuIdExtLeafs));
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            /* Invalidate leaf. */
-            mHWData->mCpuIdExtLeafs[aId - 0x80000000].ulId = UINT32_MAX;
-            break;
-
-        default:
-            return setError(E_INVALIDARG, tr("CpuId override leaf %#x is out of range"), aId);
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::RemoveAllCPUIDLeaves()
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-
-    /* Invalidate all standard leafs. */
-    for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); i++)
-        mHWData->mCpuIdStdLeafs[i].ulId = UINT32_MAX;
-
-    /* Invalidate all extended leafs. */
-    for (unsigned i = 0; i < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); i++)
-        mHWData->mCpuIdExtLeafs[i].ulId = UINT32_MAX;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetHWVirtExProperty(HWVirtExPropertyType_T property, BOOL *aVal)
-{
-    CheckComArgOutPointerValid(aVal);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    switch(property)
-    {
-        case HWVirtExPropertyType_Enabled:
-            *aVal = mHWData->mHWVirtExEnabled;
-            break;
-
-        case HWVirtExPropertyType_Exclusive:
-            *aVal = mHWData->mHWVirtExExclusive;
-            break;
-
-        case HWVirtExPropertyType_VPID:
-            *aVal = mHWData->mHWVirtExVPIDEnabled;
-            break;
-
-        case HWVirtExPropertyType_NestedPaging:
-            *aVal = mHWData->mHWVirtExNestedPagingEnabled;
-            break;
-
-        case HWVirtExPropertyType_UnrestrictedExecution:
-            *aVal = mHWData->mHWVirtExUXEnabled;
-            break;
-
-        case HWVirtExPropertyType_LargePages:
-            *aVal = mHWData->mHWVirtExLargePagesEnabled;
-#if defined(DEBUG_bird) && defined(RT_OS_LINUX) /* This feature is deadly here */
-            *aVal = FALSE;
-#endif
-            break;
-
-        case HWVirtExPropertyType_Force:
-            *aVal = mHWData->mHWVirtExForceEnabled;
-            break;
-
-        default:
-            return E_INVALIDARG;
-    }
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SetHWVirtExProperty(HWVirtExPropertyType_T property, BOOL aVal)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    switch(property)
-    {
-        case HWVirtExPropertyType_Enabled:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExEnabled = !!aVal;
-            break;
-
-        case HWVirtExPropertyType_Exclusive:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExExclusive = !!aVal;
-            break;
-
-        case HWVirtExPropertyType_VPID:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExVPIDEnabled = !!aVal;
-            break;
-
-        case HWVirtExPropertyType_NestedPaging:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExNestedPagingEnabled = !!aVal;
-            break;
-
-        case HWVirtExPropertyType_UnrestrictedExecution:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExUXEnabled = !!aVal;
-            break;
-
-        case HWVirtExPropertyType_LargePages:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExLargePagesEnabled = !!aVal;
-            break;
-
-        case HWVirtExPropertyType_Force:
-            setModified(IsModified_MachineData);
-            mHWData.backup();
-            mHWData->mHWVirtExForceEnabled = !!aVal;
-            break;
-
-        default:
-            return E_INVALIDARG;
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SnapshotFolder)(BSTR *aSnapshotFolder)
-{
-    CheckComArgOutPointerValid(aSnapshotFolder);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    Utf8Str strFullSnapshotFolder;
-    calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
-    strFullSnapshotFolder.cloneTo(aSnapshotFolder);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(SnapshotFolder)(IN_BSTR aSnapshotFolder)
-{
-    /* @todo (r=dmik):
-     *  1. Allow to change the name of the snapshot folder containing snapshots
-     *  2. Rename the folder on disk instead of just changing the property
-     *     value (to be smart and not to leave garbage). Note that it cannot be
-     *     done here because the change may be rolled back. Thus, the right
-     *     place is #saveSettings().
-     */
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    if (!mData->mCurrentSnapshot.isNull())
-        return setError(E_FAIL,
-                        tr("The snapshot folder of a machine with snapshots cannot be changed (please delete all snapshots first)"));
-
-    Utf8Str strSnapshotFolder0(aSnapshotFolder);       // keep original
-
-    Utf8Str strSnapshotFolder(strSnapshotFolder0);
-    if (strSnapshotFolder.isEmpty())
-        strSnapshotFolder = "Snapshots";
-    int vrc = calculateFullPath(strSnapshotFolder,
-                                strSnapshotFolder);
-    if (RT_FAILURE(vrc))
-        return setError(E_FAIL,
-                        tr("Invalid snapshot folder '%ls' (%Rrc)"),
-                        aSnapshotFolder, vrc);
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-
-    copyPathRelativeToMachine(strSnapshotFolder, mUserData->s.strSnapshotFolder);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(MediumAttachments)(ComSafeArrayOut(IMediumAttachment*, aAttachments))
-{
-    CheckComArgOutSafeArrayPointerValid(aAttachments);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    SafeIfaceArray<IMediumAttachment> attachments(mMediaData->mAttachments);
-    attachments.detachTo(ComSafeArrayOutArg(aAttachments));
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(VRDEServer)(IVRDEServer **vrdeServer)
-{
-    CheckComArgOutPointerValid(vrdeServer);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    Assert(!!mVRDEServer);
-    mVRDEServer.queryInterfaceTo(vrdeServer);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(AudioAdapter)(IAudioAdapter **audioAdapter)
-{
-    CheckComArgOutPointerValid(audioAdapter);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mAudioAdapter.queryInterfaceTo(audioAdapter);
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(USBControllers)(ComSafeArrayOut(IUSBController *, aUSBControllers))
-{
-#ifdef VBOX_WITH_VUSB
-    CheckComArgOutPointerValid(aUSBControllers);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    clearError();
-    MultiResult rc(S_OK);
-
-# ifdef VBOX_WITH_USB
-    rc = mParent->host()->checkUSBProxyService();
-    if (FAILED(rc)) return rc;
-# endif
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    SafeIfaceArray<IUSBController> ctrls(*mUSBControllers.data());
-    ctrls.detachTo(ComSafeArrayOutArg(aUSBControllers));
-    return S_OK;
-#else
-    /* Note: The GUI depends on this method returning E_NOTIMPL with no
-     * extended error info to indicate that USB is simply not available
-     * (w/o treating it as a failure), for example, as in OSE */
-    NOREF(aUSBControllers);
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_VUSB */
-}
-
-STDMETHODIMP Machine::COMGETTER(USBDeviceFilters)(IUSBDeviceFilters **aUSBDeviceFilters)
-{
-#ifdef VBOX_WITH_VUSB
-    CheckComArgOutPointerValid(aUSBDeviceFilters);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    clearError();
-    MultiResult rc(S_OK);
-
-# ifdef VBOX_WITH_USB
-    rc = mParent->host()->checkUSBProxyService();
-    if (FAILED(rc)) return rc;
-# endif
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    return rc = mUSBDeviceFilters.queryInterfaceTo(aUSBDeviceFilters);
-#else
-    /* Note: The GUI depends on this method returning E_NOTIMPL with no
-     * extended error info to indicate that USB is simply not available
-     * (w/o treating it as a failure), for example, as in OSE */
-    NOREF(aUSBDeviceFilters);
-    ReturnComNotImplemented();
-#endif /* VBOX_WITH_VUSB */
-}
-
-STDMETHODIMP Machine::COMGETTER(SettingsFilePath)(BSTR *aFilePath)
-{
-    CheckComArgOutPointerValid(aFilePath);
-
-    AutoLimitedCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mData->m_strConfigFileFull.cloneTo(aFilePath);
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SettingsModified)(BOOL *aModified)
-{
-    CheckComArgOutPointerValid(aModified);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    if (!mData->pMachineConfigFile->fileExists())
-        // this is a new machine, and no config file exists yet:
-        *aModified = TRUE;
-    else
-        *aModified = (mData->flModifications != 0);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SessionState)(SessionState_T *aSessionState)
-{
-    CheckComArgOutPointerValid(aSessionState);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aSessionState = mData->mSession.mState;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SessionType)(BSTR *aSessionType)
-{
-    CheckComArgOutPointerValid(aSessionType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mData->mSession.mType.cloneTo(aSessionType);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SessionPID)(ULONG *aSessionPID)
-{
-    CheckComArgOutPointerValid(aSessionPID);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aSessionPID = mData->mSession.mPID;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(State)(MachineState_T *machineState)
-{
-    CheckComArgOutPointerValid(machineState);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *machineState = mData->mMachineState;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(LastStateChange)(LONG64 *aLastStateChange)
-{
-    CheckComArgOutPointerValid(aLastStateChange);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aLastStateChange = RTTimeSpecGetMilli(&mData->mLastStateChange);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(StateFilePath)(BSTR *aStateFilePath)
-{
-    CheckComArgOutPointerValid(aStateFilePath);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mSSData->strStateFilePath.cloneTo(aStateFilePath);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(LogFolder)(BSTR *aLogFolder)
-{
-    CheckComArgOutPointerValid(aLogFolder);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    Utf8Str logFolder;
-    getLogFolder(logFolder);
-    logFolder.cloneTo(aLogFolder);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(CurrentSnapshot) (ISnapshot **aCurrentSnapshot)
-{
-    CheckComArgOutPointerValid(aCurrentSnapshot);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mData->mCurrentSnapshot.queryInterfaceTo(aCurrentSnapshot);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SnapshotCount)(ULONG *aSnapshotCount)
-{
-    CheckComArgOutPointerValid(aSnapshotCount);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aSnapshotCount = mData->mFirstSnapshot.isNull()
-                          ? 0
-                          : mData->mFirstSnapshot->getAllChildrenCount() + 1;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(CurrentStateModified)(BOOL *aCurrentStateModified)
-{
-    CheckComArgOutPointerValid(aCurrentStateModified);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* Note: for machines with no snapshots, we always return FALSE
-     * (mData->mCurrentStateModified will be TRUE in this case, for historical
-     * reasons :) */
-
-    *aCurrentStateModified = mData->mFirstSnapshot.isNull()
-                            ? FALSE
-                            : mData->mCurrentStateModified;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
-{
-    CheckComArgOutSafeArrayPointerValid(aSharedFolders);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    SafeIfaceArray<ISharedFolder> folders(mHWData->mSharedFolders);
-    folders.detachTo(ComSafeArrayOutArg(aSharedFolders));
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(ClipboardMode)(ClipboardMode_T *aClipboardMode)
-{
-    CheckComArgOutPointerValid(aClipboardMode);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aClipboardMode = mHWData->mClipboardMode;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(ClipboardMode)(ClipboardMode_T aClipboardMode)
-{
-    HRESULT rc = S_OK;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    alock.release();
-    rc = onClipboardModeChange(aClipboardMode);
-    alock.acquire();
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mClipboardMode = aClipboardMode;
-
-    /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-    if (Global::IsOnline(mData->mMachineState))
-        saveSettings(NULL);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(DragAndDropMode)(DragAndDropMode_T *aDragAndDropMode)
-{
-    CheckComArgOutPointerValid(aDragAndDropMode);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aDragAndDropMode = mHWData->mDragAndDropMode;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(DragAndDropMode)(DragAndDropMode_T aDragAndDropMode)
-{
-    HRESULT rc = S_OK;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    alock.release();
-    rc = onDragAndDropModeChange(aDragAndDropMode);
-    alock.acquire();
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mDragAndDropMode = aDragAndDropMode;
-
-    /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-    if (Global::IsOnline(mData->mMachineState))
-        saveSettings(NULL);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(GuestPropertyNotificationPatterns)(BSTR *aPatterns)
-{
-    CheckComArgOutPointerValid(aPatterns);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    try
-    {
-        mHWData->mGuestPropertyNotificationPatterns.cloneTo(aPatterns);
-    }
-    catch (...)
-    {
-        return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(GuestPropertyNotificationPatterns)(IN_BSTR aPatterns)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mGuestPropertyNotificationPatterns = aPatterns;
-    return rc;
-}
-
-STDMETHODIMP Machine::COMGETTER(StorageControllers)(ComSafeArrayOut(IStorageController *, aStorageControllers))
-{
-    CheckComArgOutSafeArrayPointerValid(aStorageControllers);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    SafeIfaceArray<IStorageController> ctrls(*mStorageControllers.data());
-    ctrls.detachTo(ComSafeArrayOutArg(aStorageControllers));
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(TeleporterEnabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mUserData->s.fTeleporterEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(TeleporterEnabled)(BOOL aEnabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* Only allow it to be set to true when PoweredOff or Aborted.
-       (Clearing it is always permitted.) */
-    if (    aEnabled
-        &&  mData->mRegistered
-        &&  (   !isSessionMachine()
-             || (   mData->mMachineState != MachineState_PoweredOff
-                 && mData->mMachineState != MachineState_Teleported
-                 && mData->mMachineState != MachineState_Aborted
-                )
-            )
-       )
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("The machine is not powered off (state is %s)"),
-                        Global::stringifyMachineState(mData->mMachineState));
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.fTeleporterEnabled = !!aEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(TeleporterPort)(ULONG *aPort)
-{
-    CheckComArgOutPointerValid(aPort);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aPort = (ULONG)mUserData->s.uTeleporterPort;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(TeleporterPort)(ULONG aPort)
-{
-    if (aPort >= _64K)
-        return setError(E_INVALIDARG, tr("Invalid port number %d"), aPort);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.uTeleporterPort = (uint32_t)aPort;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(TeleporterAddress)(BSTR *aAddress)
-{
-    CheckComArgOutPointerValid(aAddress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mUserData->s.strTeleporterAddress.cloneTo(aAddress);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(TeleporterAddress)(IN_BSTR aAddress)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.strTeleporterAddress = aAddress;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(TeleporterPassword)(BSTR *aPassword)
-{
-    CheckComArgOutPointerValid(aPassword);
-
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        mUserData->s.strTeleporterPassword.cloneTo(aPassword);
-    }
-
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(TeleporterPassword)(IN_BSTR aPassword)
-{
-    /*
-     * Hash the password first.
-     */
-    Utf8Str strPassword(aPassword);
-    if (!strPassword.isEmpty())
-    {
-        if (VBoxIsPasswordHashed(&strPassword))
-            return setError(E_INVALIDARG, tr("Cannot set an already hashed password, only plain text password please"));
-        VBoxHashPassword(&strPassword);
-    }
-
-    /*
-     * Do the update.
-     */
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            setModified(IsModified_MachineData);
-            mUserData.backup();
-            mUserData->s.strTeleporterPassword = strPassword;
-        }
-    }
-
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(FaultToleranceState)(FaultToleranceState_T *aState)
-{
-    CheckComArgOutPointerValid(aState);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aState = mUserData->s.enmFaultToleranceState;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(FaultToleranceState)(FaultToleranceState_T aState)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* @todo deal with running state change. */
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.enmFaultToleranceState = aState;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(FaultToleranceAddress)(BSTR *aAddress)
-{
-    CheckComArgOutPointerValid(aAddress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mUserData->s.strFaultToleranceAddress.cloneTo(aAddress);
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(FaultToleranceAddress)(IN_BSTR aAddress)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* @todo deal with running state change. */
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.strFaultToleranceAddress = aAddress;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(FaultTolerancePort)(ULONG *aPort)
-{
-    CheckComArgOutPointerValid(aPort);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aPort = mUserData->s.uFaultTolerancePort;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(FaultTolerancePort)(ULONG aPort)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* @todo deal with running state change. */
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.uFaultTolerancePort = aPort;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(FaultTolerancePassword)(BSTR *aPassword)
-{
-    CheckComArgOutPointerValid(aPassword);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mUserData->s.strFaultTolerancePassword.cloneTo(aPassword);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(FaultTolerancePassword)(IN_BSTR aPassword)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* @todo deal with running state change. */
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.strFaultTolerancePassword = aPassword;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(FaultToleranceSyncInterval)(ULONG *aInterval)
-{
-    CheckComArgOutPointerValid(aInterval);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aInterval = mUserData->s.uFaultToleranceInterval;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(FaultToleranceSyncInterval)(ULONG aInterval)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* @todo deal with running state change. */
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.uFaultToleranceInterval = aInterval;
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(RTCUseUTC)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mUserData->s.fRTCUseUTC;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(RTCUseUTC)(BOOL aEnabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* Only allow it to be set to true when PoweredOff or Aborted.
-       (Clearing it is always permitted.) */
-    if (    aEnabled
-        &&  mData->mRegistered
-        &&  (   !isSessionMachine()
-             || (   mData->mMachineState != MachineState_PoweredOff
-                 && mData->mMachineState != MachineState_Teleported
-                 && mData->mMachineState != MachineState_Aborted
-                )
-            )
-       )
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("The machine is not powered off (state is %s)"),
-                        Global::stringifyMachineState(mData->mMachineState));
-
-    setModified(IsModified_MachineData);
-    mUserData.backup();
-    mUserData->s.fRTCUseUTC = !!aEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(IOCacheEnabled)(BOOL *aEnabled)
-{
-    CheckComArgOutPointerValid(aEnabled);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aEnabled = mHWData->mIOCacheEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(IOCacheEnabled)(BOOL aEnabled)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mIOCacheEnabled = aEnabled;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(IOCacheSize)(ULONG *aIOCacheSize)
-{
-    CheckComArgOutPointerValid(aIOCacheSize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aIOCacheSize = mHWData->mIOCacheSize;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMSETTER(IOCacheSize)(ULONG  aIOCacheSize)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mIOCacheSize = aIOCacheSize;
-
-    return S_OK;
-}
-
-
-/**
- *  @note Locks objects!
- */
-STDMETHODIMP Machine::LockMachine(ISession *aSession,
-                                  LockType_T lockType)
-{
-    CheckComArgNotNull(aSession);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* check the session state */
-    SessionState_T state;
-    HRESULT rc = aSession->COMGETTER(State)(&state);
-    if (FAILED(rc)) return rc;
-
-    if (state != SessionState_Unlocked)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("The given session is busy"));
-
-    // get the client's IInternalSessionControl interface
-    ComPtr<IInternalSessionControl> pSessionControl = aSession;
-    ComAssertMsgRet(!!pSessionControl, ("No IInternalSessionControl interface"),
-                    E_INVALIDARG);
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mData->mRegistered)
-        return setError(E_UNEXPECTED,
-                        tr("The machine '%s' is not registered"),
-                        mUserData->s.strName.c_str());
-
-    LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
-
-    SessionState_T oldState = mData->mSession.mState;
-    /* Hack: in case the session is closing and there is a progress object
-     * which allows waiting for the session to be closed, take the opportunity
-     * and do a limited wait (max. 1 second). This helps a lot when the system
-     * is busy and thus session closing can take a little while. */
-    if (    mData->mSession.mState == SessionState_Unlocking
-        &&  mData->mSession.mProgress)
-    {
-        alock.release();
-        mData->mSession.mProgress->WaitForCompletion(1000);
-        alock.acquire();
-        LogFlowThisFunc(("after waiting: mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
-    }
-
-    // try again now
-    if (    (mData->mSession.mState == SessionState_Locked)         // machine is write-locked already (i.e. session machine exists)
-         && (lockType == LockType_Shared)                           // caller wants a shared link to the existing session that holds the write lock:
-       )
-    {
-        // OK, share the session... we are now dealing with three processes:
-        // 1) VBoxSVC (where this code runs);
-        // 2) process C: the caller's client process (who wants a shared session);
-        // 3) process W: the process which already holds the write lock on the machine (write-locking session)
-
-        // copy pointers to W (the write-locking session) before leaving lock (these must not be NULL)
-        ComPtr<IInternalSessionControl> pSessionW = mData->mSession.mDirectControl;
-        ComAssertRet(!pSessionW.isNull(), E_FAIL);
-        ComObjPtr<SessionMachine> pSessionMachine = mData->mSession.mMachine;
-        AssertReturn(!pSessionMachine.isNull(), E_FAIL);
-
-        /*
-         *  Release the lock before calling the client process. It's safe here
-         *  since the only thing to do after we get the lock again is to add
-         *  the remote control to the list (which doesn't directly influence
-         *  anything).
-         */
-        alock.release();
-
-        // get the console of the session holding the write lock (this is a remote call)
-        ComPtr<IConsole> pConsoleW;
-        LogFlowThisFunc(("Calling GetRemoteConsole()...\n"));
-        rc = pSessionW->GetRemoteConsole(pConsoleW.asOutParam());
-        LogFlowThisFunc(("GetRemoteConsole() returned %08X\n", rc));
-        if (FAILED(rc))
-            // the failure may occur w/o any error info (from RPC), so provide one
-            return setError(VBOX_E_VM_ERROR,
-                            tr("Failed to get a console object from the direct session (%Rrc)"), rc);
-
-        ComAssertRet(!pConsoleW.isNull(), E_FAIL);
-
-        // share the session machine and W's console with the caller's session
-        LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
-        rc = pSessionControl->AssignRemoteMachine(pSessionMachine, pConsoleW);
-        LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
-
-        if (FAILED(rc))
-            // the failure may occur w/o any error info (from RPC), so provide one
-            return setError(VBOX_E_VM_ERROR,
-                            tr("Failed to assign the machine to the session (%Rrc)"), rc);
-        alock.acquire();
-
-        // need to revalidate the state after acquiring the lock again
-        if (mData->mSession.mState != SessionState_Locked)
-        {
-            pSessionControl->Uninitialize();
-            return setError(VBOX_E_INVALID_SESSION_STATE,
-                            tr("The machine '%s' was unlocked unexpectedly while attempting to share its session"),
-                               mUserData->s.strName.c_str());
-        }
-
-        // add the caller's session to the list
-        mData->mSession.mRemoteControls.push_back(pSessionControl);
-    }
-    else if (    mData->mSession.mState == SessionState_Locked
-              || mData->mSession.mState == SessionState_Unlocking
-            )
-    {
-        // sharing not permitted, or machine still unlocking:
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("The machine '%s' is already locked for a session (or being unlocked)"),
-                        mUserData->s.strName.c_str());
-    }
-    else
-    {
-        // machine is not locked: then write-lock the machine (create the session machine)
-
-        // must not be busy
-        AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
-
-        // get the caller's session PID
-        RTPROCESS pid = NIL_RTPROCESS;
-        AssertCompile(sizeof(ULONG) == sizeof(RTPROCESS));
-        pSessionControl->GetPID((ULONG*)&pid);
-        Assert(pid != NIL_RTPROCESS);
-
-        bool fLaunchingVMProcess = (mData->mSession.mState == SessionState_Spawning);
-
-        if (fLaunchingVMProcess)
-        {
-            // this machine is awaiting for a spawning session to be opened:
-            // then the calling process must be the one that got started by
-            // LaunchVMProcess()
-
-            LogFlowThisFunc(("mSession.mPID=%d(0x%x)\n", mData->mSession.mPID, mData->mSession.mPID));
-            LogFlowThisFunc(("session.pid=%d(0x%x)\n", pid, pid));
-
-            if (mData->mSession.mPID != pid)
-                return setError(E_ACCESSDENIED,
-                                tr("An unexpected process (PID=0x%08X) has tried to lock the "
-                                   "machine '%s', while only the process started by LaunchVMProcess (PID=0x%08X) is allowed"),
-                                pid, mUserData->s.strName.c_str(), mData->mSession.mPID);
-        }
-
-        // create the mutable SessionMachine from the current machine
-        ComObjPtr<SessionMachine> sessionMachine;
-        sessionMachine.createObject();
-        rc = sessionMachine->init(this);
-        AssertComRC(rc);
-
-        /* NOTE: doing return from this function after this point but
-         * before the end is forbidden since it may call SessionMachine::uninit()
-         * (through the ComObjPtr's destructor) which requests the VirtualBox write
-         * lock while still holding the Machine lock in alock so that a deadlock
-         * is possible due to the wrong lock order. */
-
-        if (SUCCEEDED(rc))
-        {
-            /*
-             *  Set the session state to Spawning to protect against subsequent
-             *  attempts to open a session and to unregister the machine after
-             *  we release the lock.
-             */
-            SessionState_T origState = mData->mSession.mState;
-            mData->mSession.mState = SessionState_Spawning;
-
-            /*
-             *  Release the lock before calling the client process -- it will call
-             *  Machine/SessionMachine methods. Releasing the lock here is quite safe
-             *  because the state is Spawning, so that LaunchVMProcess() and
-             *  LockMachine() calls will fail. This method, called before we
-             *  acquire the lock again, will fail because of the wrong PID.
-             *
-             *  Note that mData->mSession.mRemoteControls accessed outside
-             *  the lock may not be modified when state is Spawning, so it's safe.
-             */
-            alock.release();
-
-            LogFlowThisFunc(("Calling AssignMachine()...\n"));
-            rc = pSessionControl->AssignMachine(sessionMachine, lockType);
-            LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
-
-            /* The failure may occur w/o any error info (from RPC), so provide one */
-            if (FAILED(rc))
-                setError(VBOX_E_VM_ERROR,
-                         tr("Failed to assign the machine to the session (%Rrc)"), rc);
-
-            if (    SUCCEEDED(rc)
-                 && fLaunchingVMProcess
-               )
-            {
-                /* complete the remote session initialization */
-
-                /* get the console from the direct session */
-                ComPtr<IConsole> console;
-                rc = pSessionControl->GetRemoteConsole(console.asOutParam());
-                ComAssertComRC(rc);
-
-                if (SUCCEEDED(rc) && !console)
-                {
-                    ComAssert(!!console);
-                    rc = E_FAIL;
-                }
-
-                /* assign machine & console to the remote session */
-                if (SUCCEEDED(rc))
-                {
-                    /*
-                     *  after LaunchVMProcess(), the first and the only
-                     *  entry in remoteControls is that remote session
-                     */
-                    LogFlowThisFunc(("Calling AssignRemoteMachine()...\n"));
-                    rc = mData->mSession.mRemoteControls.front()->AssignRemoteMachine(sessionMachine, console);
-                    LogFlowThisFunc(("AssignRemoteMachine() returned %08X\n", rc));
-
-                    /* The failure may occur w/o any error info (from RPC), so provide one */
-                    if (FAILED(rc))
-                        setError(VBOX_E_VM_ERROR,
-                                 tr("Failed to assign the machine to the remote session (%Rrc)"), rc);
-                }
-
-                if (FAILED(rc))
-                    pSessionControl->Uninitialize();
-            }
-
-            /* acquire the lock again */
-            alock.acquire();
-
-            /* Restore the session state */
-            mData->mSession.mState = origState;
-        }
-
-        // finalize spawning anyway (this is why we don't return on errors above)
-        if (fLaunchingVMProcess)
-        {
-            /* Note that the progress object is finalized later */
-            /** @todo Consider checking mData->mSession.mProgress for cancellation
-             *        around here.  */
-
-            /* We don't reset mSession.mPID here because it is necessary for
-             * SessionMachine::uninit() to reap the child process later. */
-
-            if (FAILED(rc))
-            {
-                /* Close the remote session, remove the remote control from the list
-                 * and reset session state to Closed (@note keep the code in sync
-                 * with the relevant part in openSession()). */
-
-                Assert(mData->mSession.mRemoteControls.size() == 1);
-                if (mData->mSession.mRemoteControls.size() == 1)
-                {
-                    ErrorInfoKeeper eik;
-                    mData->mSession.mRemoteControls.front()->Uninitialize();
-                }
-
-                mData->mSession.mRemoteControls.clear();
-                mData->mSession.mState = SessionState_Unlocked;
-            }
-        }
-        else
-        {
-            /* memorize PID of the directly opened session */
-            if (SUCCEEDED(rc))
-                mData->mSession.mPID = pid;
-        }
-
-        if (SUCCEEDED(rc))
-        {
-            /* memorize the direct session control and cache IUnknown for it */
-            mData->mSession.mDirectControl = pSessionControl;
-            mData->mSession.mState = SessionState_Locked;
-            /* associate the SessionMachine with this Machine */
-            mData->mSession.mMachine = sessionMachine;
-
-            /* request an IUnknown pointer early from the remote party for later
-             * identity checks (it will be internally cached within mDirectControl
-             * at least on XPCOM) */
-            ComPtr<IUnknown> unk = mData->mSession.mDirectControl;
-            NOREF(unk);
-        }
-
-        /* Release the lock since SessionMachine::uninit() locks VirtualBox which
-         * would break the lock order */
-        alock.release();
-
-        /* uninitialize the created session machine on failure */
-        if (FAILED(rc))
-            sessionMachine->uninit();
-
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        /*
-         *  tell the client watcher thread to update the set of
-         *  machines that have open sessions
-         */
-        mParent->updateClientWatcher();
-
-        if (oldState != SessionState_Locked)
-            /* fire an event */
-            mParent->onSessionStateChange(getId(), SessionState_Locked);
-    }
-
-    return rc;
-}
-
-/**
- *  @note Locks objects!
- */
-STDMETHODIMP Machine::LaunchVMProcess(ISession *aSession,
-                                      IN_BSTR aFrontend,
-                                      IN_BSTR aEnvironment,
-                                      IProgress **aProgress)
-{
-    CheckComArgStr(aFrontend);
-    Utf8Str strFrontend(aFrontend);
-    Utf8Str strEnvironment(aEnvironment);
-    /* "emergencystop" doesn't need the session, so skip the checks/interface
-     * retrieval. This code doesn't quite fit in here, but introducing a
-     * special API method would be even more effort, and would require explicit
-     * support by every API client. It's better to hide the feature a bit. */
-    if (strFrontend != "emergencystop")
-        CheckComArgNotNull(aSession);
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc = S_OK;
-    if (strFrontend.isEmpty())
-    {
-        Bstr bstrFrontend;
-        rc = COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
-        if (FAILED(rc))
-            return rc;
-        strFrontend = bstrFrontend;
-        if (strFrontend.isEmpty())
-        {
-            ComPtr<ISystemProperties> systemProperties;
-            rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
-            if (FAILED(rc))
-                return rc;
-            rc = systemProperties->COMGETTER(DefaultFrontend)(bstrFrontend.asOutParam());
-            if (FAILED(rc))
-                return rc;
-            strFrontend = bstrFrontend;
-        }
-        /* paranoia - emergencystop is not a valid default */
-        if (strFrontend == "emergencystop")
-            strFrontend = Utf8Str::Empty;
-    }
-    /* default frontend: Qt GUI */
-    if (strFrontend.isEmpty())
-        strFrontend = "GUI/Qt";
-
-    if (strFrontend != "emergencystop")
-    {
-        /* check the session state */
-        SessionState_T state;
-        rc = aSession->COMGETTER(State)(&state);
-        if (FAILED(rc))
-            return rc;
-
-        if (state != SessionState_Unlocked)
-            return setError(VBOX_E_INVALID_OBJECT_STATE,
-                            tr("The given session is busy"));
-
-        /* get the IInternalSessionControl interface */
-        ComPtr<IInternalSessionControl> control(aSession);
-        ComAssertMsgRet(!control.isNull(),
-                        ("No IInternalSessionControl interface"),
-                        E_INVALIDARG);
-
-        /* get the teleporter enable state for the progress object init. */
-        BOOL fTeleporterEnabled;
-        rc = COMGETTER(TeleporterEnabled)(&fTeleporterEnabled);
-        if (FAILED(rc))
-            return rc;
-
-        /* create a progress object */
-        ComObjPtr<ProgressProxy> progress;
-        progress.createObject();
-        rc = progress->init(mParent,
-                            static_cast<IMachine*>(this),
-                            Bstr(tr("Starting VM")).raw(),
-                            TRUE /* aCancelable */,
-                            fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
-                            BstrFmt(tr("Creating process for virtual machine \"%s\" (%s)"), mUserData->s.strName.c_str(), strFrontend.c_str()).raw(),
-                            2 /* uFirstOperationWeight */,
-                            fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
-
-        if (SUCCEEDED(rc))
-        {
-            rc = launchVMProcess(control, strFrontend, strEnvironment, progress);
-            if (SUCCEEDED(rc))
-            {
-                progress.queryInterfaceTo(aProgress);
-
-                /* signal the client watcher thread */
-                mParent->updateClientWatcher();
-
-                /* fire an event */
-                mParent->onSessionStateChange(getId(), SessionState_Spawning);
-            }
-        }
-    }
-    else
-    {
-        /* no progress object - either instant success or failure */
-        *aProgress = NULL;
-
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        if (mData->mSession.mState != SessionState_Locked)
-            return setError(VBOX_E_INVALID_OBJECT_STATE,
-                            tr("The machine '%s' is not locked by a session"),
-                            mUserData->s.strName.c_str());
-
-        /* must have a VM process associated - do not kill normal API clients
-         * with an open session */
-        if (!Global::IsOnline(mData->mMachineState))
-            return setError(VBOX_E_INVALID_OBJECT_STATE,
-                            tr("The machine '%s' does not have a VM process"),
-                            mUserData->s.strName.c_str());
-
-        /* forcibly terminate the VM process */
-        if (mData->mSession.mPID != NIL_RTPROCESS)
-            RTProcTerminate(mData->mSession.mPID);
-
-        /* signal the client watcher thread, as most likely the client has
-         * been terminated */
-        mParent->updateClientWatcher();
-    }
-
-    return rc;
-}
-
-STDMETHODIMP Machine::SetBootOrder(ULONG aPosition, DeviceType_T aDevice)
-{
-    if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
-        return setError(E_INVALIDARG,
-                        tr("Invalid boot position: %lu (must be in range [1, %lu])"),
-                        aPosition, SchemaDefs::MaxBootPosition);
-
-    if (aDevice == DeviceType_USB)
-        return setError(E_NOTIMPL,
-                        tr("Booting from USB device is currently not supported"));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mBootOrder[aPosition - 1] = aDevice;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetBootOrder(ULONG aPosition, DeviceType_T *aDevice)
-{
-    if (aPosition < 1 || aPosition > SchemaDefs::MaxBootPosition)
-        return setError(E_INVALIDARG,
-                       tr("Invalid boot position: %lu (must be in range [1, %lu])"),
-                       aPosition, SchemaDefs::MaxBootPosition);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aDevice = mHWData->mBootOrder[aPosition - 1];
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::AttachDevice(IN_BSTR aControllerName,
-                                   LONG aControllerPort,
-                                   LONG aDevice,
-                                   DeviceType_T aType,
-                                   IMedium *aMedium)
-{
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
-                     aControllerName, aControllerPort, aDevice, aType, aMedium));
-
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    // request the host lock first, since might be calling Host methods for getting host drives;
-    // next, protect the media tree all the while we're in here, as well as our member variables
-    AutoMultiWriteLock2 alock(mParent->host(), this COMMA_LOCKVAL_SRC_POS);
-    AutoWriteLock treeLock(&mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    /// @todo NEWMEDIA implicit machine registration
-    if (!mData->mRegistered)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Cannot attach storage devices to an unregistered machine"));
-
-    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
-
-    /* Check for an existing controller. */
-    ComObjPtr<StorageController> ctl;
-    rc = getStorageControllerByName(aControllerName, ctl, true /* aSetError */);
-    if (FAILED(rc)) return rc;
-
-    StorageControllerType_T ctrlType;
-    rc = ctl->COMGETTER(ControllerType)(&ctrlType);
-    if (FAILED(rc))
-        return setError(E_FAIL,
-                        tr("Could not get type of controller '%ls'"),
-                        aControllerName);
-
-    bool fSilent = false;
-    Utf8Str strReconfig;
-
-    /* Check whether the flag to allow silent storage attachment reconfiguration is set. */
-    strReconfig = getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
-    if (FAILED(rc))
-        return rc;
-    if (   mData->mMachineState == MachineState_Paused
-        && strReconfig == "1")
-        fSilent = true;
-
-    /* Check that the controller can do hotplugging if we detach the device while the VM is running. */
-    bool fHotplug = false;
-    if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
-        fHotplug = true;
-
-    if (fHotplug && !isControllerHotplugCapable(ctrlType))
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Controller '%ls' does not support hotplugging"),
-                        aControllerName);
-
-    // check that the port and device are not out of range
-    rc = ctl->checkPortAndDeviceValid(aControllerPort, aDevice);
-    if (FAILED(rc)) return rc;
-
-    /* check if the device slot is already busy */
-    MediumAttachment *pAttachTemp;
-    if ((pAttachTemp = findAttachment(mMediaData->mAttachments,
-                                      aControllerName,
-                                      aControllerPort,
-                                      aDevice)))
-    {
-        Medium *pMedium = pAttachTemp->getMedium();
-        if (pMedium)
-        {
-            AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-            return setError(VBOX_E_OBJECT_IN_USE,
-                            tr("Medium '%s' is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
-                            pMedium->getLocationFull().c_str(),
-                            aControllerPort,
-                            aDevice,
-                            aControllerName);
-        }
-        else
-            return setError(VBOX_E_OBJECT_IN_USE,
-                            tr("Device is already attached to port %d, device %d of controller '%ls' of this virtual machine"),
-                            aControllerPort, aDevice, aControllerName);
-    }
-
-    ComObjPtr<Medium> medium = static_cast<Medium*>(aMedium);
-    if (aMedium && medium.isNull())
-        return setError(E_INVALIDARG, "The given medium pointer is invalid");
-
-    AutoCaller mediumCaller(medium);
-    if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
-
-    AutoWriteLock mediumLock(medium COMMA_LOCKVAL_SRC_POS);
-
-    if (    (pAttachTemp = findAttachment(mMediaData->mAttachments, medium))
-         && !medium.isNull()
-       )
-        return setError(VBOX_E_OBJECT_IN_USE,
-                        tr("Medium '%s' is already attached to this virtual machine"),
-                        medium->getLocationFull().c_str());
-
-    if (!medium.isNull())
-    {
-        MediumType_T mtype = medium->getType();
-        // MediumType_Readonly is also new, but only applies to DVDs and floppies.
-        // For DVDs it's not written to the config file, so needs no global config
-        // version bump. For floppies it's a new attribute "type", which is ignored
-        // by older VirtualBox version, so needs no global config version bump either.
-        // For hard disks this type is not accepted.
-        if (mtype == MediumType_MultiAttach)
-        {
-            // This type is new with VirtualBox 4.0 and therefore requires settings
-            // version 1.11 in the settings backend. Unfortunately it is not enough to do
-            // the usual routine in MachineConfigFile::bumpSettingsVersionIfNeeded() for
-            // two reasons: The medium type is a property of the media registry tree, which
-            // can reside in the global config file (for pre-4.0 media); we would therefore
-            // possibly need to bump the global config version. We don't want to do that though
-            // because that might make downgrading to pre-4.0 impossible.
-            // As a result, we can only use these two new types if the medium is NOT in the
-            // global registry:
-            const Guid &uuidGlobalRegistry = mParent->getGlobalRegistryId();
-            if (    medium->isInRegistry(uuidGlobalRegistry)
-                 || !mData->pMachineConfigFile->canHaveOwnMediaRegistry()
-               )
-                return setError(VBOX_E_INVALID_OBJECT_STATE,
-                                tr("Cannot attach medium '%s': the media type 'MultiAttach' can only be attached "
-                                   "to machines that were created with VirtualBox 4.0 or later"),
-                                medium->getLocationFull().c_str());
-        }
-    }
-
-    bool fIndirect = false;
-    if (!medium.isNull())
-        fIndirect = medium->isReadOnly();
-    bool associate = true;
-
-    do
-    {
-        if (    aType == DeviceType_HardDisk
-             && mMediaData.isBackedUp())
-        {
-            const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
-
-            /* check if the medium was attached to the VM before we started
-             * changing attachments in which case the attachment just needs to
-             * be restored */
-            if ((pAttachTemp = findAttachment(oldAtts, medium)))
-            {
-                AssertReturn(!fIndirect, E_FAIL);
-
-                /* see if it's the same bus/channel/device */
-                if (pAttachTemp->matches(aControllerName, aControllerPort, aDevice))
-                {
-                    /* the simplest case: restore the whole attachment
-                     * and return, nothing else to do */
-                    mMediaData->mAttachments.push_back(pAttachTemp);
-
-                    /* Reattach the medium to the VM. */
-                    if (fHotplug || fSilent)
-                    {
-                        mediumLock.release();
-                        treeLock.release();
-                        alock.release();
-
-                        MediumLockList *pMediumLockList(new MediumLockList());
-
-                        rc = medium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                          true /* fMediumLockWrite */,
-                                                          NULL,
-                                                          *pMediumLockList);
-                        alock.acquire();
-                        if (FAILED(rc))
-                            delete pMediumLockList;
-                        else
-                        {
-                            mData->mSession.mLockedMedia.Unlock();
-                            alock.release();
-                            rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
-                            mData->mSession.mLockedMedia.Lock();
-                            alock.acquire();
-                        }
-                        alock.release();
-
-                        if (SUCCEEDED(rc))
-                        {
-                            rc = onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
-                            /* Remove lock list in case of error. */
-                            if (FAILED(rc))
-                            {
-                                mData->mSession.mLockedMedia.Unlock();
-                                mData->mSession.mLockedMedia.Remove(pAttachTemp);
-                                mData->mSession.mLockedMedia.Lock();
-                            }
-                        }
-                    }
-
-                    return S_OK;
-                }
-
-                /* bus/channel/device differ; we need a new attachment object,
-                 * but don't try to associate it again */
-                associate = false;
-                break;
-            }
-        }
-
-        /* go further only if the attachment is to be indirect */
-        if (!fIndirect)
-            break;
-
-        /* perform the so called smart attachment logic for indirect
-         * attachments. Note that smart attachment is only applicable to base
-         * hard disks. */
-
-        if (medium->getParent().isNull())
-        {
-            /* first, investigate the backup copy of the current hard disk
-             * attachments to make it possible to re-attach existing diffs to
-             * another device slot w/o losing their contents */
-            if (mMediaData.isBackedUp())
-            {
-                const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
-
-                MediaData::AttachmentList::const_iterator foundIt = oldAtts.end();
-                uint32_t foundLevel = 0;
-
-                for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
-                     it != oldAtts.end();
-                     ++it)
-                {
-                    uint32_t level = 0;
-                    MediumAttachment *pAttach = *it;
-                    ComObjPtr<Medium> pMedium = pAttach->getMedium();
-                    Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
-                    if (pMedium.isNull())
-                        continue;
-
-                    if (pMedium->getBase(&level) == medium)
-                    {
-                        /* skip the hard disk if its currently attached (we
-                         * cannot attach the same hard disk twice) */
-                        if (findAttachment(mMediaData->mAttachments,
-                                           pMedium))
-                            continue;
-
-                        /* matched device, channel and bus (i.e. attached to the
-                         * same place) will win and immediately stop the search;
-                         * otherwise the attachment that has the youngest
-                         * descendant of medium will be used
-                         */
-                        if (pAttach->matches(aControllerName, aControllerPort, aDevice))
-                        {
-                            /* the simplest case: restore the whole attachment
-                             * and return, nothing else to do */
-                            mMediaData->mAttachments.push_back(*it);
-
-                            /* Reattach the medium to the VM. */
-                            if (fHotplug || fSilent)
-                            {
-                                mediumLock.release();
-                                treeLock.release();
-                                alock.release();
-
-                                MediumLockList *pMediumLockList(new MediumLockList());
-
-                                rc = medium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                                  true /* fMediumLockWrite */,
-                                                                  NULL,
-                                                                  *pMediumLockList);
-                                alock.acquire();
-                                if (FAILED(rc))
-                                    delete pMediumLockList;
-                                else
-                                {
-                                    mData->mSession.mLockedMedia.Unlock();
-                                    alock.release();
-                                    rc = mData->mSession.mLockedMedia.Insert(pAttachTemp, pMediumLockList);
-                                    mData->mSession.mLockedMedia.Lock();
-                                    alock.acquire();
-                                }
-                                alock.release();
-
-                                if (SUCCEEDED(rc))
-                                {
-                                    rc = onStorageDeviceChange(pAttachTemp, FALSE /* aRemove */, fSilent);
-                                    /* Remove lock list in case of error. */
-                                    if (FAILED(rc))
-                                    {
-                                        mData->mSession.mLockedMedia.Unlock();
-                                        mData->mSession.mLockedMedia.Remove(pAttachTemp);
-                                        mData->mSession.mLockedMedia.Lock();
-                                    }
-                                }
-                            }
-
-                            return S_OK;
-                        }
-                        else if (    foundIt == oldAtts.end()
-                                  || level > foundLevel /* prefer younger */
-                                )
-                        {
-                            foundIt = it;
-                            foundLevel = level;
-                        }
-                    }
-                }
-
-                if (foundIt != oldAtts.end())
-                {
-                    /* use the previously attached hard disk */
-                    medium = (*foundIt)->getMedium();
-                    mediumCaller.attach(medium);
-                    if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
-                    mediumLock.attach(medium);
-                    /* not implicit, doesn't require association with this VM */
-                    fIndirect = false;
-                    associate = false;
-                    /* go right to the MediumAttachment creation */
-                    break;
-                }
-            }
-
-            /* must give up the medium lock and medium tree lock as below we
-             * go over snapshots, which needs a lock with higher lock order. */
-            mediumLock.release();
-            treeLock.release();
-
-            /* then, search through snapshots for the best diff in the given
-             * hard disk's chain to base the new diff on */
-
-            ComObjPtr<Medium> base;
-            ComObjPtr<Snapshot> snap = mData->mCurrentSnapshot;
-            while (snap)
-            {
-                AutoReadLock snapLock(snap COMMA_LOCKVAL_SRC_POS);
-
-                const MediaData::AttachmentList &snapAtts = snap->getSnapshotMachine()->mMediaData->mAttachments;
-
-                MediumAttachment *pAttachFound = NULL;
-                uint32_t foundLevel = 0;
-
-                for (MediaData::AttachmentList::const_iterator it = snapAtts.begin();
-                     it != snapAtts.end();
-                     ++it)
-                {
-                    MediumAttachment *pAttach = *it;
-                    ComObjPtr<Medium> pMedium = pAttach->getMedium();
-                    Assert(!pMedium.isNull() || pAttach->getType() != DeviceType_HardDisk);
-                    if (pMedium.isNull())
-                        continue;
-
-                    uint32_t level = 0;
-                    if (pMedium->getBase(&level) == medium)
-                    {
-                        /* matched device, channel and bus (i.e. attached to the
-                         * same place) will win and immediately stop the search;
-                         * otherwise the attachment that has the youngest
-                         * descendant of medium will be used
-                         */
-                        if (    pAttach->getDevice() == aDevice
-                             && pAttach->getPort() == aControllerPort
-                             && pAttach->getControllerName() == aControllerName
-                           )
-                        {
-                            pAttachFound = pAttach;
-                            break;
-                        }
-                        else if (    !pAttachFound
-                                  || level > foundLevel /* prefer younger */
-                                )
-                        {
-                            pAttachFound = pAttach;
-                            foundLevel = level;
-                        }
-                    }
-                }
-
-                if (pAttachFound)
-                {
-                    base = pAttachFound->getMedium();
-                    break;
-                }
-
-                snap = snap->getParent();
-            }
-
-            /* re-lock medium tree and the medium, as we need it below */
-            treeLock.acquire();
-            mediumLock.acquire();
-
-            /* found a suitable diff, use it as a base */
-            if (!base.isNull())
-            {
-                medium = base;
-                mediumCaller.attach(medium);
-                if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
-                mediumLock.attach(medium);
-            }
-        }
-
-        Utf8Str strFullSnapshotFolder;
-        calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
-
-        ComObjPtr<Medium> diff;
-        diff.createObject();
-        // store this diff in the same registry as the parent
-        Guid uuidRegistryParent;
-        if (!medium->getFirstRegistryMachineId(uuidRegistryParent))
-        {
-            // parent image has no registry: this can happen if we're attaching a new immutable
-            // image that has not yet been attached (medium then points to the base and we're
-            // creating the diff image for the immutable, and the parent is not yet registered);
-            // put the parent in the machine registry then
-            mediumLock.release();
-            treeLock.release();
-            alock.release();
-            addMediumToRegistry(medium);
-            alock.acquire();
-            treeLock.acquire();
-            mediumLock.acquire();
-            medium->getFirstRegistryMachineId(uuidRegistryParent);
-        }
-        rc = diff->init(mParent,
-                        medium->getPreferredDiffFormat(),
-                        strFullSnapshotFolder.append(RTPATH_SLASH_STR),
-                        uuidRegistryParent);
-        if (FAILED(rc)) return rc;
-
-        /* Apply the normal locking logic to the entire chain. */
-        MediumLockList *pMediumLockList(new MediumLockList());
-        mediumLock.release();
-        treeLock.release();
-        rc = diff->createMediumLockList(true /* fFailIfInaccessible */,
-                                        true /* fMediumLockWrite */,
-                                        medium,
-                                        *pMediumLockList);
-        treeLock.acquire();
-        mediumLock.acquire();
-        if (SUCCEEDED(rc))
-        {
-            mediumLock.release();
-            treeLock.release();
-            rc = pMediumLockList->Lock();
-            treeLock.acquire();
-            mediumLock.acquire();
-            if (FAILED(rc))
-                setError(rc,
-                         tr("Could not lock medium when creating diff '%s'"),
-                         diff->getLocationFull().c_str());
-            else
-            {
-                /* will release the lock before the potentially lengthy
-                 * operation, so protect with the special state */
-                MachineState_T oldState = mData->mMachineState;
-                setMachineState(MachineState_SettingUp);
-
-                mediumLock.release();
-                treeLock.release();
-                alock.release();
-
-                rc = medium->createDiffStorage(diff,
-                                               MediumVariant_Standard,
-                                               pMediumLockList,
-                                               NULL /* aProgress */,
-                                               true /* aWait */);
-
-                alock.acquire();
-                treeLock.acquire();
-                mediumLock.acquire();
-
-                setMachineState(oldState);
-            }
-        }
-
-        /* Unlock the media and free the associated memory. */
-        delete pMediumLockList;
-
-        if (FAILED(rc)) return rc;
-
-        /* use the created diff for the actual attachment */
-        medium = diff;
-        mediumCaller.attach(medium);
-        if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
-        mediumLock.attach(medium);
-    }
-    while (0);
-
-    ComObjPtr<MediumAttachment> attachment;
-    attachment.createObject();
-    rc = attachment->init(this,
-                          medium,
-                          aControllerName,
-                          aControllerPort,
-                          aDevice,
-                          aType,
-                          fIndirect,
-                          false /* fPassthrough */,
-                          false /* fTempEject */,
-                          false /* fNonRotational */,
-                          false /* fDiscard */,
-                          Utf8Str::Empty);
-    if (FAILED(rc)) return rc;
-
-    if (associate && !medium.isNull())
-    {
-        // as the last step, associate the medium to the VM
-        rc = medium->addBackReference(mData->mUuid);
-        // here we can fail because of Deleting, or being in process of creating a Diff
-        if (FAILED(rc)) return rc;
-
-        mediumLock.release();
-        treeLock.release();
-        alock.release();
-        addMediumToRegistry(medium);
-        alock.acquire();
-        treeLock.acquire();
-        mediumLock.acquire();
-    }
-
-    /* success: finally remember the attachment */
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-    mMediaData->mAttachments.push_back(attachment);
-
-    mediumLock.release();
-    treeLock.release();
-    alock.release();
-
-    if (fHotplug || fSilent)
-    {
-        if (!medium.isNull())
-        {
-            MediumLockList *pMediumLockList(new MediumLockList());
-
-            rc = medium->createMediumLockList(true /* fFailIfInaccessible */,
-                                              true /* fMediumLockWrite */,
-                                              NULL,
-                                              *pMediumLockList);
-            alock.acquire();
-            if (FAILED(rc))
-                delete pMediumLockList;
-            else
-            {
-                mData->mSession.mLockedMedia.Unlock();
-                alock.release();
-                rc = mData->mSession.mLockedMedia.Insert(attachment, pMediumLockList);
-                mData->mSession.mLockedMedia.Lock();
-                alock.acquire();
-            }
-            alock.release();
-        }
-
-        if (SUCCEEDED(rc))
-        {
-            rc = onStorageDeviceChange(attachment, FALSE /* aRemove */, fSilent);
-            /* Remove lock list in case of error. */
-            if (FAILED(rc))
-            {
-                mData->mSession.mLockedMedia.Unlock();
-                mData->mSession.mLockedMedia.Remove(attachment);
-                mData->mSession.mLockedMedia.Lock();
-            }
-        }
-    }
-
-    mParent->saveModifiedRegistries();
-
-    return rc;
-}
-
-STDMETHODIMP Machine::DetachDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                   LONG aDevice)
-{
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
-                     aControllerName, aControllerPort, aDevice));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
-
-    /* Check for an existing controller. */
-    ComObjPtr<StorageController> ctl;
-    rc = getStorageControllerByName(aControllerName, ctl, true /* aSetError */);
-    if (FAILED(rc)) return rc;
-
-    StorageControllerType_T ctrlType;
-    rc = ctl->COMGETTER(ControllerType)(&ctrlType);
-    if (FAILED(rc))
-        return setError(E_FAIL,
-                        tr("Could not get type of controller '%ls'"),
-                        aControllerName);
-
-    bool fSilent = false;
-    Utf8Str strReconfig;
-
-    /* Check whether the flag to allow silent storage attachment reconfiguration is set. */
-    strReconfig = getExtraData(Utf8Str("VBoxInternal2/SilentReconfigureWhilePaused"));
-    if (FAILED(rc))
-        return rc;
-    if (   mData->mMachineState == MachineState_Paused
-        && strReconfig == "1")
-        fSilent = true;
-
-    /* Check that the controller can do hotplugging if we detach the device while the VM is running. */
-    bool fHotplug = false;
-    if (!fSilent && Global::IsOnlineOrTransient(mData->mMachineState))
-        fHotplug = true;
-
-    if (fHotplug && !isControllerHotplugCapable(ctrlType))
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Controller '%ls' does not support hotplugging"),
-                        aControllerName);
-
-    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
-                                               aControllerName,
-                                               aControllerPort,
-                                               aDevice);
-    if (!pAttach)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-    /*
-     * The VM has to detach the device before we delete any implicit diffs.
-     * If this fails we can roll back without loosing data.
-     */
-    if (fHotplug || fSilent)
-    {
-        alock.release();
-        rc = onStorageDeviceChange(pAttach, TRUE /* aRemove */, fSilent);
-        alock.acquire();
-    }
-    if (FAILED(rc)) return rc;
-
-    /* If we are here everything went well and we can delete the implicit now. */
-    rc = detachDevice(pAttach, alock, NULL /* pSnapshot */);
-
-    alock.release();
-
-    mParent->saveModifiedRegistries();
-
-    return rc;
-}
-
-STDMETHODIMP Machine::PassthroughDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                        LONG aDevice, BOOL aPassthrough)
-{
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aPassthrough=%d\n",
-                     aControllerName, aControllerPort, aDevice, aPassthrough));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
-
-    if (Global::IsOnlineOrTransient(mData->mMachineState))
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Invalid machine state: %s"),
-                        Global::stringifyMachineState(mData->mMachineState));
-
-    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
-                                               aControllerName,
-                                               aControllerPort,
-                                               aDevice);
-    if (!pAttach)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-
-    AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-
-    if (pAttach->getType() != DeviceType_DVD)
-        return setError(E_INVALIDARG,
-                        tr("Setting passthrough rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
-                        aDevice, aControllerPort, aControllerName);
-    pAttach->updatePassthrough(!!aPassthrough);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::TemporaryEjectDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                           LONG aDevice, BOOL aTemporaryEject)
-{
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aTemporaryEject=%d\n",
-                     aControllerName, aControllerPort, aDevice, aTemporaryEject));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
-                                               aControllerName,
-                                               aControllerPort,
-                                               aDevice);
-    if (!pAttach)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-
-    AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-
-    if (pAttach->getType() != DeviceType_DVD)
-        return setError(E_INVALIDARG,
-                        tr("Setting temporary eject flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a DVD"),
-                        aDevice, aControllerPort, aControllerName);
-    pAttach->updateTempEject(!!aTemporaryEject);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::NonRotationalDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                          LONG aDevice, BOOL aNonRotational)
-{
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aNonRotational=%d\n",
-                     aControllerName, aControllerPort, aDevice, aNonRotational));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
-
-    if (Global::IsOnlineOrTransient(mData->mMachineState))
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Invalid machine state: %s"),
-                        Global::stringifyMachineState(mData->mMachineState));
-
-    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
-                                               aControllerName,
-                                               aControllerPort,
-                                               aDevice);
-    if (!pAttach)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-
-    AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-
-    if (pAttach->getType() != DeviceType_HardDisk)
-        return setError(E_INVALIDARG,
-                        tr("Setting the non-rotational medium flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a hard disk"),
-                        aDevice, aControllerPort, aControllerName);
-    pAttach->updateNonRotational(!!aNonRotational);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SetAutoDiscardForDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                              LONG aDevice, BOOL aDiscard)
-{
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aDiscard=%d\n",
-                     aControllerName, aControllerPort, aDevice, aDiscard));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
-
-    if (Global::IsOnlineOrTransient(mData->mMachineState))
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Invalid machine state: %s"),
-                        Global::stringifyMachineState(mData->mMachineState));
-
-    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
-                                               aControllerName,
-                                               aControllerPort,
-                                               aDevice);
-    if (!pAttach)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-
-    AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-
-    if (pAttach->getType() != DeviceType_HardDisk)
-        return setError(E_INVALIDARG,
-                        tr("Setting the discard medium flag rejected as the device attached to device slot %d on port %d of controller '%ls' is not a hard disk"),
-                        aDevice, aControllerPort, aControllerName);
-    pAttach->updateDiscard(!!aDiscard);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SetNoBandwidthGroupForDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                                   LONG aDevice)
-{
-    int rc = S_OK;
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
-                     aControllerName, aControllerPort, aDevice));
-
-    rc = SetBandwidthGroupForDevice(aControllerName, aControllerPort, aDevice, NULL);
-
-    return rc;
-}
-
-STDMETHODIMP Machine::SetBandwidthGroupForDevice(IN_BSTR aControllerName, LONG aControllerPort,
-                                                 LONG aDevice, IBandwidthGroup *aBandwidthGroup)
-{
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
-                     aControllerName, aControllerPort, aDevice));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    AssertReturn(mData->mMachineState != MachineState_Saved, E_FAIL);
-
-    if (Global::IsOnlineOrTransient(mData->mMachineState))
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Invalid machine state: %s"),
-                        Global::stringifyMachineState(mData->mMachineState));
-
-    MediumAttachment *pAttach = findAttachment(mMediaData->mAttachments,
-                                               aControllerName,
-                                               aControllerPort,
-                                               aDevice);
-    if (!pAttach)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-
-    ComObjPtr<BandwidthGroup> group = static_cast<BandwidthGroup*>(aBandwidthGroup);
-    if (aBandwidthGroup && group.isNull())
-        return setError(E_INVALIDARG, "The given bandwidth group pointer is invalid");
-
-    AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-
-    const Utf8Str strBandwidthGroupOld = pAttach->getBandwidthGroup();
-    if (strBandwidthGroupOld.isNotEmpty())
-    {
-        /* Get the bandwidth group object and release it - this must not fail. */
-        ComObjPtr<BandwidthGroup> pBandwidthGroupOld;
-        rc = getBandwidthGroup(strBandwidthGroupOld, pBandwidthGroupOld, false);
-        Assert(SUCCEEDED(rc));
-
-        pBandwidthGroupOld->release();
-        pAttach->updateBandwidthGroup(Utf8Str::Empty);
-    }
-
-    if (!group.isNull())
-    {
-        group->reference();
-        pAttach->updateBandwidthGroup(group->getName());
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::AttachDeviceWithoutMedium(IN_BSTR aControllerName,
-                                                LONG    aControllerPort,
-                                                LONG    aDevice,
-                                                DeviceType_T aType)
-{
-     HRESULT rc = S_OK;
-
-     LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aType=%d aMedium=%p\n",
-                      aControllerName, aControllerPort, aDevice, aType));
-
-     rc = AttachDevice(aControllerName, aControllerPort, aDevice, aType, NULL);
-
-     return rc;
-}
-
-
-
-STDMETHODIMP Machine::UnmountMedium(IN_BSTR aControllerName,
-                                    LONG    aControllerPort,
-                                    LONG    aDevice,
-                                    BOOL    aForce)
-{
-     int rc = S_OK;
-     LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d",
-                      aControllerName, aControllerPort, aForce));
-
-     rc = MountMedium(aControllerName, aControllerPort, aDevice, NULL, aForce);
-
-     return rc;
-}
-
-STDMETHODIMP Machine::MountMedium(IN_BSTR aControllerName,
-                                  LONG aControllerPort,
-                                  LONG aDevice,
-                                  IMedium *aMedium,
-                                  BOOL aForce)
-{
-    int rc = S_OK;
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d aForce=%d\n",
-                     aControllerName, aControllerPort, aDevice, aForce));
-
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    // request the host lock first, since might be calling Host methods for getting host drives;
-    // next, protect the media tree all the while we're in here, as well as our member variables
-    AutoMultiWriteLock3 multiLock(mParent->host()->lockHandle(),
-                                  this->lockHandle(),
-                                  &mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
-                                                         aControllerName,
-                                                         aControllerPort,
-                                                         aDevice);
-    if (pAttach.isNull())
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No drive attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-    /* Remember previously mounted medium. The medium before taking the
-     * backup is not necessarily the same thing. */
-    ComObjPtr<Medium> oldmedium;
-    oldmedium = pAttach->getMedium();
-
-    ComObjPtr<Medium> pMedium = static_cast<Medium*>(aMedium);
-    if (aMedium && pMedium.isNull())
-        return setError(E_INVALIDARG, "The given medium pointer is invalid");
-
-    AutoCaller mediumCaller(pMedium);
-    if (FAILED(mediumCaller.rc())) return mediumCaller.rc();
-
-    AutoWriteLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-    if (pMedium)
-    {
-        DeviceType_T mediumType = pAttach->getType();
-        switch (mediumType)
-        {
-            case DeviceType_DVD:
-            case DeviceType_Floppy:
-            break;
-
-            default:
-                return setError(VBOX_E_INVALID_OBJECT_STATE,
-                                tr("The device at port %d, device %d of controller '%ls' of this virtual machine is not removeable"),
-                                aControllerPort,
-                                aDevice,
-                                aControllerName);
-        }
-    }
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-
-    {
-        // The backup operation makes the pAttach reference point to the
-        // old settings. Re-get the correct reference.
-        pAttach = findAttachment(mMediaData->mAttachments,
-                                 aControllerName,
-                                 aControllerPort,
-                                 aDevice);
-        if (!oldmedium.isNull())
-            oldmedium->removeBackReference(mData->mUuid);
-        if (!pMedium.isNull())
-        {
-            pMedium->addBackReference(mData->mUuid);
-
-            mediumLock.release();
-            multiLock.release();
-            addMediumToRegistry(pMedium);
-            multiLock.acquire();
-            mediumLock.acquire();
-        }
-
-        AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-        pAttach->updateMedium(pMedium);
-    }
-
-    setModified(IsModified_Storage);
-
-    mediumLock.release();
-    multiLock.release();
-    rc = onMediumChange(pAttach, aForce);
-    multiLock.acquire();
-    mediumLock.acquire();
-
-    /* On error roll back this change only. */
-    if (FAILED(rc))
-    {
-        if (!pMedium.isNull())
-            pMedium->removeBackReference(mData->mUuid);
-        pAttach = findAttachment(mMediaData->mAttachments,
-                                 aControllerName,
-                                 aControllerPort,
-                                 aDevice);
-        /* If the attachment is gone in the meantime, bail out. */
-        if (pAttach.isNull())
-            return rc;
-        AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-        if (!oldmedium.isNull())
-            oldmedium->addBackReference(mData->mUuid);
-        pAttach->updateMedium(oldmedium);
-    }
-
-    mediumLock.release();
-    multiLock.release();
-
-    mParent->saveModifiedRegistries();
-
-    return rc;
-}
-
-STDMETHODIMP Machine::GetMedium(IN_BSTR aControllerName,
-                                LONG aControllerPort,
-                                LONG aDevice,
-                                IMedium **aMedium)
-{
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
-                     aControllerName, aControllerPort, aDevice));
-
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-    CheckComArgOutPointerValid(aMedium);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aMedium = NULL;
-
-    ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
-                                                         aControllerName,
-                                                         aControllerPort,
-                                                         aDevice);
-    if (pAttach.isNull())
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-    pAttach->getMedium().queryInterfaceTo(aMedium);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetSerialPort(ULONG slot, ISerialPort **port)
-{
-    CheckComArgOutPointerValid(port);
-    CheckComArgExpr(slot, slot < RT_ELEMENTS(mSerialPorts));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mSerialPorts[slot].queryInterfaceTo(port);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetParallelPort(ULONG slot, IParallelPort **port)
-{
-    CheckComArgOutPointerValid(port);
-    CheckComArgExpr(slot, slot < RT_ELEMENTS(mParallelPorts));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mParallelPorts[slot].queryInterfaceTo(port);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetNetworkAdapter(ULONG slot, INetworkAdapter **adapter)
-{
-    CheckComArgOutPointerValid(adapter);
-    /* Do not assert if slot is out of range, just return the advertised
-       status.  testdriver/vbox.py triggers this in logVmInfo. */
-    if (slot >= mNetworkAdapters.size())
-        return setError(E_INVALIDARG,
-                        tr("No network adapter in slot %RU32 (total %RU32 adapters)"),
-                        slot, mNetworkAdapters.size());
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mNetworkAdapters[slot].queryInterfaceTo(adapter);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetExtraDataKeys(ComSafeArrayOut(BSTR, aKeys))
-{
-    CheckComArgOutSafeArrayPointerValid(aKeys);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    com::SafeArray<BSTR> saKeys(mData->pMachineConfigFile->mapExtraDataItems.size());
-    int i = 0;
-    for (settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.begin();
-         it != mData->pMachineConfigFile->mapExtraDataItems.end();
-         ++it, ++i)
-    {
-        const Utf8Str &strKey = it->first;
-        strKey.cloneTo(&saKeys[i]);
-    }
-    saKeys.detachTo(ComSafeArrayOutArg(aKeys));
-
-    return S_OK;
-  }
-
-  /**
-   *  @note Locks this object for reading.
-   */
-STDMETHODIMP Machine::GetExtraData(IN_BSTR aKey,
-                                   BSTR *aValue)
-{
-    CheckComArgStrNotEmptyOrNull(aKey);
-    CheckComArgOutPointerValid(aValue);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* start with nothing found */
-    Bstr bstrResult("");
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(Utf8Str(aKey));
-    if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
-        // found:
-        bstrResult = it->second; // source is a Utf8Str
-
-    /* return the result to caller (may be empty) */
-    bstrResult.cloneTo(aValue);
-
-    return S_OK;
-}
-
-  /**
-   *  @note Locks mParent for writing + this object for writing.
-   */
-STDMETHODIMP Machine::SetExtraData(IN_BSTR aKey, IN_BSTR aValue)
-{
-    CheckComArgStrNotEmptyOrNull(aKey);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    Utf8Str strKey(aKey);
-    Utf8Str strValue(aValue);
-    Utf8Str strOldValue;            // empty
-
-    // locking note: we only hold the read lock briefly to look up the old value,
-    // then release it and call the onExtraCanChange callbacks. There is a small
-    // chance of a race insofar as the callback might be called twice if two callers
-    // change the same key at the same time, but that's a much better solution
-    // than the deadlock we had here before. The actual changing of the extradata
-    // is then performed under the write lock and race-free.
-
-    // look up the old value first; if nothing has changed then we need not do anything
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
-        settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
-        if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
-            strOldValue = it->second;
-    }
-
-    bool fChanged;
-    if ((fChanged = (strOldValue != strValue)))
-    {
-        // ask for permission from all listeners outside the locks;
-        // onExtraDataCanChange() only briefly requests the VirtualBox
-        // lock to copy the list of callbacks to invoke
-        Bstr error;
-        Bstr bstrValue(aValue);
-
-        if (!mParent->onExtraDataCanChange(mData->mUuid, aKey, bstrValue.raw(), error))
-        {
-            const char *sep = error.isEmpty() ? "" : ": ";
-            CBSTR err = error.raw();
-            LogWarningFunc(("Someone vetoed! Change refused%s%ls\n",
-                            sep, err));
-            return setError(E_ACCESSDENIED,
-                            tr("Could not set extra data because someone refused the requested change of '%ls' to '%ls'%s%ls"),
-                            aKey,
-                            bstrValue.raw(),
-                            sep,
-                            err);
-        }
-
-        // data is changing and change not vetoed: then write it out under the lock
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        if (isSnapshotMachine())
-        {
-            HRESULT rc = checkStateDependency(MutableStateDep);
-            if (FAILED(rc)) return rc;
-        }
-
-        if (strValue.isEmpty())
-            mData->pMachineConfigFile->mapExtraDataItems.erase(strKey);
-        else
-            mData->pMachineConfigFile->mapExtraDataItems[strKey] = strValue;
-                // creates a new key if needed
-
-        bool fNeedsGlobalSaveSettings = false;
-        saveSettings(&fNeedsGlobalSaveSettings);
-
-        if (fNeedsGlobalSaveSettings)
-        {
-            // save the global settings; for that we should hold only the VirtualBox lock
-            alock.release();
-            AutoWriteLock vboxlock(mParent COMMA_LOCKVAL_SRC_POS);
-            mParent->saveSettings();
-        }
-    }
-
-    // fire notification outside the lock
-    if (fChanged)
-        mParent->onExtraDataChange(mData->mUuid, aKey, aValue);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::SaveSettings()
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock mlock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* when there was auto-conversion, we want to save the file even if
-     * the VM is saved */
-    HRESULT rc = checkStateDependency(MutableOrSavedStateDep);
-    if (FAILED(rc)) return rc;
-
-    /* the settings file path may never be null */
-    ComAssertRet(!mData->m_strConfigFileFull.isEmpty(), E_FAIL);
-
-    /* save all VM data excluding snapshots */
-    bool fNeedsGlobalSaveSettings = false;
-    rc = saveSettings(&fNeedsGlobalSaveSettings);
-    mlock.release();
-
-    if (SUCCEEDED(rc) && fNeedsGlobalSaveSettings)
-    {
-        // save the global settings; for that we should hold only the VirtualBox lock
-        AutoWriteLock vlock(mParent COMMA_LOCKVAL_SRC_POS);
-        rc = mParent->saveSettings();
-    }
-
-    return rc;
-}
-
-STDMETHODIMP Machine::DiscardSettings()
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    /*
-     *  during this rollback, the session will be notified if data has
-     *  been actually changed
-     */
-    rollback(true /* aNotify */);
-
-    return S_OK;
-}
-
-/** @note Locks objects! */
-STDMETHODIMP Machine::Unregister(CleanupMode_T cleanupMode,
-                                 ComSafeArrayOut(IMedium*, aMedia))
-{
-    // use AutoLimitedCaller because this call is valid on inaccessible machines as well
-    AutoLimitedCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    Guid id(getId());
-
-    if (mData->mSession.mState != SessionState_Unlocked)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Cannot unregister the machine '%s' while it is locked"),
-                        mUserData->s.strName.c_str());
-
-    // wait for state dependents to drop to zero
-    ensureNoStateDependencies();
-
-    if (!mData->mAccessible)
-    {
-        // inaccessible maschines can only be unregistered; uninitialize ourselves
-        // here because currently there may be no unregistered that are inaccessible
-        // (this state combination is not supported). Note releasing the caller and
-        // leaving the lock before calling uninit()
-        alock.release();
-        autoCaller.release();
-
-        uninit();
-
-        mParent->unregisterMachine(this, id);
-            // calls VirtualBox::saveSettings()
-
-        return S_OK;
-    }
-
-    HRESULT rc = S_OK;
-
-    // discard saved state
-    if (mData->mMachineState == MachineState_Saved)
-    {
-        // add the saved state file to the list of files the caller should delete
-        Assert(!mSSData->strStateFilePath.isEmpty());
-        mData->llFilesToDelete.push_back(mSSData->strStateFilePath);
-
-        mSSData->strStateFilePath.setNull();
-
-        // unconditionally set the machine state to powered off, we now
-        // know no session has locked the machine
-        mData->mMachineState = MachineState_PoweredOff;
-    }
-
-    size_t cSnapshots = 0;
-    if (mData->mFirstSnapshot)
-        cSnapshots = mData->mFirstSnapshot->getAllChildrenCount() + 1;
-    if (cSnapshots && cleanupMode == CleanupMode_UnregisterOnly)
-        // fail now before we start detaching media
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("Cannot unregister the machine '%s' because it has %d snapshots"),
-                           mUserData->s.strName.c_str(), cSnapshots);
-
-    // This list collects the medium objects from all medium attachments
-    // which we will detach from the machine and its snapshots, in a specific
-    // order which allows for closing all media without getting "media in use"
-    // errors, simply by going through the list from the front to the back:
-    // 1) first media from machine attachments (these have the "leaf" attachments with snapshots
-    //    and must be closed before the parent media from the snapshots, or closing the parents
-    //    will fail because they still have children);
-    // 2) media from the youngest snapshots followed by those from the parent snapshots until
-    //    the root ("first") snapshot of the machine.
-    MediaList llMedia;
-
-    if (    !mMediaData.isNull()      // can be NULL if machine is inaccessible
-         && mMediaData->mAttachments.size()
-       )
-    {
-        // we have media attachments: detach them all and add the Medium objects to our list
-        if (cleanupMode != CleanupMode_UnregisterOnly)
-            detachAllMedia(alock, NULL /* pSnapshot */, cleanupMode, llMedia);
-        else
-            return setError(VBOX_E_INVALID_OBJECT_STATE,
-                            tr("Cannot unregister the machine '%s' because it has %d media attachments"),
-                            mUserData->s.strName.c_str(), mMediaData->mAttachments.size());
-    }
-
-    if (cSnapshots)
-    {
-        // autoCleanup must be true here, or we would have failed above
-
-        // add the media from the medium attachments of the snapshots to llMedia
-        // as well, after the "main" machine media; Snapshot::uninitRecursively()
-        // calls Machine::detachAllMedia() for the snapshot machine, recursing
-        // into the children first
-
-        // Snapshot::beginDeletingSnapshot() asserts if the machine state is not this
-        MachineState_T oldState = mData->mMachineState;
-        mData->mMachineState = MachineState_DeletingSnapshot;
-
-        // make a copy of the first snapshot so the refcount does not drop to 0
-        // in beginDeletingSnapshot, which sets pFirstSnapshot to 0 (that hangs
-        // because of the AutoCaller voodoo)
-        ComObjPtr<Snapshot> pFirstSnapshot = mData->mFirstSnapshot;
-
-        // GO!
-        pFirstSnapshot->uninitRecursively(alock, cleanupMode, llMedia, mData->llFilesToDelete);
-
-        mData->mMachineState = oldState;
-    }
-
-    if (FAILED(rc))
-    {
-        rollbackMedia();
-        return rc;
-    }
-
-    // commit all the media changes made above
-    commitMedia();
-
-    mData->mRegistered = false;
-
-    // machine lock no longer needed
-    alock.release();
-
-    // return media to caller
-    SafeIfaceArray<IMedium> sfaMedia(llMedia);
-    sfaMedia.detachTo(ComSafeArrayOutArg(aMedia));
-
-    mParent->unregisterMachine(this, id);
-            // calls VirtualBox::saveSettings() and VirtualBox::saveModifiedRegistries()
-
-    return S_OK;
-}
-
-struct Machine::DeleteTask
-{
-    ComObjPtr<Machine>          pMachine;
-    RTCList<ComPtr<IMedium> >   llMediums;
-    StringsList                 llFilesToDelete;
-    ComObjPtr<Progress>         pProgress;
-};
-
-STDMETHODIMP Machine::DeleteConfig(ComSafeArrayIn(IMedium*, aMedia), IProgress **aProgress)
-{
-    LogFlowFuncEnter();
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    if (mData->mRegistered)
-        return setError(VBOX_E_INVALID_VM_STATE,
-                        tr("Cannot delete settings of a registered machine"));
-
-    DeleteTask *pTask = new DeleteTask;
-    pTask->pMachine = this;
-    com::SafeIfaceArray<IMedium> sfaMedia(ComSafeArrayInArg(aMedia));
-
-    // collect files to delete
-    pTask->llFilesToDelete = mData->llFilesToDelete;            // saved states pushed here by Unregister()
-
-    for (size_t i = 0; i < sfaMedia.size(); ++i)
-    {
-        IMedium *pIMedium(sfaMedia[i]);
-        ComObjPtr<Medium> pMedium = static_cast<Medium*>(pIMedium);
-        if (pMedium.isNull())
-            return setError(E_INVALIDARG, "The given medium pointer with index %d is invalid", i);
-        SafeArray<BSTR> ids;
-        rc = pMedium->COMGETTER(MachineIds)(ComSafeArrayAsOutParam(ids));
-        if (FAILED(rc)) return rc;
-        /* At this point the medium should not have any back references
-         * anymore. If it has it is attached to another VM and *must* not
-         * deleted. */
-        if (ids.size() < 1)
-            pTask->llMediums.append(pMedium);
-    }
-    if (mData->pMachineConfigFile->fileExists())
-        pTask->llFilesToDelete.push_back(mData->m_strConfigFileFull);
-
-    pTask->pProgress.createObject();
-    pTask->pProgress->init(getVirtualBox(),
-                           static_cast<IMachine*>(this) /* aInitiator */,
-                           Bstr(tr("Deleting files")).raw(),
-                           true /* fCancellable */,
-                           pTask->llFilesToDelete.size() + pTask->llMediums.size() + 1,   // cOperations
-                           BstrFmt(tr("Deleting '%s'"), pTask->llFilesToDelete.front().c_str()).raw());
-
-    int vrc = RTThreadCreate(NULL,
-                             Machine::deleteThread,
-                             (void*)pTask,
-                             0,
-                             RTTHREADTYPE_MAIN_WORKER,
-                             0,
-                             "MachineDelete");
-
-    pTask->pProgress.queryInterfaceTo(aProgress);
-
-    if (RT_FAILURE(vrc))
-    {
-        delete pTask;
-        return setError(E_FAIL, "Could not create MachineDelete thread (%Rrc)", vrc);
-    }
-
-    LogFlowFuncLeave();
-
-    return S_OK;
-}
-
-/**
- * Static task wrapper passed to RTThreadCreate() in Machine::Delete() which then
- * calls Machine::deleteTaskWorker() on the actual machine object.
- * @param Thread
- * @param pvUser
- * @return
- */
-/*static*/
-DECLCALLBACK(int) Machine::deleteThread(RTTHREAD Thread, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    DeleteTask *pTask = (DeleteTask*)pvUser;
-    Assert(pTask);
-    Assert(pTask->pMachine);
-    Assert(pTask->pProgress);
-
-    HRESULT rc = pTask->pMachine->deleteTaskWorker(*pTask);
-    pTask->pProgress->notifyComplete(rc);
-
-    delete pTask;
-
-    LogFlowFuncLeave();
-
-    NOREF(Thread);
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Task thread implementation for Machine::Delete(), called from Machine::deleteThread().
- * @param task
- * @return
- */
-HRESULT Machine::deleteTaskWorker(DeleteTask &task)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-
-    try
-    {
-        ULONG uLogHistoryCount = 3;
-        ComPtr<ISystemProperties> systemProperties;
-        rc = mParent->COMGETTER(SystemProperties)(systemProperties.asOutParam());
-        if (FAILED(rc)) throw rc;
-
-        if (!systemProperties.isNull())
-        {
-            rc = systemProperties->COMGETTER(LogHistoryCount)(&uLogHistoryCount);
-            if (FAILED(rc)) throw rc;
-        }
-
-        MachineState_T oldState = mData->mMachineState;
-        setMachineState(MachineState_SettingUp);
-        alock.release();
-        for (size_t i = 0; i < task.llMediums.size(); ++i)
-        {
-            ComObjPtr<Medium> pMedium = (Medium*)(IMedium*)task.llMediums.at(i);
-            {
-                AutoCaller mac(pMedium);
-                if (FAILED(mac.rc())) throw mac.rc();
-                Utf8Str strLocation = pMedium->getLocationFull();
-                rc = task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), strLocation.c_str()).raw(), 1);
-                if (FAILED(rc)) throw rc;
-                LogFunc(("Deleting file %s\n", strLocation.c_str()));
-            }
-            ComPtr<IProgress> pProgress2;
-            rc = pMedium->DeleteStorage(pProgress2.asOutParam());
-            if (FAILED(rc)) throw rc;
-            rc = task.pProgress->WaitForAsyncProgressCompletion(pProgress2);
-            if (FAILED(rc)) throw rc;
-            /* Check the result of the asynchrony process. */
-            LONG iRc;
-            rc = pProgress2->COMGETTER(ResultCode)(&iRc);
-            if (FAILED(rc)) throw rc;
-            /* If the thread of the progress object has an error, then
-             * retrieve the error info from there, or it'll be lost. */
-            if (FAILED(iRc))
-                throw setError(ProgressErrorInfo(pProgress2));
-        }
-        setMachineState(oldState);
-        alock.acquire();
-
-        // delete the files pushed on the task list by Machine::Delete()
-        // (this includes saved states of the machine and snapshots and
-        // medium storage files from the IMedium list passed in, and the
-        // machine XML file)
-        StringsList::const_iterator it = task.llFilesToDelete.begin();
-        while (it != task.llFilesToDelete.end())
-        {
-            const Utf8Str &strFile = *it;
-            LogFunc(("Deleting file %s\n", strFile.c_str()));
-            int vrc = RTFileDelete(strFile.c_str());
-            if (RT_FAILURE(vrc))
-                throw setError(VBOX_E_IPRT_ERROR,
-                               tr("Could not delete file '%s' (%Rrc)"), strFile.c_str(), vrc);
-
-            ++it;
-            if (it == task.llFilesToDelete.end())
-            {
-                rc = task.pProgress->SetNextOperation(Bstr(tr("Cleaning up machine directory")).raw(), 1);
-                if (FAILED(rc)) throw rc;
-                break;
-            }
-
-            rc = task.pProgress->SetNextOperation(BstrFmt(tr("Deleting '%s'"), it->c_str()).raw(), 1);
-            if (FAILED(rc)) throw rc;
-        }
-
-        /* delete the settings only when the file actually exists */
-        if (mData->pMachineConfigFile->fileExists())
-        {
-            /* Delete any backup or uncommitted XML files. Ignore failures.
-               See the fSafe parameter of xml::XmlFileWriter::write for details. */
-            /** @todo Find a way to avoid referring directly to iprt/xml.h here. */
-            Utf8Str otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszTmpSuff);
-            RTFileDelete(otherXml.c_str());
-            otherXml = Utf8StrFmt("%s%s", mData->m_strConfigFileFull.c_str(), xml::XmlFileWriter::s_pszPrevSuff);
-            RTFileDelete(otherXml.c_str());
-
-            /* delete the Logs folder, nothing important should be left
-             * there (we don't check for errors because the user might have
-             * some private files there that we don't want to delete) */
-            Utf8Str logFolder;
-            getLogFolder(logFolder);
-            Assert(logFolder.length());
-            if (RTDirExists(logFolder.c_str()))
-            {
-                /* Delete all VBox.log[.N] files from the Logs folder
-                 * (this must be in sync with the rotation logic in
-                 * Console::powerUpThread()). Also, delete the VBox.png[.N]
-                 * files that may have been created by the GUI. */
-                Utf8Str log = Utf8StrFmt("%s%cVBox.log",
-                                         logFolder.c_str(), RTPATH_DELIMITER);
-                RTFileDelete(log.c_str());
-                log = Utf8StrFmt("%s%cVBox.png",
-                                 logFolder.c_str(), RTPATH_DELIMITER);
-                RTFileDelete(log.c_str());
-                for (int i = uLogHistoryCount; i > 0; i--)
-                {
-                    log = Utf8StrFmt("%s%cVBox.log.%d",
-                                     logFolder.c_str(), RTPATH_DELIMITER, i);
-                    RTFileDelete(log.c_str());
-                    log = Utf8StrFmt("%s%cVBox.png.%d",
-                                     logFolder.c_str(), RTPATH_DELIMITER, i);
-                    RTFileDelete(log.c_str());
-                }
-
-                RTDirRemove(logFolder.c_str());
-            }
-
-            /* delete the Snapshots folder, nothing important should be left
-             * there (we don't check for errors because the user might have
-             * some private files there that we don't want to delete) */
-            Utf8Str strFullSnapshotFolder;
-            calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
-            Assert(!strFullSnapshotFolder.isEmpty());
-            if (RTDirExists(strFullSnapshotFolder.c_str()))
-                RTDirRemove(strFullSnapshotFolder.c_str());
-
-            // delete the directory that contains the settings file, but only
-            // if it matches the VM name
-            Utf8Str settingsDir;
-            if (isInOwnDir(&settingsDir))
-                RTDirRemove(settingsDir.c_str());
-        }
-
-        alock.release();
-
-        mParent->saveModifiedRegistries();
-    }
-    catch (HRESULT aRC) { rc = aRC; }
-
-    return rc;
-}
-
-STDMETHODIMP Machine::FindSnapshot(IN_BSTR aNameOrId, ISnapshot **aSnapshot)
-{
-    CheckComArgOutPointerValid(aSnapshot);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<Snapshot> pSnapshot;
-    HRESULT rc;
-
-    if (!aNameOrId || !*aNameOrId)
-        // null case (caller wants root snapshot): findSnapshotById() handles this
-        rc = findSnapshotById(Guid(), pSnapshot, true /* aSetError */);
-    else
-    {
-        Guid uuid(aNameOrId);
-        if (uuid.isValid())
-            rc = findSnapshotById(uuid, pSnapshot, true /* aSetError */);
-        else
-            rc = findSnapshotByName(Utf8Str(aNameOrId), pSnapshot, true /* aSetError */);
-    }
-    pSnapshot.queryInterfaceTo(aSnapshot);
-
-    return rc;
-}
-
-STDMETHODIMP Machine::CreateSharedFolder(IN_BSTR aName, IN_BSTR aHostPath, BOOL aWritable, BOOL aAutoMount)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgStrNotEmptyOrNull(aHostPath);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    Utf8Str strName(aName);
-
-    ComObjPtr<SharedFolder> sharedFolder;
-    rc = findSharedFolder(strName, sharedFolder, false /* aSetError */);
-    if (SUCCEEDED(rc))
-        return setError(VBOX_E_OBJECT_IN_USE,
-                        tr("Shared folder named '%s' already exists"),
-                        strName.c_str());
-
-    sharedFolder.createObject();
-    rc = sharedFolder->init(getMachine(),
-                            strName,
-                            aHostPath,
-                            !!aWritable,
-                            !!aAutoMount,
-                            true /* fFailOnError */);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_SharedFolders);
-    mHWData.backup();
-    mHWData->mSharedFolders.push_back(sharedFolder);
-
-    /* inform the direct session if any */
-    alock.release();
-    onSharedFolderChange();
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::RemoveSharedFolder(IN_BSTR aName)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    ComObjPtr<SharedFolder> sharedFolder;
-    rc = findSharedFolder(aName, sharedFolder, true /* aSetError */);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_SharedFolders);
-    mHWData.backup();
-    mHWData->mSharedFolders.remove(sharedFolder);
-
-    /* inform the direct session if any */
-    alock.release();
-    onSharedFolderChange();
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::CanShowConsoleWindow(BOOL *aCanShow)
-{
-    CheckComArgOutPointerValid(aCanShow);
-
-    /* start with No */
-    *aCanShow = FALSE;
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        if (mData->mSession.mState != SessionState_Locked)
-            return setError(VBOX_E_INVALID_VM_STATE,
-                            tr("Machine is not locked for session (session state: %s)"),
-                            Global::stringifySessionState(mData->mSession.mState));
-
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore calls made after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    LONG64 dummy;
-    return directControl->OnShowWindow(TRUE /* aCheck */, aCanShow, &dummy);
-}
-
-STDMETHODIMP Machine::ShowConsoleWindow(LONG64 *aWinId)
-{
-    CheckComArgOutPointerValid(aWinId);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        if (mData->mSession.mState != SessionState_Locked)
-            return setError(E_FAIL,
-                            tr("Machine is not locked for session (session state: %s)"),
-                            Global::stringifySessionState(mData->mSession.mState));
-
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore calls made after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    BOOL dummy;
-    return directControl->OnShowWindow(FALSE /* aCheck */, &dummy, aWinId);
-}
-
-#ifdef VBOX_WITH_GUEST_PROPS
-/**
- * Look up a guest property in VBoxSVC's internal structures.
- */
-HRESULT Machine::getGuestPropertyFromService(IN_BSTR aName,
-                                             BSTR *aValue,
-                                             LONG64 *aTimestamp,
-                                             BSTR *aFlags) const
-{
-    using namespace guestProp;
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    Utf8Str strName(aName);
-    HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.find(strName);
-
-    if (it != mHWData->mGuestProperties.end())
-    {
-        char szFlags[MAX_FLAGS_LEN + 1];
-        it->second.strValue.cloneTo(aValue);
-        *aTimestamp = it->second.mTimestamp;
-        writeFlags(it->second.mFlags, szFlags);
-        Bstr(szFlags).cloneTo(aFlags);
-    }
-
-    return S_OK;
-}
-
-/**
- * Query the VM that a guest property belongs to for the property.
- * @returns E_ACCESSDENIED if the VM process is not available or not
- *          currently handling queries and the lookup should then be done in
- *          VBoxSVC.
- */
-HRESULT Machine::getGuestPropertyFromVM(IN_BSTR aName,
-                                        BSTR *aValue,
-                                        LONG64 *aTimestamp,
-                                        BSTR *aFlags) const
-{
-    HRESULT rc;
-    ComPtr<IInternalSessionControl> directControl;
-    directControl = mData->mSession.mDirectControl;
-
-    /* fail if we were called after #OnSessionEnd() is called.  This is a
-     * silly race condition. */
-
-    if (!directControl)
-        rc = E_ACCESSDENIED;
-    else
-        rc = directControl->AccessGuestProperty(aName, NULL, NULL,
-                                                false /* isSetter */,
-                                                aValue, aTimestamp, aFlags);
-    return rc;
-}
-#endif // VBOX_WITH_GUEST_PROPS
-
-STDMETHODIMP Machine::GetGuestProperty(IN_BSTR aName,
-                                       BSTR *aValue,
-                                       LONG64 *aTimestamp,
-                                       BSTR *aFlags)
-{
-#ifndef VBOX_WITH_GUEST_PROPS
-    ReturnComNotImplemented();
-#else // VBOX_WITH_GUEST_PROPS
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgOutPointerValid(aValue);
-    CheckComArgOutPointerValid(aTimestamp);
-    CheckComArgOutPointerValid(aFlags);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc = getGuestPropertyFromVM(aName, aValue, aTimestamp, aFlags);
-    if (rc == E_ACCESSDENIED)
-        /* The VM is not running or the service is not (yet) accessible */
-        rc = getGuestPropertyFromService(aName, aValue, aTimestamp, aFlags);
-    return rc;
-#endif // VBOX_WITH_GUEST_PROPS
-}
-
-STDMETHODIMP Machine::GetGuestPropertyValue(IN_BSTR aName, BSTR *aValue)
-{
-    LONG64 dummyTimestamp;
-    Bstr dummyFlags;
-    return GetGuestProperty(aName, aValue, &dummyTimestamp, dummyFlags.asOutParam());
-}
-
-STDMETHODIMP Machine::GetGuestPropertyTimestamp(IN_BSTR aName, LONG64 *aTimestamp)
-{
-    Bstr dummyValue;
-    Bstr dummyFlags;
-    return GetGuestProperty(aName, dummyValue.asOutParam(), aTimestamp, dummyFlags.asOutParam());
-}
-
-#ifdef VBOX_WITH_GUEST_PROPS
-/**
- * Set a guest property in VBoxSVC's internal structures.
- */
-HRESULT Machine::setGuestPropertyToService(IN_BSTR aName, IN_BSTR aValue,
-                                           IN_BSTR aFlags)
-{
-    using namespace guestProp;
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    HRESULT rc = S_OK;
-
-    rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    try
-    {
-        Utf8Str utf8Name(aName);
-        Utf8Str utf8Flags(aFlags);
-        uint32_t fFlags = NILFLAG;
-        if (   aFlags != NULL
-            && RT_FAILURE(validateFlags(utf8Flags.c_str(), &fFlags)))
-            return setError(E_INVALIDARG,
-                            tr("Invalid guest property flag values: '%ls'"),
-                            aFlags);
-
-        bool fDelete = !RT_VALID_PTR(aValue) || *(aValue) == '\0';
-        HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(utf8Name);
-        if (it == mHWData->mGuestProperties.end())
-        {
-            if (!fDelete)
-            {
-                setModified(IsModified_MachineData);
-                mHWData.backupEx();
-
-                RTTIMESPEC time;
-                HWData::GuestProperty prop;
-                prop.strValue   = aValue;
-                prop.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
-                prop.mFlags     = fFlags;
-                mHWData->mGuestProperties[Utf8Str(aName)] = prop;
-            }
-        }
-        else
-        {
-            if (it->second.mFlags & (RDONLYHOST))
-            {
-                rc = setError(E_ACCESSDENIED,
-                              tr("The property '%ls' cannot be changed by the host"),
-                              aName);
-            }
-            else
-            {
-                setModified(IsModified_MachineData);
-                mHWData.backupEx();
-
-                /* The backupEx() operation invalidates our iterator,
-                 * so get a new one. */
-                it = mHWData->mGuestProperties.find(utf8Name);
-                Assert(it != mHWData->mGuestProperties.end());
-
-                if (!fDelete)
-                {
-                    RTTIMESPEC time;
-                    it->second.strValue   = aValue;
-                    it->second.mTimestamp = RTTimeSpecGetNano(RTTimeNow(&time));
-                    it->second.mFlags     = fFlags;
-                }
-                else
-                    mHWData->mGuestProperties.erase(it);
-            }
-        }
-
-        if (   SUCCEEDED(rc)
-            && (   mHWData->mGuestPropertyNotificationPatterns.isEmpty()
-                || RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
-                                                RTSTR_MAX,
-                                                utf8Name.c_str(),
-                                                RTSTR_MAX,
-                                                NULL)
-               )
-           )
-        {
-            alock.release();
-
-            mParent->onGuestPropertyChange(mData->mUuid, aName,
-                                           aValue ? aValue : Bstr("").raw(),
-                                           aFlags ? aFlags : Bstr("").raw());
-        }
-    }
-    catch (std::bad_alloc &)
-    {
-        rc = E_OUTOFMEMORY;
-    }
-
-    return rc;
-}
-
-/**
- * Set a property on the VM that that property belongs to.
- * @returns E_ACCESSDENIED if the VM process is not available or not
- *          currently handling queries and the setting should then be done in
- *          VBoxSVC.
- */
-HRESULT Machine::setGuestPropertyToVM(IN_BSTR aName, IN_BSTR aValue,
-                                      IN_BSTR aFlags)
-{
-    HRESULT rc;
-
-    try
-    {
-        ComPtr<IInternalSessionControl> directControl = mData->mSession.mDirectControl;
-
-        BSTR dummy = NULL; /* will not be changed (setter) */
-        LONG64 dummy64;
-        if (!directControl)
-            rc = E_ACCESSDENIED;
-        else
-            /** @todo Fix when adding DeleteGuestProperty(), see defect. */
-            rc = directControl->AccessGuestProperty(aName, aValue, aFlags,
-                                                    true /* isSetter */,
-                                                    &dummy, &dummy64, &dummy);
-    }
-    catch (std::bad_alloc &)
-    {
-        rc = E_OUTOFMEMORY;
-    }
-
-    return rc;
-}
-#endif // VBOX_WITH_GUEST_PROPS
-
-STDMETHODIMP Machine::SetGuestProperty(IN_BSTR aName, IN_BSTR aValue,
-                                       IN_BSTR aFlags)
-{
-#ifndef VBOX_WITH_GUEST_PROPS
-    ReturnComNotImplemented();
-#else // VBOX_WITH_GUEST_PROPS
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgMaybeNull(aFlags);
-    CheckComArgMaybeNull(aValue);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc()))
-        return autoCaller.rc();
-
-    HRESULT rc = setGuestPropertyToVM(aName, aValue, aFlags);
-    if (rc == E_ACCESSDENIED)
-        /* The VM is not running or the service is not (yet) accessible */
-        rc = setGuestPropertyToService(aName, aValue, aFlags);
-    return rc;
-#endif // VBOX_WITH_GUEST_PROPS
-}
-
-STDMETHODIMP Machine::SetGuestPropertyValue(IN_BSTR aName, IN_BSTR aValue)
-{
-    return SetGuestProperty(aName, aValue, NULL);
-}
-
-STDMETHODIMP Machine::DeleteGuestProperty(IN_BSTR aName)
-{
-    return SetGuestProperty(aName, NULL, NULL);
-}
-
-#ifdef VBOX_WITH_GUEST_PROPS
-/**
- * Enumerate the guest properties in VBoxSVC's internal structures.
- */
-HRESULT Machine::enumerateGuestPropertiesInService
-                (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
-                 ComSafeArrayOut(BSTR, aValues),
-                 ComSafeArrayOut(LONG64, aTimestamps),
-                 ComSafeArrayOut(BSTR, aFlags))
-{
-    using namespace guestProp;
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-    Utf8Str strPatterns(aPatterns);
-
-    HWData::GuestPropertyMap propMap;
-
-    /*
-     * Look for matching patterns and build up a list.
-     */
-    HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.begin();
-    while (it != mHWData->mGuestProperties.end())
-    {
-        if (   strPatterns.isEmpty()
-            || RTStrSimplePatternMultiMatch(strPatterns.c_str(),
-                                            RTSTR_MAX,
-                                            it->first.c_str(),
-                                            RTSTR_MAX,
-                                            NULL)
-           )
-        {
-            propMap.insert(*it);
-        }
-
-        it++;
-    }
-
-    alock.release();
-
-    /*
-     * And build up the arrays for returning the property information.
-     */
-    size_t cEntries = propMap.size();
-    SafeArray<BSTR> names(cEntries);
-    SafeArray<BSTR> values(cEntries);
-    SafeArray<LONG64> timestamps(cEntries);
-    SafeArray<BSTR> flags(cEntries);
-    size_t iProp = 0;
-
-    it = propMap.begin();
-    while (it != propMap.end())
-    {
-         char szFlags[MAX_FLAGS_LEN + 1];
-         it->first.cloneTo(&names[iProp]);
-         it->second.strValue.cloneTo(&values[iProp]);
-         timestamps[iProp] = it->second.mTimestamp;
-         writeFlags(it->second.mFlags, szFlags);
-         Bstr(szFlags).cloneTo(&flags[iProp++]);
-         it++;
-    }
-    names.detachTo(ComSafeArrayOutArg(aNames));
-    values.detachTo(ComSafeArrayOutArg(aValues));
-    timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
-    flags.detachTo(ComSafeArrayOutArg(aFlags));
-    return S_OK;
-}
-
-/**
- * Enumerate the properties managed by a VM.
- * @returns E_ACCESSDENIED if the VM process is not available or not
- *          currently handling queries and the setting should then be done in
- *          VBoxSVC.
- */
-HRESULT Machine::enumerateGuestPropertiesOnVM
-                (IN_BSTR aPatterns, ComSafeArrayOut(BSTR, aNames),
-                 ComSafeArrayOut(BSTR, aValues),
-                 ComSafeArrayOut(LONG64, aTimestamps),
-                 ComSafeArrayOut(BSTR, aFlags))
-{
-    HRESULT rc;
-    ComPtr<IInternalSessionControl> directControl;
-    directControl = mData->mSession.mDirectControl;
-
-    if (!directControl)
-        rc = E_ACCESSDENIED;
-    else
-        rc = directControl->EnumerateGuestProperties
-                     (aPatterns, ComSafeArrayOutArg(aNames),
-                      ComSafeArrayOutArg(aValues),
-                      ComSafeArrayOutArg(aTimestamps),
-                      ComSafeArrayOutArg(aFlags));
-    return rc;
-}
-#endif // VBOX_WITH_GUEST_PROPS
-
-STDMETHODIMP Machine::EnumerateGuestProperties(IN_BSTR aPatterns,
-                                               ComSafeArrayOut(BSTR, aNames),
-                                               ComSafeArrayOut(BSTR, aValues),
-                                               ComSafeArrayOut(LONG64, aTimestamps),
-                                               ComSafeArrayOut(BSTR, aFlags))
-{
-#ifndef VBOX_WITH_GUEST_PROPS
-    ReturnComNotImplemented();
-#else // VBOX_WITH_GUEST_PROPS
-    CheckComArgMaybeNull(aPatterns);
-    CheckComArgOutSafeArrayPointerValid(aNames);
-    CheckComArgOutSafeArrayPointerValid(aValues);
-    CheckComArgOutSafeArrayPointerValid(aTimestamps);
-    CheckComArgOutSafeArrayPointerValid(aFlags);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc = enumerateGuestPropertiesOnVM
-                     (aPatterns, ComSafeArrayOutArg(aNames),
-                      ComSafeArrayOutArg(aValues),
-                      ComSafeArrayOutArg(aTimestamps),
-                      ComSafeArrayOutArg(aFlags));
-    if (rc == E_ACCESSDENIED)
-        /* The VM is not running or the service is not (yet) accessible */
-        rc = enumerateGuestPropertiesInService
-                     (aPatterns, ComSafeArrayOutArg(aNames),
-                      ComSafeArrayOutArg(aValues),
-                      ComSafeArrayOutArg(aTimestamps),
-                      ComSafeArrayOutArg(aFlags));
-    return rc;
-#endif // VBOX_WITH_GUEST_PROPS
-}
-
-STDMETHODIMP Machine::GetMediumAttachmentsOfController(IN_BSTR aName,
-                                                       ComSafeArrayOut(IMediumAttachment*, aAttachments))
-{
-    MediaData::AttachmentList atts;
-
-    HRESULT rc = getMediumAttachmentsOfController(aName, atts);
-    if (FAILED(rc)) return rc;
-
-    SafeIfaceArray<IMediumAttachment> attachments(atts);
-    attachments.detachTo(ComSafeArrayOutArg(aAttachments));
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetMediumAttachment(IN_BSTR aControllerName,
-                                          LONG aControllerPort,
-                                          LONG aDevice,
-                                          IMediumAttachment **aAttachment)
-{
-    LogFlowThisFunc(("aControllerName=\"%ls\" aControllerPort=%d aDevice=%d\n",
-                     aControllerName, aControllerPort, aDevice));
-
-    CheckComArgStrNotEmptyOrNull(aControllerName);
-    CheckComArgOutPointerValid(aAttachment);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    *aAttachment = NULL;
-
-    ComObjPtr<MediumAttachment> pAttach = findAttachment(mMediaData->mAttachments,
-                                                         aControllerName,
-                                                         aControllerPort,
-                                                         aDevice);
-    if (pAttach.isNull())
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("No storage device attached to device slot %d on port %d of controller '%ls'"),
-                        aDevice, aControllerPort, aControllerName);
-
-    pAttach.queryInterfaceTo(aAttachment);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::AddStorageController(IN_BSTR aName,
-                                           StorageBus_T aConnectionType,
-                                           IStorageController **controller)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    if (   (aConnectionType <= StorageBus_Null)
-        || (aConnectionType >  StorageBus_SAS))
-        return setError(E_INVALIDARG,
-                        tr("Invalid connection type: %d"),
-                        aConnectionType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    /* try to find one with the name first. */
-    ComObjPtr<StorageController> ctrl;
-
-    rc = getStorageControllerByName(aName, ctrl, false /* aSetError */);
-    if (SUCCEEDED(rc))
-        return setError(VBOX_E_OBJECT_IN_USE,
-                        tr("Storage controller named '%ls' already exists"),
-                        aName);
-
-    ctrl.createObject();
-
-    /* get a new instance number for the storage controller */
-    ULONG ulInstance = 0;
-    bool fBootable = true;
-    for (StorageControllerList::const_iterator it = mStorageControllers->begin();
-         it != mStorageControllers->end();
-         ++it)
-    {
-        if ((*it)->getStorageBus() == aConnectionType)
-        {
-            ULONG ulCurInst = (*it)->getInstance();
-
-            if (ulCurInst >= ulInstance)
-                ulInstance = ulCurInst + 1;
-
-            /* Only one controller of each type can be marked as bootable. */
-            if ((*it)->getBootable())
-                fBootable = false;
-        }
-    }
-
-    rc = ctrl->init(this, aName, aConnectionType, ulInstance, fBootable);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_Storage);
-    mStorageControllers.backup();
-    mStorageControllers->push_back(ctrl);
-
-    ctrl.queryInterfaceTo(controller);
-
-    /* inform the direct session if any */
-    alock.release();
-    onStorageControllerChange();
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetStorageControllerByName(IN_BSTR aName,
-                                                 IStorageController **aStorageController)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<StorageController> ctrl;
-
-    HRESULT rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
-    if (SUCCEEDED(rc))
-        ctrl.queryInterfaceTo(aStorageController);
-
-    return rc;
-}
-
-STDMETHODIMP Machine::GetStorageControllerByInstance(ULONG aInstance,
-                                                     IStorageController **aStorageController)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    for (StorageControllerList::const_iterator it = mStorageControllers->begin();
-         it != mStorageControllers->end();
-         ++it)
-    {
-        if ((*it)->getInstance() == aInstance)
-        {
-            (*it).queryInterfaceTo(aStorageController);
-            return S_OK;
-        }
-    }
-
-    return setError(VBOX_E_OBJECT_NOT_FOUND,
-                    tr("Could not find a storage controller with instance number '%lu'"),
-                    aInstance);
-}
-
-STDMETHODIMP Machine::SetStorageControllerBootable(IN_BSTR aName, BOOL fBootable)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    ComObjPtr<StorageController> ctrl;
-
-    rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
-    if (SUCCEEDED(rc))
-    {
-        /* Ensure that only one controller of each type is marked as bootable. */
-        if (fBootable == TRUE)
-        {
-            for (StorageControllerList::const_iterator it = mStorageControllers->begin();
-                 it != mStorageControllers->end();
-                 ++it)
-            {
-                ComObjPtr<StorageController> aCtrl = (*it);
-
-                if (   (aCtrl->getName() != Utf8Str(aName))
-                    && aCtrl->getBootable() == TRUE
-                    && aCtrl->getStorageBus() == ctrl->getStorageBus()
-                    && aCtrl->getControllerType() == ctrl->getControllerType())
-                {
-                    aCtrl->setBootable(FALSE);
-                    break;
-                }
-            }
-        }
-
-        if (SUCCEEDED(rc))
-        {
-            ctrl->setBootable(fBootable);
-            setModified(IsModified_Storage);
-        }
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        /* inform the direct session if any */
-        alock.release();
-        onStorageControllerChange();
-    }
-
-    return rc;
-}
-
-STDMETHODIMP Machine::RemoveStorageController(IN_BSTR aName)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    ComObjPtr<StorageController> ctrl;
-    rc = getStorageControllerByName(aName, ctrl, true /* aSetError */);
-    if (FAILED(rc)) return rc;
-
-    {
-        /* find all attached devices to the appropriate storage controller and detach them all */
-        // make a temporary list because detachDevice invalidates iterators into
-        // mMediaData->mAttachments
-        MediaData::AttachmentList llAttachments2 = mMediaData->mAttachments;
-
-        for (MediaData::AttachmentList::iterator it = llAttachments2.begin();
-             it != llAttachments2.end();
-             ++it)
-        {
-            MediumAttachment *pAttachTemp = *it;
-
-            AutoCaller localAutoCaller(pAttachTemp);
-            if (FAILED(localAutoCaller.rc())) return localAutoCaller.rc();
-
-            AutoReadLock local_alock(pAttachTemp COMMA_LOCKVAL_SRC_POS);
-
-            if (pAttachTemp->getControllerName() == aName)
-            {
-                rc = detachDevice(pAttachTemp, alock, NULL);
-                if (FAILED(rc)) return rc;
-            }
-        }
-    }
-
-    /* We can remove it now. */
-    setModified(IsModified_Storage);
-    mStorageControllers.backup();
-
-    ctrl->unshare();
-
-    mStorageControllers->remove(ctrl);
-
-    /* inform the direct session if any */
-    alock.release();
-    onStorageControllerChange();
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::AddUSBController(IN_BSTR aName, USBControllerType_T aType,
-                                       IUSBController **controller)
-{
-    if (   (aType <= USBControllerType_Null)
-        || (aType >= USBControllerType_Last))
-        return setError(E_INVALIDARG,
-                        tr("Invalid USB controller type: %d"),
-                        aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    /* try to find one with the same type first. */
-    ComObjPtr<USBController> ctrl;
-
-    rc = getUSBControllerByName(aName, ctrl, false /* aSetError */);
-    if (SUCCEEDED(rc))
-        return setError(VBOX_E_OBJECT_IN_USE,
-                        tr("USB controller named '%ls' already exists"),
-                        aName);
-
-    /* Check that we don't exceed the maximum number of USB controllers for the given type. */
-    ULONG maxInstances;
-    rc = mParent->getSystemProperties()->GetMaxInstancesOfUSBControllerType(mHWData->mChipsetType, aType, &maxInstances);
-    if (FAILED(rc))
-        return rc;
-
-    ULONG cInstances = getUSBControllerCountByType(aType);
-    if (cInstances >= maxInstances)
-        return setError(E_INVALIDARG,
-                        tr("Too many USB controllers of this type"));
-
-    ctrl.createObject();
-
-    rc = ctrl->init(this, aName, aType);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_USB);
-    mUSBControllers.backup();
-    mUSBControllers->push_back(ctrl);
-
-    ctrl.queryInterfaceTo(controller);
-
-    /* inform the direct session if any */
-    alock.release();
-    onUSBControllerChange();
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetUSBControllerByName(IN_BSTR aName, IUSBController **aUSBController)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<USBController> ctrl;
-
-    HRESULT rc = getUSBControllerByName(aName, ctrl, true /* aSetError */);
-    if (SUCCEEDED(rc))
-        ctrl.queryInterfaceTo(aUSBController);
-
-    return rc;
-}
-
-STDMETHODIMP Machine::GetUSBControllerCountByType(USBControllerType_T aType,
-                                                  ULONG *aControllers)
-{
-    CheckComArgOutPointerValid(aControllers);
-
-    if (   (aType <= USBControllerType_Null)
-        || (aType >= USBControllerType_Last))
-        return setError(E_INVALIDARG,
-                        tr("Invalid USB controller type: %d"),
-                        aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<USBController> ctrl;
-
-    *aControllers = getUSBControllerCountByType(aType);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::RemoveUSBController(IN_BSTR aName)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(MutableStateDep);
-    if (FAILED(rc)) return rc;
-
-    ComObjPtr<USBController> ctrl;
-    rc = getUSBControllerByName(aName, ctrl, true /* aSetError */);
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_USB);
-    mUSBControllers.backup();
-
-    ctrl->unshare();
-
-    mUSBControllers->remove(ctrl);
-
-    /* inform the direct session if any */
-    alock.release();
-    onUSBControllerChange();
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::QuerySavedGuestScreenInfo(ULONG uScreenId,
-                                                ULONG *puOriginX,
-                                                ULONG *puOriginY,
-                                                ULONG *puWidth,
-                                                ULONG *puHeight,
-                                                BOOL *pfEnabled)
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(puOriginX);
-    CheckComArgNotNull(puOriginY);
-    CheckComArgNotNull(puWidth);
-    CheckComArgNotNull(puHeight);
-    CheckComArgNotNull(pfEnabled);
-
-    uint32_t u32OriginX= 0;
-    uint32_t u32OriginY= 0;
-    uint32_t u32Width = 0;
-    uint32_t u32Height = 0;
-    uint16_t u16Flags = 0;
-
-    int vrc = readSavedGuestScreenInfo(mSSData->strStateFilePath, uScreenId,
-                                       &u32OriginX, &u32OriginY, &u32Width, &u32Height, &u16Flags);
-    if (RT_FAILURE(vrc))
-    {
-#ifdef RT_OS_WINDOWS
-        /* HACK: GUI sets *pfEnabled to 'true' and expects it to stay so if the API fails.
-         * This works with XPCOM. But Windows COM sets all output parameters to zero.
-         * So just assign fEnable to TRUE again.
-         * The right fix would be to change GUI API wrappers to make sure that parameters
-         * are changed only if API succeeds.
-         */
-        *pfEnabled = TRUE;
-#endif
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved guest size is not available (%Rrc)"),
-                        vrc);
-    }
-
-    *puOriginX = u32OriginX;
-    *puOriginY = u32OriginY;
-    *puWidth = u32Width;
-    *puHeight = u32Height;
-    *pfEnabled = (u16Flags & VBVA_SCREEN_F_DISABLED) == 0;
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::QuerySavedThumbnailSize(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight)
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aSize);
-    CheckComArgNotNull(aWidth);
-    CheckComArgNotNull(aHeight);
-
-    if (aScreenId != 0)
-        return E_NOTIMPL;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    uint8_t *pu8Data = NULL;
-    uint32_t cbData = 0;
-    uint32_t u32Width = 0;
-    uint32_t u32Height = 0;
-
-    int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
-
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot data is not available (%Rrc)"),
-                        vrc);
-
-    *aSize = cbData;
-    *aWidth = u32Width;
-    *aHeight = u32Height;
-
-    freeSavedDisplayScreenshot(pu8Data);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::ReadSavedThumbnailToArray(ULONG aScreenId, BOOL aBGR, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData))
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aWidth);
-    CheckComArgNotNull(aHeight);
-    CheckComArgOutSafeArrayPointerValid(aData);
-
-    if (aScreenId != 0)
-        return E_NOTIMPL;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    uint8_t *pu8Data = NULL;
-    uint32_t cbData = 0;
-    uint32_t u32Width = 0;
-    uint32_t u32Height = 0;
-
-    int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
-
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot data is not available (%Rrc)"),
-                        vrc);
-
-    *aWidth = u32Width;
-    *aHeight = u32Height;
-
-    com::SafeArray<BYTE> bitmap(cbData);
-    /* Convert pixels to format expected by the API caller. */
-    if (aBGR)
-    {
-        /* [0] B, [1] G, [2] R, [3] A. */
-        for (unsigned i = 0; i < cbData; i += 4)
-        {
-            bitmap[i]     = pu8Data[i];
-            bitmap[i + 1] = pu8Data[i + 1];
-            bitmap[i + 2] = pu8Data[i + 2];
-            bitmap[i + 3] = 0xff;
-        }
-    }
-    else
-    {
-        /* [0] R, [1] G, [2] B, [3] A. */
-        for (unsigned i = 0; i < cbData; i += 4)
-        {
-            bitmap[i]     = pu8Data[i + 2];
-            bitmap[i + 1] = pu8Data[i + 1];
-            bitmap[i + 2] = pu8Data[i];
-            bitmap[i + 3] = 0xff;
-        }
-    }
-    bitmap.detachTo(ComSafeArrayOutArg(aData));
-
-    freeSavedDisplayScreenshot(pu8Data);
-
-    return S_OK;
-}
-
-
-STDMETHODIMP Machine::ReadSavedThumbnailPNGToArray(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData))
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aWidth);
-    CheckComArgNotNull(aHeight);
-    CheckComArgOutSafeArrayPointerValid(aData);
-
-    if (aScreenId != 0)
-        return E_NOTIMPL;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    uint8_t *pu8Data = NULL;
-    uint32_t cbData = 0;
-    uint32_t u32Width = 0;
-    uint32_t u32Height = 0;
-
-    int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 0 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
-
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot data is not available (%Rrc)"),
-                        vrc);
-
-    *aWidth = u32Width;
-    *aHeight = u32Height;
-
-    HRESULT rc = S_OK;
-    uint8_t *pu8PNG = NULL;
-    uint32_t cbPNG = 0;
-    uint32_t cxPNG = 0;
-    uint32_t cyPNG = 0;
-
-    vrc = DisplayMakePNG(pu8Data, u32Width, u32Height, &pu8PNG, &cbPNG, &cxPNG, &cyPNG, 0);
-
-    if (RT_SUCCESS(vrc))
-    {
-        com::SafeArray<BYTE> screenData(cbPNG);
-        screenData.initFrom(pu8PNG, cbPNG);
-        if (pu8PNG)
-            RTMemFree(pu8PNG);
-        screenData.detachTo(ComSafeArrayOutArg(aData));
-    }
-    else
-    {
-        if (pu8PNG)
-            RTMemFree(pu8PNG);
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Could not convert screenshot to PNG (%Rrc)"),
-                        vrc);
-    }
-
-    freeSavedDisplayScreenshot(pu8Data);
-
-    return rc;
-}
-
-STDMETHODIMP Machine::QuerySavedScreenshotPNGSize(ULONG aScreenId, ULONG *aSize, ULONG *aWidth, ULONG *aHeight)
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aSize);
-    CheckComArgNotNull(aWidth);
-    CheckComArgNotNull(aHeight);
-
-    if (aScreenId != 0)
-        return E_NOTIMPL;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    uint8_t *pu8Data = NULL;
-    uint32_t cbData = 0;
-    uint32_t u32Width = 0;
-    uint32_t u32Height = 0;
-
-    int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
-
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot data is not available (%Rrc)"),
-                        vrc);
-
-    *aSize = cbData;
-    *aWidth = u32Width;
-    *aHeight = u32Height;
-
-    freeSavedDisplayScreenshot(pu8Data);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::ReadSavedScreenshotPNGToArray(ULONG aScreenId, ULONG *aWidth, ULONG *aHeight, ComSafeArrayOut(BYTE, aData))
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aWidth);
-    CheckComArgNotNull(aHeight);
-    CheckComArgOutSafeArrayPointerValid(aData);
-
-    if (aScreenId != 0)
-        return E_NOTIMPL;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    uint8_t *pu8Data = NULL;
-    uint32_t cbData = 0;
-    uint32_t u32Width = 0;
-    uint32_t u32Height = 0;
-
-    int vrc = readSavedDisplayScreenshot(mSSData->strStateFilePath, 1 /* u32Type */, &pu8Data, &cbData, &u32Width, &u32Height);
-
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Saved screenshot thumbnail data is not available (%Rrc)"),
-                        vrc);
-
-    *aWidth = u32Width;
-    *aHeight = u32Height;
-
-    com::SafeArray<BYTE> png(cbData);
-    png.initFrom(pu8Data, cbData);
-    png.detachTo(ComSafeArrayOutArg(aData));
-
-    freeSavedDisplayScreenshot(pu8Data);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::HotPlugCPU(ULONG aCpu)
-{
-    HRESULT rc = S_OK;
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mHWData->mCPUHotPlugEnabled)
-        return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
-
-    if (aCpu >= mHWData->mCPUCount)
-        return setError(E_INVALIDARG, tr("CPU id exceeds number of possible CPUs [0:%lu]"), mHWData->mCPUCount-1);
-
-    if (mHWData->mCPUAttached[aCpu])
-        return setError(VBOX_E_OBJECT_IN_USE, tr("CPU %lu is already attached"), aCpu);
-
-    alock.release();
-    rc = onCPUChange(aCpu, false);
-    alock.acquire();
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mCPUAttached[aCpu] = true;
-
-    /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-    if (Global::IsOnline(mData->mMachineState))
-        saveSettings(NULL);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::HotUnplugCPU(ULONG aCpu)
-{
-    HRESULT rc = S_OK;
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mHWData->mCPUHotPlugEnabled)
-        return setError(E_INVALIDARG, tr("CPU hotplug is not enabled"));
-
-    if (aCpu >= SchemaDefs::MaxCPUCount)
-        return setError(E_INVALIDARG,
-                        tr("CPU index exceeds maximum CPU count (must be in range [0:%lu])"),
-                        SchemaDefs::MaxCPUCount);
-
-    if (!mHWData->mCPUAttached[aCpu])
-        return setError(VBOX_E_OBJECT_NOT_FOUND, tr("CPU %lu is not attached"), aCpu);
-
-    /* CPU 0 can't be detached */
-    if (aCpu == 0)
-        return setError(E_INVALIDARG, tr("It is not possible to detach CPU 0"));
-
-    alock.release();
-    rc = onCPUChange(aCpu, true);
-    alock.acquire();
-    if (FAILED(rc)) return rc;
-
-    setModified(IsModified_MachineData);
-    mHWData.backup();
-    mHWData->mCPUAttached[aCpu] = false;
-
-    /** Save settings if online - @todo why is this required? -- @bugref{6818} */
-    if (Global::IsOnline(mData->mMachineState))
-        saveSettings(NULL);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::GetCPUStatus(ULONG aCpu, BOOL *aCpuAttached)
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aCpuAttached);
-
-    *aCpuAttached = false;
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* If hotplug is enabled the CPU is always enabled. */
-    if (!mHWData->mCPUHotPlugEnabled)
-    {
-        if (aCpu < mHWData->mCPUCount)
-            *aCpuAttached = true;
-    }
-    else
-    {
-        if (aCpu < SchemaDefs::MaxCPUCount)
-            *aCpuAttached = mHWData->mCPUAttached[aCpu];
-    }
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::QueryLogFilename(ULONG aIdx, BSTR *aName)
-{
-    CheckComArgOutPointerValid(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    Utf8Str log = queryLogFilename(aIdx);
-    if (!RTFileExists(log.c_str()))
-        log.setNull();
-    log.cloneTo(aName);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::ReadLog(ULONG aIdx, LONG64 aOffset, LONG64 aSize, ComSafeArrayOut(BYTE, aData))
-{
-    LogFlowThisFunc(("\n"));
-    CheckComArgOutSafeArrayPointerValid(aData);
-    if (aSize < 0)
-        return setError(E_INVALIDARG, tr("The size argument (%lld) is negative"), aSize);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-    Utf8Str log = queryLogFilename(aIdx);
-
-    /* do not unnecessarily hold the lock while doing something which does
-     * not need the lock and potentially takes a long time. */
-    alock.release();
-
-    /* Limit the chunk size to 32K for now, as that gives better performance
-     * over (XP)COM, and keeps the SOAP reply size under 1M for the webservice.
-     * One byte expands to approx. 25 bytes of breathtaking XML. */
-    size_t cbData = (size_t)RT_MIN(aSize, 32768);
-    com::SafeArray<BYTE> logData(cbData);
-
-    RTFILE LogFile;
-    int vrc = RTFileOpen(&LogFile, log.c_str(),
-                         RTFILE_O_OPEN | RTFILE_O_READ | RTFILE_O_DENY_NONE);
-    if (RT_SUCCESS(vrc))
-    {
-        vrc = RTFileReadAt(LogFile, aOffset, logData.raw(), cbData, &cbData);
-        if (RT_SUCCESS(vrc))
-            logData.resize(cbData);
-        else
-            rc = setError(VBOX_E_IPRT_ERROR,
-                          tr("Could not read log file '%s' (%Rrc)"),
-                          log.c_str(), vrc);
-        RTFileClose(LogFile);
-    }
-    else
-        rc = setError(VBOX_E_IPRT_ERROR,
-                      tr("Could not open log file '%s' (%Rrc)"),
-                      log.c_str(), vrc);
-
-    if (FAILED(rc))
-        logData.resize(0);
-    logData.detachTo(ComSafeArrayOutArg(aData));
-
-    return rc;
-}
-
-
-/**
- * Currently this method doesn't attach device to the running VM,
- * just makes sure it's plugged on next VM start.
- */
-STDMETHODIMP Machine::AttachHostPCIDevice(LONG hostAddress, LONG desiredGuestAddress, BOOL /*tryToUnbind*/)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    // lock scope
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        HRESULT rc = checkStateDependency(MutableStateDep);
-        if (FAILED(rc)) return rc;
-
-        ChipsetType_T aChipset = ChipsetType_PIIX3;
-        COMGETTER(ChipsetType)(&aChipset);
-
-        if (aChipset != ChipsetType_ICH9)
-        {
-            return setError(E_INVALIDARG,
-                            tr("Host PCI attachment only supported with ICH9 chipset"));
-        }
-
-        // check if device with this host PCI address already attached
-        for (HWData::PCIDeviceAssignmentList::iterator it =  mHWData->mPCIDeviceAssignments.begin();
-             it !=  mHWData->mPCIDeviceAssignments.end();
-             ++it)
-        {
-            LONG iHostAddress = -1;
-            ComPtr<PCIDeviceAttachment> pAttach;
-            pAttach = *it;
-            pAttach->COMGETTER(HostAddress)(&iHostAddress);
-            if (iHostAddress == hostAddress)
-                return setError(E_INVALIDARG,
-                                tr("Device with host PCI address already attached to this VM"));
-        }
-
-        ComObjPtr<PCIDeviceAttachment> pda;
-        char name[32];
-
-        RTStrPrintf(name, sizeof(name), "host%02x:%02x.%x", (hostAddress>>8) & 0xff, (hostAddress & 0xf8) >> 3, hostAddress & 7);
-        Bstr bname(name);
-        pda.createObject();
-        pda->init(this, bname,  hostAddress, desiredGuestAddress, TRUE);
-        setModified(IsModified_MachineData);
-        mHWData.backup();
-        mHWData->mPCIDeviceAssignments.push_back(pda);
-    }
-
-    return S_OK;
-}
-
-/**
- * Currently this method doesn't detach device from the running VM,
- * just makes sure it's not plugged on next VM start.
- */
-STDMETHODIMP Machine::DetachHostPCIDevice(LONG hostAddress)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComObjPtr<PCIDeviceAttachment> pAttach;
-    bool fRemoved = false;
-    HRESULT rc;
-
-    // lock scope
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        rc = checkStateDependency(MutableStateDep);
-        if (FAILED(rc)) return rc;
-
-        for (HWData::PCIDeviceAssignmentList::iterator it =  mHWData->mPCIDeviceAssignments.begin();
-             it !=  mHWData->mPCIDeviceAssignments.end();
-             ++it)
-        {
-            LONG iHostAddress = -1;
-            pAttach = *it;
-            pAttach->COMGETTER(HostAddress)(&iHostAddress);
-            if (iHostAddress  != -1  && iHostAddress == hostAddress)
-            {
-                setModified(IsModified_MachineData);
-                mHWData.backup();
-                mHWData->mPCIDeviceAssignments.remove(pAttach);
-                fRemoved = true;
-                break;
-            }
-        }
-    }
-
-
-    /* Fire event outside of the lock */
-    if (fRemoved)
-    {
-        Assert(!pAttach.isNull());
-        ComPtr<IEventSource> es;
-        rc = mParent->COMGETTER(EventSource)(es.asOutParam());
-        Assert(SUCCEEDED(rc));
-        Bstr mid;
-        rc = this->COMGETTER(Id)(mid.asOutParam());
-        Assert(SUCCEEDED(rc));
-        fireHostPCIDevicePlugEvent(es, mid.raw(), false /* unplugged */, true /* success */, pAttach, NULL);
-    }
-
-    return fRemoved ? S_OK : setError(VBOX_E_OBJECT_NOT_FOUND,
-                                      tr("No host PCI device %08x attached"),
-                                      hostAddress
-                                      );
-}
-
-STDMETHODIMP Machine::COMGETTER(PCIDeviceAssignments)(ComSafeArrayOut(IPCIDeviceAttachment *, aAssignments))
-{
-    CheckComArgOutSafeArrayPointerValid(aAssignments);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    SafeIfaceArray<IPCIDeviceAttachment> assignments(mHWData->mPCIDeviceAssignments);
-    assignments.detachTo(ComSafeArrayOutArg(aAssignments));
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(BandwidthControl)(IBandwidthControl **aBandwidthControl)
-{
-    CheckComArgOutPointerValid(aBandwidthControl);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    mBandwidthControl.queryInterfaceTo(aBandwidthControl);
-
-    return S_OK;
-}
-
-STDMETHODIMP Machine::COMGETTER(TracingEnabled)(BOOL *pfEnabled)
-{
-    CheckComArgOutPointerValid(pfEnabled);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        *pfEnabled = mHWData->mDebugging.fTracingEnabled;
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(TracingEnabled)(BOOL fEnabled)
-{
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            hrc = mHWData.backupEx();
-            if (SUCCEEDED(hrc))
-            {
-                setModified(IsModified_MachineData);
-                mHWData->mDebugging.fTracingEnabled = fEnabled != FALSE;
-            }
-        }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(TracingConfig)(BSTR *pbstrConfig)
-{
-    CheckComArgOutPointerValid(pbstrConfig);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = mHWData->mDebugging.strTracingConfig.cloneToEx(pbstrConfig);
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(TracingConfig)(IN_BSTR bstrConfig)
-{
-    CheckComArgStr(bstrConfig);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            hrc = mHWData.backupEx();
-            if (SUCCEEDED(hrc))
-            {
-                hrc = mHWData->mDebugging.strTracingConfig.cloneEx(bstrConfig);
-                if (SUCCEEDED(hrc))
-                    setModified(IsModified_MachineData);
-            }
-        }
-    }
-    return hrc;
-
-}
-
-STDMETHODIMP Machine::COMGETTER(AllowTracingToAccessVM)(BOOL *pfAllow)
-{
-    CheckComArgOutPointerValid(pfAllow);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        *pfAllow = mHWData->mDebugging.fAllowTracingToAccessVM;
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(AllowTracingToAccessVM)(BOOL fAllow)
-{
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            hrc = mHWData.backupEx();
-            if (SUCCEEDED(hrc))
-            {
-                setModified(IsModified_MachineData);
-                mHWData->mDebugging.fAllowTracingToAccessVM = fAllow != FALSE;
-            }
-        }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(AutostartEnabled)(BOOL *pfEnabled)
-{
-    CheckComArgOutPointerValid(pfEnabled);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        *pfEnabled = mHWData->mAutostart.fAutostartEnabled;
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(AutostartEnabled)(BOOL fEnabled)
-{
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (   SUCCEEDED(hrc)
-            && mHWData->mAutostart.fAutostartEnabled != !!fEnabled)
-        {
-            AutostartDb *autostartDb = mParent->getAutostartDb();
-            int vrc;
-
-            if (fEnabled)
-                vrc = autostartDb->addAutostartVM(mUserData->s.strName.c_str());
-            else
-                vrc = autostartDb->removeAutostartVM(mUserData->s.strName.c_str());
-
-            if (RT_SUCCESS(vrc))
-            {
-                hrc = mHWData.backupEx();
-                if (SUCCEEDED(hrc))
-                {
-                    setModified(IsModified_MachineData);
-                    mHWData->mAutostart.fAutostartEnabled = fEnabled != FALSE;
-                }
-            }
-            else if (vrc == VERR_NOT_SUPPORTED)
-                hrc = setError(VBOX_E_NOT_SUPPORTED,
-                               tr("The VM autostart feature is not supported on this platform"));
-            else if (vrc == VERR_PATH_NOT_FOUND)
-                hrc = setError(E_FAIL,
-                               tr("The path to the autostart database is not set"));
-            else
-                hrc = setError(E_UNEXPECTED,
-                               tr("%s machine '%s' to the autostart database failed with %Rrc"),
-                               fEnabled ? "Adding" : "Removing",
-                               mUserData->s.strName.c_str(), vrc);
-        }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(AutostartDelay)(ULONG *puDelay)
-{
-    CheckComArgOutPointerValid(puDelay);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        *puDelay = mHWData->mAutostart.uAutostartDelay;
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(AutostartDelay)(ULONG uDelay)
-{
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            hrc = mHWData.backupEx();
-            if (SUCCEEDED(hrc))
-            {
-                setModified(IsModified_MachineData);
-                mHWData->mAutostart.uAutostartDelay = uDelay;
-            }
-        }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(AutostopType)(AutostopType_T *penmAutostopType)
-{
-    CheckComArgOutPointerValid(penmAutostopType);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        *penmAutostopType = mHWData->mAutostart.enmAutostopType;
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(AutostopType)(AutostopType_T enmAutostopType)
-{
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableStateDep);
-        if (   SUCCEEDED(hrc)
-            && mHWData->mAutostart.enmAutostopType != enmAutostopType)
-        {
-            AutostartDb *autostartDb = mParent->getAutostartDb();
-            int vrc;
-
-            if (enmAutostopType != AutostopType_Disabled)
-                vrc = autostartDb->addAutostopVM(mUserData->s.strName.c_str());
-            else
-                vrc = autostartDb->removeAutostopVM(mUserData->s.strName.c_str());
-
-            if (RT_SUCCESS(vrc))
-            {
-                hrc = mHWData.backupEx();
-                if (SUCCEEDED(hrc))
-                {
-                    setModified(IsModified_MachineData);
-                    mHWData->mAutostart.enmAutostopType = enmAutostopType;
-                }
-            }
-            else if (vrc == VERR_NOT_SUPPORTED)
-                hrc = setError(VBOX_E_NOT_SUPPORTED,
-                               tr("The VM autostop feature is not supported on this platform"));
-            else if (vrc == VERR_PATH_NOT_FOUND)
-                hrc = setError(E_FAIL,
-                               tr("The path to the autostart database is not set"));
-            else
-                hrc = setError(E_UNEXPECTED,
-                               tr("%s machine '%s' to the autostop database failed with %Rrc"),
-                               enmAutostopType != AutostopType_Disabled ? "Adding" : "Removing",
-                               mUserData->s.strName.c_str(), vrc);
-        }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(DefaultFrontend)(BSTR *aDefaultFrontend)
-{
-    CheckComArgOutPointerValid(aDefaultFrontend);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        mHWData->mDefaultFrontend.cloneTo(aDefaultFrontend);
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(DefaultFrontend)(IN_BSTR aDefaultFrontend)
-{
-    CheckComArgStr(aDefaultFrontend);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableOrSavedStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            hrc = mHWData.backupEx();
-            if (SUCCEEDED(hrc))
-            {
-                setModified(IsModified_MachineData);
-                mHWData->mDefaultFrontend = aDefaultFrontend;
-            }
-        }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(Icon)(ComSafeArrayOut(BYTE, aIcon))
-{
-    CheckComArgSafeArrayNotNull(aIcon);
-    CheckComArgOutSafeArrayPointerValid(aIcon);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        com::SafeArray<BYTE> icon(mUserData->mIcon.size());
-        memcpy(icon.raw(), &mUserData->mIcon[0], mUserData->mIcon.size());
-        icon.detachTo(ComSafeArrayOutArg(aIcon));
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMSETTER(Icon)(ComSafeArrayIn(BYTE, aIcon))
-{
-    CheckComArgSafeArrayNotNull(aIcon);
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        hrc = checkStateDependency(MutableOrSavedStateDep);
-        if (SUCCEEDED(hrc))
-        {
-            setModified(IsModified_MachineData);
-            mUserData.backup();
-            com::SafeArray<BYTE> icon(ComSafeArrayInArg(aIcon));
-            mUserData->mIcon.clear();
-            memcpy(&mUserData->mIcon[0], icon.raw(), mUserData->mIcon.size());
-         }
-    }
-    return hrc;
-}
-
-STDMETHODIMP Machine::COMGETTER(USBProxyAvailable)(BOOL *aAvailable)
-{
-    CheckComArgOutPointerValid(aAvailable);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-#ifdef VBOX_WITH_USB
-    *aAvailable = true;
-#else
-    *aAvailable = false;
-#endif
-    return S_OK;
-}
-
-STDMETHODIMP Machine::CloneTo(IMachine *pTarget, CloneMode_T mode, ComSafeArrayIn(CloneOptions_T, options), IProgress **pProgress)
-{
-    LogFlowFuncEnter();
-
-    CheckComArgNotNull(pTarget);
-    CheckComArgOutPointerValid(pProgress);
-
-    /* Convert the options. */
-    RTCList<CloneOptions_T> optList;
-    if (options != NULL)
-        optList = com::SafeArray<CloneOptions_T>(ComSafeArrayInArg(options)).toList();
-
-    if (optList.contains(CloneOptions_Link))
-    {
-        if (!isSnapshotMachine())
-            return setError(E_INVALIDARG,
-                            tr("Linked clone can only be created from a snapshot"));
-        if (mode != CloneMode_MachineState)
-            return setError(E_INVALIDARG,
-                            tr("Linked clone can only be created for a single machine state"));
-    }
-    AssertReturn(!(optList.contains(CloneOptions_KeepAllMACs) && optList.contains(CloneOptions_KeepNATMACs)), E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-
-    MachineCloneVM *pWorker = new MachineCloneVM(this, static_cast<Machine*>(pTarget), mode, optList);
-
-    HRESULT rc = pWorker->start(pProgress);
-
-    LogFlowFuncLeave();
-
-    return rc;
-}
-
-// public methods for internal purposes
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- * Adds the given IsModified_* flag to the dirty flags of the machine.
- * This must be called either during loadSettings or under the machine write lock.
- * @param fl
- */
-void Machine::setModified(uint32_t fl, bool fAllowStateModification /* = true */)
-{
-    mData->flModifications |= fl;
-    if (fAllowStateModification && isStateModificationAllowed())
-        mData->mCurrentStateModified = true;
-}
-
-/**
- * Adds the given IsModified_* flag to the dirty flags of the machine, taking
- * care of the write locking.
- *
- * @param   fModifications      The flag to add.
- */
-void Machine::setModifiedLock(uint32_t fModification, bool fAllowStateModification /* = true */)
-{
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    setModified(fModification, fAllowStateModification);
-}
-
-/**
- *  Saves the registry entry of this machine to the given configuration node.
- *
- *  @param aEntryNode Node to save the registry entry to.
- *
- *  @note locks this object for reading.
- */
-HRESULT Machine::saveRegistryEntry(settings::MachineRegistryEntry &data)
-{
-    AutoLimitedCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    data.uuid = mData->mUuid;
-    data.strSettingsFile = mData->m_strConfigFile;
-
-    return S_OK;
-}
-
-/**
- * Calculates the absolute path of the given path taking the directory of the
- * machine settings file as the current directory.
- *
- * @param  aPath    Path to calculate the absolute path for.
- * @param  aResult  Where to put the result (used only on success, can be the
- *                  same Utf8Str instance as passed in @a aPath).
- * @return IPRT result.
- *
- * @note Locks this object for reading.
- */
-int Machine::calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(!mData->m_strConfigFileFull.isEmpty(), VERR_GENERAL_FAILURE);
-
-    Utf8Str strSettingsDir = mData->m_strConfigFileFull;
-
-    strSettingsDir.stripFilename();
-    char folder[RTPATH_MAX];
-    int vrc = RTPathAbsEx(strSettingsDir.c_str(), strPath.c_str(), folder, sizeof(folder));
-    if (RT_SUCCESS(vrc))
-        aResult = folder;
-
-    return vrc;
-}
-
-/**
- * Copies strSource to strTarget, making it relative to the machine folder
- * if it is a subdirectory thereof, or simply copying it otherwise.
- *
- * @param strSource Path to evaluate and copy.
- * @param strTarget Buffer to receive target path.
- *
- * @note Locks this object for reading.
- */
-void Machine::copyPathRelativeToMachine(const Utf8Str &strSource,
-                                        Utf8Str &strTarget)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), (void)0);
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturnVoid(!mData->m_strConfigFileFull.isEmpty());
-    // use strTarget as a temporary buffer to hold the machine settings dir
-    strTarget = mData->m_strConfigFileFull;
-    strTarget.stripFilename();
-    if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
-    {
-        // is relative: then append what's left
-        strTarget = strSource.substr(strTarget.length() + 1); // skip '/'
-        // for empty paths (only possible for subdirs) use "." to avoid
-        // triggering default settings for not present config attributes.
-        if (strTarget.isEmpty())
-            strTarget = ".";
-    }
-    else
-        // is not relative: then overwrite
-        strTarget = strSource;
-}
-
-/**
- *  Returns the full path to the machine's log folder in the
- *  \a aLogFolder argument.
- */
-void Machine::getLogFolder(Utf8Str &aLogFolder)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    char szTmp[RTPATH_MAX];
-    int vrc = RTEnvGetEx(RTENV_DEFAULT, "VBOX_USER_VMLOGDIR", szTmp, sizeof(szTmp), NULL);
-    if (RT_SUCCESS(vrc))
-    {
-        if (szTmp[0] && !mUserData.isNull())
-        {
-            char szTmp2[RTPATH_MAX];
-            vrc = RTPathAbs(szTmp, szTmp2, sizeof(szTmp2));
-            if (RT_SUCCESS(vrc))
-                aLogFolder = BstrFmt("%s%c%s",
-                                     szTmp2,
-                                     RTPATH_DELIMITER,
-                                     mUserData->s.strName.c_str()); // path/to/logfolder/vmname
-        }
-        else
-            vrc = VERR_PATH_IS_RELATIVE;
-    }
-
-    if (RT_FAILURE(vrc))
-    {
-        // fallback if VBOX_USER_LOGHOME is not set or invalid
-        aLogFolder = mData->m_strConfigFileFull;    // path/to/machinesfolder/vmname/vmname.vbox
-        aLogFolder.stripFilename();                 // path/to/machinesfolder/vmname
-        aLogFolder.append(RTPATH_DELIMITER);
-        aLogFolder.append("Logs");                  // path/to/machinesfolder/vmname/Logs
-    }
-}
-
-/**
- *  Returns the full path to the machine's log file for an given index.
- */
-Utf8Str Machine::queryLogFilename(ULONG idx)
-{
-    Utf8Str logFolder;
-    getLogFolder(logFolder);
-    Assert(logFolder.length());
-    Utf8Str log;
-    if (idx == 0)
-        log = Utf8StrFmt("%s%cVBox.log",
-                         logFolder.c_str(), RTPATH_DELIMITER);
-    else
-        log = Utf8StrFmt("%s%cVBox.log.%d",
-                         logFolder.c_str(), RTPATH_DELIMITER, idx);
-    return log;
-}
-
-/**
- * Composes a unique saved state filename based on the current system time. The filename is
- * granular to the second so this will work so long as no more than one snapshot is taken on
- * a machine per second.
- *
- * Before version 4.1, we used this formula for saved state files:
- *      Utf8StrFmt("%s%c{%RTuuid}.sav", strFullSnapshotFolder.c_str(), RTPATH_DELIMITER, mData->mUuid.raw())
- * which no longer works because saved state files can now be shared between the saved state of the
- * "saved" machine and an online snapshot, and the following would cause problems:
- * 1) save machine
- * 2) create online snapshot from that machine state --> reusing saved state file
- * 3) save machine again --> filename would be reused, breaking the online snapshot
- *
- * So instead we now use a timestamp.
- *
- * @param str
- */
-void Machine::composeSavedStateFilename(Utf8Str &strStateFilePath)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        calculateFullPath(mUserData->s.strSnapshotFolder, strStateFilePath);
-    }
-
-    RTTIMESPEC ts;
-    RTTimeNow(&ts);
-    RTTIME time;
-    RTTimeExplode(&time, &ts);
-
-    strStateFilePath += RTPATH_DELIMITER;
-    strStateFilePath += Utf8StrFmt("%04d-%02u-%02uT%02u-%02u-%02u-%09uZ.sav",
-                                   time.i32Year, time.u8Month, time.u8MonthDay,
-                                   time.u8Hour, time.u8Minute, time.u8Second, time.u32Nanosecond);
-}
-
-/**
- *  Returns the full path to the default video capture file.
- */
-void Machine::getDefaultVideoCaptureFile(Utf8Str &strFile)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    strFile = mData->m_strConfigFileFull;       // path/to/machinesfolder/vmname/vmname.vbox
-    strFile.stripExt();                         // path/to/machinesfolder/vmname/vmname
-    strFile.append(".webm");                    // path/to/machinesfolder/vmname/vmname.webm
-}
-
-/**
- * Returns whether at least one USB controller is present for the VM.
- */
-bool Machine::isUSBControllerPresent()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), false);
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    return (mUSBControllers->size() > 0);
-}
-
-/**
- *  @note Locks this object for writing, calls the client process
- *        (inside the lock).
- */
-HRESULT Machine::launchVMProcess(IInternalSessionControl *aControl,
-                                 const Utf8Str &strFrontend,
-                                 const Utf8Str &strEnvironment,
-                                 ProgressProxy *aProgress)
-{
-    LogFlowThisFuncEnter();
-
-    AssertReturn(aControl, E_FAIL);
-    AssertReturn(aProgress, E_FAIL);
-    AssertReturn(!strFrontend.isEmpty(), E_FAIL);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mData->mRegistered)
-        return setError(E_UNEXPECTED,
-                        tr("The machine '%s' is not registered"),
-                        mUserData->s.strName.c_str());
-
-    LogFlowThisFunc(("mSession.mState=%s\n", Global::stringifySessionState(mData->mSession.mState)));
-
-    if (    mData->mSession.mState == SessionState_Locked
-         || mData->mSession.mState == SessionState_Spawning
-         || mData->mSession.mState == SessionState_Unlocking)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("The machine '%s' is already locked by a session (or being locked or unlocked)"),
-                        mUserData->s.strName.c_str());
-
-    /* may not be busy */
-    AssertReturn(!Global::IsOnlineOrTransient(mData->mMachineState), E_FAIL);
-
-    /* get the path to the executable */
-    char szPath[RTPATH_MAX];
-    RTPathAppPrivateArch(szPath, sizeof(szPath) - 1);
-    size_t sz = strlen(szPath);
-    szPath[sz++] = RTPATH_DELIMITER;
-    szPath[sz] = 0;
-    char *cmd = szPath + sz;
-    sz = RTPATH_MAX - sz;
-
-    int vrc = VINF_SUCCESS;
-    RTPROCESS pid = NIL_RTPROCESS;
-
-    RTENV env = RTENV_DEFAULT;
-
-    if (!strEnvironment.isEmpty())
-    {
-        char *newEnvStr = NULL;
-
-        do
-        {
-            /* clone the current environment */
-            int vrc2 = RTEnvClone(&env, RTENV_DEFAULT);
-            AssertRCBreakStmt(vrc2, vrc = vrc2);
-
-            newEnvStr = RTStrDup(strEnvironment.c_str());
-            AssertPtrBreakStmt(newEnvStr, vrc = vrc2);
-
-            /* put new variables to the environment
-             * (ignore empty variable names here since RTEnv API
-             * intentionally doesn't do that) */
-            char *var = newEnvStr;
-            for (char *p = newEnvStr; *p; ++p)
-            {
-                if (*p == '\n' && (p == newEnvStr || *(p - 1) != '\\'))
-                {
-                    *p = '\0';
-                    if (*var)
-                    {
-                        char *val = strchr(var, '=');
-                        if (val)
-                        {
-                            *val++ = '\0';
-                            vrc2 = RTEnvSetEx(env, var, val);
-                        }
-                        else
-                            vrc2 = RTEnvUnsetEx(env, var);
-                        if (RT_FAILURE(vrc2))
-                            break;
-                    }
-                    var = p + 1;
-                }
-            }
-            if (RT_SUCCESS(vrc2) && *var)
-                vrc2 = RTEnvPutEx(env, var);
-
-            AssertRCBreakStmt(vrc2, vrc = vrc2);
-        }
-        while (0);
-
-        if (newEnvStr != NULL)
-            RTStrFree(newEnvStr);
-    }
-
-#ifdef VBOX_WITH_QTGUI
-    if (strFrontend == "gui" || strFrontend == "GUI/Qt")
-    {
-# ifdef RT_OS_DARWIN /* Avoid Launch Services confusing this with the selector by using a helper app. */
-        const char VirtualBox_exe[] = "../Resources/VirtualBoxVM.app/Contents/MacOS/VirtualBoxVM";
-# else
-        const char VirtualBox_exe[] = "VirtualBox" HOSTSUFF_EXE;
-# endif
-        Assert(sz >= sizeof(VirtualBox_exe));
-        strcpy(cmd, VirtualBox_exe);
-
-        Utf8Str idStr = mData->mUuid.toString();
-        const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), "--no-startvm-errormsgbox", 0 };
-        vrc = RTProcCreate(szPath, args, env, 0, &pid);
-    }
-#else /* !VBOX_WITH_QTGUI */
-    if (0)
-        ;
-#endif /* VBOX_WITH_QTGUI */
-
-    else
-
-#ifdef VBOX_WITH_VBOXSDL
-    if (strFrontend == "sdl" || strFrontend == "GUI/SDL")
-    {
-        const char VBoxSDL_exe[] = "VBoxSDL" HOSTSUFF_EXE;
-        Assert(sz >= sizeof(VBoxSDL_exe));
-        strcpy(cmd, VBoxSDL_exe);
-
-        Utf8Str idStr = mData->mUuid.toString();
-        const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(), "--startvm", idStr.c_str(), 0 };
-        vrc = RTProcCreate(szPath, args, env, 0, &pid);
-    }
-#else /* !VBOX_WITH_VBOXSDL */
-    if (0)
-        ;
-#endif /* !VBOX_WITH_VBOXSDL */
-
-    else
-
-#ifdef VBOX_WITH_HEADLESS
-    if (   strFrontend == "headless"
-        || strFrontend == "capture"
-        || strFrontend == "vrdp" /* Deprecated. Same as headless. */
-       )
-    {
-        /* On pre-4.0 the "headless" type was used for passing "--vrdp off" to VBoxHeadless to let it work in OSE,
-         * which did not contain VRDP server. In VBox 4.0 the remote desktop server (VRDE) is optional,
-         * and a VM works even if the server has not been installed.
-         * So in 4.0 the "headless" behavior remains the same for default VBox installations.
-         * Only if a VRDE has been installed and the VM enables it, the "headless" will work
-         * differently in 4.0 and 3.x.
-         */
-        const char VBoxHeadless_exe[] = "VBoxHeadless" HOSTSUFF_EXE;
-        Assert(sz >= sizeof(VBoxHeadless_exe));
-        strcpy(cmd, VBoxHeadless_exe);
-
-        Utf8Str idStr = mData->mUuid.toString();
-        /* Leave space for "--capture" arg. */
-        const char * args[] = {szPath, "--comment", mUserData->s.strName.c_str(),
-                                       "--startvm", idStr.c_str(),
-                                       "--vrde", "config",
-                                       0, /* For "--capture". */
-                                       0 };
-        if (strFrontend == "capture")
-        {
-            unsigned pos = RT_ELEMENTS(args) - 2;
-            args[pos] = "--capture";
-        }
-        vrc = RTProcCreate(szPath, args, env,
-#ifdef RT_OS_WINDOWS
-                RTPROC_FLAGS_NO_WINDOW
-#else
-                0
-#endif
-                , &pid);
-    }
-#else /* !VBOX_WITH_HEADLESS */
-    if (0)
-        ;
-#endif /* !VBOX_WITH_HEADLESS */
-    else
-    {
-        RTEnvDestroy(env);
-        return setError(E_INVALIDARG,
-                        tr("Invalid frontend name: '%s'"),
-                        strFrontend.c_str());
-    }
-
-    RTEnvDestroy(env);
-
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_IPRT_ERROR,
-                        tr("Could not launch a process for the machine '%s' (%Rrc)"),
-                        mUserData->s.strName.c_str(), vrc);
-
-    LogFlowThisFunc(("launched.pid=%d(0x%x)\n", pid, pid));
-
-    /*
-     *  Note that we don't release the lock here before calling the client,
-     *  because it doesn't need to call us back if called with a NULL argument.
-     *  Releasing the lock here is dangerous because we didn't prepare the
-     *  launch data yet, but the client we've just started may happen to be
-     *  too fast and call openSession() that will fail (because of PID, etc.),
-     *  so that the Machine will never get out of the Spawning session state.
-     */
-
-    /* inform the session that it will be a remote one */
-    LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
-    HRESULT rc = aControl->AssignMachine(NULL, LockType_Write);
-    LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
-
-    if (FAILED(rc))
-    {
-        /* restore the session state */
-        mData->mSession.mState = SessionState_Unlocked;
-        /* The failure may occur w/o any error info (from RPC), so provide one */
-        return setError(VBOX_E_VM_ERROR,
-                        tr("Failed to assign the machine to the session (%Rrc)"), rc);
-    }
-
-    /* attach launch data to the machine */
-    Assert(mData->mSession.mPID == NIL_RTPROCESS);
-    mData->mSession.mRemoteControls.push_back(aControl);
-    mData->mSession.mProgress = aProgress;
-    mData->mSession.mPID = pid;
-    mData->mSession.mState = SessionState_Spawning;
-    mData->mSession.mType = strFrontend;
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-/**
- * Returns @c true if the given machine has an open direct session and returns
- * the session machine instance and additional session data (on some platforms)
- * if so.
- *
- * Note that when the method returns @c false, the arguments remain unchanged.
- *
- * @param aMachine  Session machine object.
- * @param aControl  Direct session control object (optional).
- * @param aIPCSem   Mutex IPC semaphore handle for this machine (optional).
- *
- * @note locks this object for reading.
- */
+
+Machine::ClientToken::ClientToken()
+{
+    AssertReleaseFailed();
+}
+
+Machine::ClientToken::~ClientToken()
+{
 #if defined(RT_OS_WINDOWS)
-bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                            ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
-                            HANDLE *aIPCSem /*= NULL*/,
-                            bool aAllowClosing /*= false*/)
+    if (mClientToken)
+        ::CloseHandle(mClientToken);
 #elif defined(RT_OS_OS2)
-bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                            ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
-                            HMTX *aIPCSem /*= NULL*/,
-                            bool aAllowClosing /*= false*/)
-#else
-bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                            ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
-                            bool aAllowClosing /*= false*/)
-#endif
-{
-    AutoLimitedCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), false);
-
-    /* just return false for inaccessible machines */
-    if (autoCaller.state() != Ready)
-        return false;
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (    mData->mSession.mState == SessionState_Locked
-         || (aAllowClosing && mData->mSession.mState == SessionState_Unlocking)
-       )
-    {
-        AssertReturn(!mData->mSession.mMachine.isNull(), false);
-
-        aMachine = mData->mSession.mMachine;
-
-        if (aControl != NULL)
-            *aControl = mData->mSession.mDirectControl;
-
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-        /* Additional session data */
-        if (aIPCSem != NULL)
-            *aIPCSem = aMachine->mIPCSem;
-#endif
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Returns @c true if the given machine has an spawning direct session and
- * returns and additional session data (on some platforms) if so.
- *
- * Note that when the method returns @c false, the arguments remain unchanged.
- *
- * @param aPID  PID of the spawned direct session process.
- *
- * @note locks this object for reading.
- */
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-bool Machine::isSessionSpawning(RTPROCESS *aPID /*= NULL*/)
-#else
-bool Machine::isSessionSpawning()
-#endif
-{
-    AutoLimitedCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), false);
-
-    /* just return false for inaccessible machines */
-    if (autoCaller.state() != Ready)
-        return false;
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mData->mSession.mState == SessionState_Spawning)
-    {
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-        /* Additional session data */
-        if (aPID != NULL)
-        {
-            AssertReturn(mData->mSession.mPID != NIL_RTPROCESS, false);
-            *aPID = mData->mSession.mPID;
-        }
-#endif
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Called from the client watcher thread to check for unexpected client process
- * death during Session_Spawning state (e.g. before it successfully opened a
- * direct session).
- *
- * On Win32 and on OS/2, this method is called only when we've got the
- * direct client's process termination notification, so it always returns @c
- * true.
- *
- * On other platforms, this method returns @c true if the client process is
- * terminated and @c false if it's still alive.
- *
- * @note Locks this object for writing.
- */
-bool Machine::checkForSpawnFailure()
-{
-    AutoCaller autoCaller(this);
-    if (!autoCaller.isOk())
-    {
-        /* nothing to do */
-        LogFlowThisFunc(("Already uninitialized!\n"));
-        return true;
-    }
-
-    /* VirtualBox::addProcessToReap() needs a write lock */
-    AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
-
-    if (mData->mSession.mState != SessionState_Spawning)
-    {
-        /* nothing to do */
-        LogFlowThisFunc(("Not spawning any more!\n"));
-        return true;
-    }
-
-    HRESULT rc = S_OK;
-
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-
-    /* the process was already unexpectedly terminated, we just need to set an
-     * error and finalize session spawning */
-    rc = setError(E_FAIL,
-                  tr("The virtual machine '%s' has terminated unexpectedly during startup"),
-                  getName().c_str());
-#else
-
-    /* PID not yet initialized, skip check. */
-    if (mData->mSession.mPID == NIL_RTPROCESS)
-        return false;
-
-    RTPROCSTATUS status;
-    int vrc = ::RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK,
-                           &status);
-
-    if (vrc != VERR_PROCESS_RUNNING)
-    {
-        if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_NORMAL)
-            rc = setError(E_FAIL,
-                          tr("The virtual machine '%s' has terminated unexpectedly during startup with exit code %d"),
-                          getName().c_str(), status.iStatus);
-        else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_SIGNAL)
-            rc = setError(E_FAIL,
-                          tr("The virtual machine '%s' has terminated unexpectedly during startup because of signal %d"),
-                          getName().c_str(), status.iStatus);
-        else if (RT_SUCCESS(vrc) && status.enmReason == RTPROCEXITREASON_ABEND)
-            rc = setError(E_FAIL,
-                          tr("The virtual machine '%s' has terminated abnormally"),
-                          getName().c_str(), status.iStatus);
-        else
-            rc = setError(E_FAIL,
-                          tr("The virtual machine '%s' has terminated unexpectedly during startup (%Rrc)"),
-                          getName().c_str(), rc);
-    }
-
-#endif
-
-    if (FAILED(rc))
-    {
-        /* Close the remote session, remove the remote control from the list
-         * and reset session state to Closed (@note keep the code in sync with
-         * the relevant part in checkForSpawnFailure()). */
-
-        Assert(mData->mSession.mRemoteControls.size() == 1);
-        if (mData->mSession.mRemoteControls.size() == 1)
-        {
-            ErrorInfoKeeper eik;
-            mData->mSession.mRemoteControls.front()->Uninitialize();
-        }
-
-        mData->mSession.mRemoteControls.clear();
-        mData->mSession.mState = SessionState_Unlocked;
-
-        /* finalize the progress after setting the state */
-        if (!mData->mSession.mProgress.isNull())
-        {
-            mData->mSession.mProgress->notifyComplete(rc);
-            mData->mSession.mProgress.setNull();
-        }
-
-        mParent->addProcessToReap(mData->mSession.mPID);
-        mData->mSession.mPID = NIL_RTPROCESS;
-
-        mParent->onSessionStateChange(mData->mUuid, SessionState_Unlocked);
-        return true;
-    }
-
-    return false;
-}
-
-/**
- *  Checks whether the machine can be registered. If so, commits and saves
- *  all settings.
- *
- *  @note Must be called from mParent's write lock. Locks this object and
- *  children for writing.
- */
-HRESULT Machine::prepareRegister()
-{
-    AssertReturn(mParent->isWriteLockOnCurrentThread(), E_FAIL);
-
-    AutoLimitedCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* wait for state dependents to drop to zero */
-    ensureNoStateDependencies();
-
-    if (!mData->mAccessible)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("The machine '%s' with UUID {%s} is inaccessible and cannot be registered"),
-                        mUserData->s.strName.c_str(),
-                        mData->mUuid.toString().c_str());
-
-    AssertReturn(autoCaller.state() == Ready, E_FAIL);
-
-    if (mData->mRegistered)
-        return setError(VBOX_E_INVALID_OBJECT_STATE,
-                        tr("The machine '%s' with UUID {%s} is already registered"),
-                        mUserData->s.strName.c_str(),
-                        mData->mUuid.toString().c_str());
-
-    HRESULT rc = S_OK;
-
-    // Ensure the settings are saved. If we are going to be registered and
-    // no config file exists yet, create it by calling saveSettings() too.
-    if (    (mData->flModifications)
-         || (!mData->pMachineConfigFile->fileExists())
-       )
-    {
-        rc = saveSettings(NULL);
-                // no need to check whether VirtualBox.xml needs saving too since
-                // we can't have a machine XML file rename pending
-        if (FAILED(rc)) return rc;
-    }
-
-    /* more config checking goes here */
-
-    if (SUCCEEDED(rc))
-    {
-        /* we may have had implicit modifications we want to fix on success */
-        commit();
-
-        mData->mRegistered = true;
-    }
-    else
-    {
-        /* we may have had implicit modifications we want to cancel on failure*/
-        rollback(false /* aNotify */);
-    }
-
-    return rc;
-}
-
-/**
- * Increases the number of objects dependent on the machine state or on the
- * registered state. Guarantees that these two states will not change at least
- * until #releaseStateDependency() is called.
- *
- * Depending on the @a aDepType value, additional state checks may be made.
- * These checks will set extended error info on failure. See
- * #checkStateDependency() for more info.
- *
- * If this method returns a failure, the dependency is not added and the caller
- * is not allowed to rely on any particular machine state or registration state
- * value and may return the failed result code to the upper level.
- *
- * @param aDepType      Dependency type to add.
- * @param aState        Current machine state (NULL if not interested).
- * @param aRegistered   Current registered state (NULL if not interested).
- *
- * @note Locks this object for writing.
- */
-HRESULT Machine::addStateDependency(StateDependency aDepType /* = AnyStateDep */,
-                                    MachineState_T *aState /* = NULL */,
-                                    BOOL *aRegistered /* = NULL */)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = checkStateDependency(aDepType);
-    if (FAILED(rc)) return rc;
-
-    {
-        if (mData->mMachineStateChangePending != 0)
-        {
-            /* ensureNoStateDependencies() is waiting for state dependencies to
-             * drop to zero so don't add more. It may make sense to wait a bit
-             * and retry before reporting an error (since the pending state
-             * transition should be really quick) but let's just assert for
-             * now to see if it ever happens on practice. */
-
-            AssertFailed();
-
-            return setError(E_ACCESSDENIED,
-                            tr("Machine state change is in progress. Please retry the operation later."));
-        }
-
-        ++mData->mMachineStateDeps;
-        Assert(mData->mMachineStateDeps != 0 /* overflow */);
-    }
-
-    if (aState)
-        *aState = mData->mMachineState;
-    if (aRegistered)
-        *aRegistered = mData->mRegistered;
-
-    return S_OK;
-}
-
-/**
- * Decreases the number of objects dependent on the machine state.
- * Must always complete the #addStateDependency() call after the state
- * dependency is no more necessary.
- */
-void Machine::releaseStateDependency()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* releaseStateDependency() w/o addStateDependency()? */
-    AssertReturnVoid(mData->mMachineStateDeps != 0);
-    -- mData->mMachineStateDeps;
-
-    if (mData->mMachineStateDeps == 0)
-    {
-        /* inform ensureNoStateDependencies() that there are no more deps */
-        if (mData->mMachineStateChangePending != 0)
-        {
-            Assert(mData->mMachineStateDepsSem != NIL_RTSEMEVENTMULTI);
-            RTSemEventMultiSignal (mData->mMachineStateDepsSem);
-        }
-    }
-}
-
-Utf8Str Machine::getExtraData(const Utf8Str &strKey)
-{
-    /* start with nothing found */
-    Utf8Str strResult("");
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    settings::StringsMap::const_iterator it = mData->pMachineConfigFile->mapExtraDataItems.find(strKey);
-    if (it != mData->pMachineConfigFile->mapExtraDataItems.end())
-        // found:
-        strResult = it->second; // source is a Utf8Str
-
-    return strResult;
-}
-
-// protected methods
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Performs machine state checks based on the @a aDepType value. If a check
- *  fails, this method will set extended error info, otherwise it will return
- *  S_OK. It is supposed, that on failure, the caller will immediately return
- *  the return value of this method to the upper level.
- *
- *  When @a aDepType is AnyStateDep, this method always returns S_OK.
- *
- *  When @a aDepType is MutableStateDep, this method returns S_OK only if the
- *  current state of this machine object allows to change settings of the
- *  machine (i.e. the machine is not registered, or registered but not running
- *  and not saved). It is useful to call this method from Machine setters
- *  before performing any change.
- *
- *  When @a aDepType is MutableOrSavedStateDep, this method behaves the same
- *  as for MutableStateDep except that if the machine is saved, S_OK is also
- *  returned. This is useful in setters which allow changing machine
- *  properties when it is in the saved state.
- *
- *  When @a aDepType is OfflineStateDep, this method returns S_OK if the
- *  state is one of the 4 offline states (PoweredOff, Saved, Teleported,
- *  Aborted).
- *
- *  @param aDepType     Dependency type to check.
- *
- *  @note Non Machine based classes should use #addStateDependency() and
- *  #releaseStateDependency() methods or the smart AutoStateDependency
- *  template.
- *
- *  @note This method must be called from under this object's read or write
- *        lock.
- */
-HRESULT Machine::checkStateDependency(StateDependency aDepType)
-{
-    switch (aDepType)
-    {
-        case AnyStateDep:
-        {
-            break;
-        }
-        case MutableStateDep:
-        {
-            if (   mData->mRegistered
-                && (   !isSessionMachine()  /** @todo This was just converted raw; Check if Running and Paused should actually be included here... (Live Migration) */
-                    || (   mData->mMachineState != MachineState_Paused
-                        && mData->mMachineState != MachineState_Running
-                        && mData->mMachineState != MachineState_Aborted
-                        && mData->mMachineState != MachineState_Teleported
-                        && mData->mMachineState != MachineState_PoweredOff
-                       )
-                   )
-               )
-                return setError(VBOX_E_INVALID_VM_STATE,
-                                tr("The machine is not mutable (state is %s)"),
-                                Global::stringifyMachineState(mData->mMachineState));
-            break;
-        }
-        case MutableOrSavedStateDep:
-        {
-            if (   mData->mRegistered
-                && (   !isSessionMachine() /** @todo This was just converted raw; Check if Running and Paused should actually be included here... (Live Migration) */
-                    || (   mData->mMachineState != MachineState_Paused
-                        && mData->mMachineState != MachineState_Running
-                        && mData->mMachineState != MachineState_Aborted
-                        && mData->mMachineState != MachineState_Teleported
-                        && mData->mMachineState != MachineState_Saved
-                        && mData->mMachineState != MachineState_PoweredOff
-                       )
-                   )
-               )
-                return setError(VBOX_E_INVALID_VM_STATE,
-                                tr("The machine is not mutable (state is %s)"),
-                                Global::stringifyMachineState(mData->mMachineState));
-            break;
-        }
-        case OfflineStateDep:
-        {
-            if (   mData->mRegistered
-                && (   !isSessionMachine()
-                    || (   mData->mMachineState != MachineState_PoweredOff
-                        && mData->mMachineState != MachineState_Saved
-                        && mData->mMachineState != MachineState_Aborted
-                        && mData->mMachineState != MachineState_Teleported
-                       )
-                   )
-               )
-                return setError(VBOX_E_INVALID_VM_STATE,
-                                tr("The machine is not offline (state is %s)"),
-                                Global::stringifyMachineState(mData->mMachineState));
-            break;
-        }
-    }
-
-    return S_OK;
-}
-
-/**
- * Helper to initialize all associated child objects and allocate data
- * structures.
- *
- * This method must be called as a part of the object's initialization procedure
- * (usually done in the #init() method).
- *
- * @note Must be called only from #init() or from #registeredInit().
- */
-HRESULT Machine::initDataAndChildObjects()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-    AssertComRCReturn(autoCaller.state() == InInit ||
-                      autoCaller.state() == Limited, E_FAIL);
-
-    AssertReturn(!mData->mAccessible, E_FAIL);
-
-    /* allocate data structures */
-    mSSData.allocate();
-    mUserData.allocate();
-    mHWData.allocate();
-    mMediaData.allocate();
-    mStorageControllers.allocate();
-    mUSBControllers.allocate();
-
-    /* initialize mOSTypeId */
-    mUserData->s.strOsType = mParent->getUnknownOSType()->id();
-
-    /* create associated BIOS settings object */
-    unconst(mBIOSSettings).createObject();
-    mBIOSSettings->init(this);
-
-    /* create an associated VRDE object (default is disabled) */
-    unconst(mVRDEServer).createObject();
-    mVRDEServer->init(this);
-
-    /* create associated serial port objects */
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
-    {
-        unconst(mSerialPorts[slot]).createObject();
-        mSerialPorts[slot]->init(this, slot);
-    }
-
-    /* create associated parallel port objects */
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-    {
-        unconst(mParallelPorts[slot]).createObject();
-        mParallelPorts[slot]->init(this, slot);
-    }
-
-    /* create the audio adapter object (always present, default is disabled) */
-    unconst(mAudioAdapter).createObject();
-    mAudioAdapter->init(this);
-
-    /* create the USB device filters object (always present) */
-    unconst(mUSBDeviceFilters).createObject();
-    mUSBDeviceFilters->init(this);
-
-    /* create associated network adapter objects */
-    mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
-    for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
-    {
-        unconst(mNetworkAdapters[slot]).createObject();
-        mNetworkAdapters[slot]->init(this, slot);
-    }
-
-    /* create the bandwidth control */
-    unconst(mBandwidthControl).createObject();
-    mBandwidthControl->init(this);
-
-    return S_OK;
-}
-
-/**
- * Helper to uninitialize all associated child objects and to free all data
- * structures.
- *
- * This method must be called as a part of the object's uninitialization
- * procedure (usually done in the #uninit() method).
- *
- * @note Must be called only from #uninit() or from #registeredInit().
- */
-void Machine::uninitDataAndChildObjects()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-    AssertComRCReturnVoid(    autoCaller.state() == InUninit
-                           || autoCaller.state() == Limited);
-
-    /* tell all our other child objects we've been uninitialized */
-    if (mBandwidthControl)
-    {
-        mBandwidthControl->uninit();
-        unconst(mBandwidthControl).setNull();
-    }
-
-    for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
-    {
-        if (mNetworkAdapters[slot])
-        {
-            mNetworkAdapters[slot]->uninit();
-            unconst(mNetworkAdapters[slot]).setNull();
-        }
-    }
-
-    if (mUSBDeviceFilters)
-    {
-        mUSBDeviceFilters->uninit();
-        unconst(mUSBDeviceFilters).setNull();
-    }
-
-    if (mAudioAdapter)
-    {
-        mAudioAdapter->uninit();
-        unconst(mAudioAdapter).setNull();
-    }
-
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-    {
-        if (mParallelPorts[slot])
-        {
-            mParallelPorts[slot]->uninit();
-            unconst(mParallelPorts[slot]).setNull();
-        }
-    }
-
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
-    {
-        if (mSerialPorts[slot])
-        {
-            mSerialPorts[slot]->uninit();
-            unconst(mSerialPorts[slot]).setNull();
-        }
-    }
-
-    if (mVRDEServer)
-    {
-        mVRDEServer->uninit();
-        unconst(mVRDEServer).setNull();
-    }
-
-    if (mBIOSSettings)
-    {
-        mBIOSSettings->uninit();
-        unconst(mBIOSSettings).setNull();
-    }
-
-    /* Deassociate media (only when a real Machine or a SnapshotMachine
-     * instance is uninitialized; SessionMachine instances refer to real
-     * Machine media). This is necessary for a clean re-initialization of
-     * the VM after successfully re-checking the accessibility state. Note
-     * that in case of normal Machine or SnapshotMachine uninitialization (as
-     * a result of unregistering or deleting the snapshot), outdated media
-     * attachments will already be uninitialized and deleted, so this
-     * code will not affect them. */
-    if (    !!mMediaData
-         && (!isSessionMachine())
-       )
-    {
-        for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-             it != mMediaData->mAttachments.end();
-             ++it)
-        {
-            ComObjPtr<Medium> pMedium = (*it)->getMedium();
-            if (pMedium.isNull())
-                continue;
-            HRESULT rc = pMedium->removeBackReference(mData->mUuid, getSnapshotId());
-            AssertComRC(rc);
-        }
-    }
-
-    if (!isSessionMachine() && !isSnapshotMachine())
-    {
-        // clean up the snapshots list (Snapshot::uninit() will handle the snapshot's children recursively)
-        if (mData->mFirstSnapshot)
-        {
-            // snapshots tree is protected by machine write lock; strictly
-            // this isn't necessary here since we're deleting the entire
-            // machine, but otherwise we assert in Snapshot::uninit()
-            AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-            mData->mFirstSnapshot->uninit();
-            mData->mFirstSnapshot.setNull();
-        }
-
-        mData->mCurrentSnapshot.setNull();
-    }
-
-    /* free data structures (the essential mData structure is not freed here
-     * since it may be still in use) */
-    mMediaData.free();
-    mStorageControllers.free();
-    mUSBControllers.free();
-    mHWData.free();
-    mUserData.free();
-    mSSData.free();
-}
-
-/**
- *  Returns a pointer to the Machine object for this machine that acts like a
- *  parent for complex machine data objects such as shared folders, etc.
- *
- *  For primary Machine objects and for SnapshotMachine objects, returns this
- *  object's pointer itself. For SessionMachine objects, returns the peer
- *  (primary) machine pointer.
- */
-Machine* Machine::getMachine()
-{
-    if (isSessionMachine())
-        return (Machine*)mPeer;
-    return this;
-}
-
-/**
- * Makes sure that there are no machine state dependents. If necessary, waits
- * for the number of dependents to drop to zero.
- *
- * Make sure this method is called from under this object's write lock to
- * guarantee that no new dependents may be added when this method returns
- * control to the caller.
- *
- * @note Locks this object for writing. The lock will be released while waiting
- *       (if necessary).
- *
- * @warning To be used only in methods that change the machine state!
- */
-void Machine::ensureNoStateDependencies()
-{
-    AssertReturnVoid(isWriteLockOnCurrentThread());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* Wait for all state dependents if necessary */
-    if (mData->mMachineStateDeps != 0)
-    {
-        /* lazy semaphore creation */
-        if (mData->mMachineStateDepsSem == NIL_RTSEMEVENTMULTI)
-            RTSemEventMultiCreate(&mData->mMachineStateDepsSem);
-
-        LogFlowThisFunc(("Waiting for state deps (%d) to drop to zero...\n",
-                          mData->mMachineStateDeps));
-
-        ++mData->mMachineStateChangePending;
-
-        /* reset the semaphore before waiting, the last dependent will signal
-         * it */
-        RTSemEventMultiReset(mData->mMachineStateDepsSem);
-
-        alock.release();
-
-        RTSemEventMultiWait(mData->mMachineStateDepsSem, RT_INDEFINITE_WAIT);
-
-        alock.acquire();
-
-        -- mData->mMachineStateChangePending;
-    }
-}
-
-/**
- * Changes the machine state and informs callbacks.
- *
- * This method is not intended to fail so it either returns S_OK or asserts (and
- * returns a failure).
- *
- * @note Locks this object for writing.
- */
-HRESULT Machine::setMachineState(MachineState_T aMachineState)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* wait for state dependents to drop to zero */
-    ensureNoStateDependencies();
-
-    if (mData->mMachineState != aMachineState)
-    {
-        mData->mMachineState = aMachineState;
-
-        RTTimeNow(&mData->mLastStateChange);
-
-        mParent->onMachineStateChange(mData->mUuid, aMachineState);
-    }
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-/**
- *  Searches for a shared folder with the given logical name
- *  in the collection of shared folders.
- *
- *  @param aName            logical name of the shared folder
- *  @param aSharedFolder    where to return the found object
- *  @param aSetError        whether to set the error info if the folder is
- *                          not found
- *  @return
- *      S_OK when found or VBOX_E_OBJECT_NOT_FOUND when not found
- *
- *  @note
- *      must be called from under the object's lock!
- */
-HRESULT Machine::findSharedFolder(const Utf8Str &aName,
-                                  ComObjPtr<SharedFolder> &aSharedFolder,
-                                  bool aSetError /* = false */)
-{
-    HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
-    for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
-        it != mHWData->mSharedFolders.end();
-        ++it)
-    {
-        SharedFolder *pSF = *it;
-        AutoCaller autoCaller(pSF);
-        if (pSF->getName() == aName)
-        {
-            aSharedFolder = pSF;
-            rc = S_OK;
-            break;
-        }
-    }
-
-    if (aSetError && FAILED(rc))
-        setError(rc, tr("Could not find a shared folder named '%s'"), aName.c_str());
-
-    return rc;
-}
-
-/**
- * Initializes all machine instance data from the given settings structures
- * from XML. The exception is the machine UUID which needs special handling
- * depending on the caller's use case, so the caller needs to set that herself.
- *
- * This gets called in several contexts during machine initialization:
- *
- * -- When machine XML exists on disk already and needs to be loaded into memory,
- *    for example, from registeredInit() to load all registered machines on
- *    VirtualBox startup. In this case, puuidRegistry is NULL because the media
- *    attached to the machine should be part of some media registry already.
- *
- * -- During OVF import, when a machine config has been constructed from an
- *    OVF file. In this case, puuidRegistry is set to the machine UUID to
- *    ensure that the media listed as attachments in the config (which have
- *    been imported from the OVF) receive the correct registry ID.
- *
- * -- During VM cloning.
- *
- * @param config Machine settings from XML.
- * @param puuidRegistry If != NULL, Medium::setRegistryIdIfFirst() gets called with this registry ID for each attached medium in the config.
- * @return
- */
-HRESULT Machine::loadMachineDataFromSettings(const settings::MachineConfigFile &config,
-                                             const Guid *puuidRegistry)
-{
-    // copy name, description, OS type, teleporter, UTC etc.
-    #define DECODE_STR_MAX _1M
-    mUserData->s = config.machineUserData;
-
-    // Decode the Icon overide data from config userdata and set onto Machine.
-    const char* pszStr = config.machineUserData.ovIcon.c_str();
-    ssize_t cbOut = RTBase64DecodedSize(pszStr, NULL);
-    if (cbOut > DECODE_STR_MAX)
-        return setError(E_FAIL,
-                        tr("Icon Data too long.'%d' > '%d'"),
-                        cbOut,
-                        DECODE_STR_MAX);
-    com::SafeArray<BYTE> iconByte(cbOut);
-    HRESULT rc = RTBase64Decode(pszStr, iconByte.raw(), cbOut, NULL, NULL);
-    if (FAILED(rc))
-        return setError(E_FAIL,
-                        tr("Failure to Decode Icon Data. '%s' (%d)"),
-                        pszStr,
-                        rc);
-    COMSETTER(Icon)(ComSafeArrayAsInParam(iconByte));
-
-    // look up the object by Id to check it is valid
-    ComPtr<IGuestOSType> guestOSType;
-    rc = mParent->GetGuestOSType(Bstr(mUserData->s.strOsType).raw(),
-                                         guestOSType.asOutParam());
-    if (FAILED(rc)) return rc;
-
-    // stateFile (optional)
-    if (config.strStateFile.isEmpty())
-        mSSData->strStateFilePath.setNull();
-    else
-    {
-        Utf8Str stateFilePathFull(config.strStateFile);
-        int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
-        if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Invalid saved state file path '%s' (%Rrc)"),
-                            config.strStateFile.c_str(),
-                            vrc);
-        mSSData->strStateFilePath = stateFilePathFull;
-    }
-
-    // snapshot folder needs special processing so set it again
-    rc = COMSETTER(SnapshotFolder)(Bstr(config.machineUserData.strSnapshotFolder).raw());
-    if (FAILED(rc)) return rc;
-
-    /* Copy the extra data items (Not in any case config is already the same as
-     * mData->pMachineConfigFile, like when the xml files are read from disk. So
-     * make sure the extra data map is copied). */
-    mData->pMachineConfigFile->mapExtraDataItems = config.mapExtraDataItems;
-
-    /* currentStateModified (optional, default is true) */
-    mData->mCurrentStateModified = config.fCurrentStateModified;
-
-    mData->mLastStateChange = config.timeLastStateChange;
-
-    /*
-     *  note: all mUserData members must be assigned prior this point because
-     *  we need to commit changes in order to let mUserData be shared by all
-     *  snapshot machine instances.
-     */
-    mUserData.commitCopy();
-
-    // machine registry, if present (must be loaded before snapshots)
-    if (config.canHaveOwnMediaRegistry())
-    {
-        // determine machine folder
-        Utf8Str strMachineFolder = getSettingsFileFull();
-        strMachineFolder.stripFilename();
-        rc = mParent->initMedia(getId(),         // media registry ID == machine UUID
-                                config.mediaRegistry,
-                                strMachineFolder);
-        if (FAILED(rc)) return rc;
-    }
-
-    /* Snapshot node (optional) */
-    size_t cRootSnapshots;
-    if ((cRootSnapshots = config.llFirstSnapshot.size()))
-    {
-        // there must be only one root snapshot
-        Assert(cRootSnapshots == 1);
-
-        const settings::Snapshot &snap = config.llFirstSnapshot.front();
-
-        rc = loadSnapshot(snap,
-                          config.uuidCurrentSnapshot,
-                          NULL);        // no parent == first snapshot
-        if (FAILED(rc)) return rc;
-    }
-
-    // hardware data
-    rc = loadHardware(config.hardwareMachine, &config.debugging, &config.autostart);
-    if (FAILED(rc)) return rc;
-
-    // load storage controllers
-    rc = loadStorageControllers(config.storageMachine,
-                                puuidRegistry,
-                                NULL /* puuidSnapshot */);
-    if (FAILED(rc)) return rc;
-
-    /*
-     *  NOTE: the assignment below must be the last thing to do,
-     *  otherwise it will be not possible to change the settings
-     *  somewhere in the code above because all setters will be
-     *  blocked by checkStateDependency(MutableStateDep).
-     */
-
-    /* set the machine state to Aborted or Saved when appropriate */
-    if (config.fAborted)
-    {
-        mSSData->strStateFilePath.setNull();
-
-        /* no need to use setMachineState() during init() */
-        mData->mMachineState = MachineState_Aborted;
-    }
-    else if (!mSSData->strStateFilePath.isEmpty())
-    {
-        /* no need to use setMachineState() during init() */
-        mData->mMachineState = MachineState_Saved;
-    }
-
-    // after loading settings, we are no longer different from the XML on disk
-    mData->flModifications = 0;
-
-    return S_OK;
-}
-
-/**
- *  Recursively loads all snapshots starting from the given.
- *
- *  @param aNode            <Snapshot> node.
- *  @param aCurSnapshotId   Current snapshot ID from the settings file.
- *  @param aParentSnapshot  Parent snapshot.
- */
-HRESULT Machine::loadSnapshot(const settings::Snapshot &data,
-                              const Guid &aCurSnapshotId,
-                              Snapshot *aParentSnapshot)
-{
-    AssertReturn(!isSnapshotMachine(), E_FAIL);
-    AssertReturn(!isSessionMachine(), E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    Utf8Str strStateFile;
-    if (!data.strStateFile.isEmpty())
-    {
-        /* optional */
-        strStateFile = data.strStateFile;
-        int vrc = calculateFullPath(strStateFile, strStateFile);
-        if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Invalid saved state file path '%s' (%Rrc)"),
-                            strStateFile.c_str(),
-                            vrc);
-    }
-
-    /* create a snapshot machine object */
-    ComObjPtr<SnapshotMachine> pSnapshotMachine;
-    pSnapshotMachine.createObject();
-    rc = pSnapshotMachine->initFromSettings(this,
-                                            data.hardware,
-                                            &data.debugging,
-                                            &data.autostart,
-                                            data.storage,
-                                            data.uuid.ref(),
-                                            strStateFile);
-    if (FAILED(rc)) return rc;
-
-    /* create a snapshot object */
-    ComObjPtr<Snapshot> pSnapshot;
-    pSnapshot.createObject();
-    /* initialize the snapshot */
-    rc = pSnapshot->init(mParent, // VirtualBox object
-                         data.uuid,
-                         data.strName,
-                         data.strDescription,
-                         data.timestamp,
-                         pSnapshotMachine,
-                         aParentSnapshot);
-    if (FAILED(rc)) return rc;
-
-    /* memorize the first snapshot if necessary */
-    if (!mData->mFirstSnapshot)
-        mData->mFirstSnapshot = pSnapshot;
-
-    /* memorize the current snapshot when appropriate */
-    if (    !mData->mCurrentSnapshot
-         && pSnapshot->getId() == aCurSnapshotId
-       )
-        mData->mCurrentSnapshot = pSnapshot;
-
-    // now create the children
-    for (settings::SnapshotsList::const_iterator it = data.llChildSnapshots.begin();
-         it != data.llChildSnapshots.end();
-         ++it)
-    {
-        const settings::Snapshot &childData = *it;
-        // recurse
-        rc = loadSnapshot(childData,
-                          aCurSnapshotId,
-                          pSnapshot);       // parent = the one we created above
-        if (FAILED(rc)) return rc;
-    }
-
-    return rc;
-}
-
-/**
- *  Loads settings into mHWData.
- *
- *  @param data           Reference to the hardware settings.
- *  @param pDbg           Pointer to the debugging settings.
- *  @param pAutostart     Pointer to the autostart settings.
- */
-HRESULT Machine::loadHardware(const settings::Hardware &data, const settings::Debugging *pDbg,
-                              const settings::Autostart *pAutostart)
-{
-    AssertReturn(!isSessionMachine(), E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    try
-    {
-        /* The hardware version attribute (optional). */
-        mHWData->mHWVersion = data.strVersion;
-        mHWData->mHardwareUUID = data.uuid;
-
-        mHWData->mHWVirtExEnabled             = data.fHardwareVirt;
-        mHWData->mHWVirtExExclusive           = data.fHardwareVirtExclusive;
-        mHWData->mHWVirtExNestedPagingEnabled = data.fNestedPaging;
-        mHWData->mHWVirtExLargePagesEnabled   = data.fLargePages;
-        mHWData->mHWVirtExVPIDEnabled         = data.fVPID;
-        mHWData->mHWVirtExUXEnabled           = data.fUnrestrictedExecution;
-        mHWData->mHWVirtExForceEnabled        = data.fHardwareVirtForce;
-        mHWData->mPAEEnabled                  = data.fPAE;
-        mHWData->mSyntheticCpu                = data.fSyntheticCpu;
-        mHWData->mLongMode                    = data.enmLongMode;
-        mHWData->mCPUCount                    = data.cCPUs;
-        mHWData->mCPUHotPlugEnabled           = data.fCpuHotPlug;
-        mHWData->mCpuExecutionCap             = data.ulCpuExecutionCap;
-
-        // cpu
-        if (mHWData->mCPUHotPlugEnabled)
-        {
-            for (settings::CpuList::const_iterator it = data.llCpus.begin();
-                it != data.llCpus.end();
-                ++it)
-            {
-                const settings::Cpu &cpu = *it;
-
-                mHWData->mCPUAttached[cpu.ulId] = true;
-            }
-        }
-
-        // cpuid leafs
-        for (settings::CpuIdLeafsList::const_iterator it = data.llCpuIdLeafs.begin();
-            it != data.llCpuIdLeafs.end();
-            ++it)
-        {
-            const settings::CpuIdLeaf &leaf = *it;
-
-            switch (leaf.ulId)
-            {
-            case 0x0:
-            case 0x1:
-            case 0x2:
-            case 0x3:
-            case 0x4:
-            case 0x5:
-            case 0x6:
-            case 0x7:
-            case 0x8:
-            case 0x9:
-            case 0xA:
-                mHWData->mCpuIdStdLeafs[leaf.ulId] = leaf;
-                break;
-
-            case 0x80000000:
-            case 0x80000001:
-            case 0x80000002:
-            case 0x80000003:
-            case 0x80000004:
-            case 0x80000005:
-            case 0x80000006:
-            case 0x80000007:
-            case 0x80000008:
-            case 0x80000009:
-            case 0x8000000A:
-                mHWData->mCpuIdExtLeafs[leaf.ulId - 0x80000000] = leaf;
-                break;
-
-            default:
-                /* just ignore */
-                break;
-            }
-        }
-
-        mHWData->mMemorySize = data.ulMemorySizeMB;
-        mHWData->mPageFusionEnabled = data.fPageFusionEnabled;
-
-        // boot order
-        for (size_t i = 0;
-             i < RT_ELEMENTS(mHWData->mBootOrder);
-             i++)
-        {
-            settings::BootOrderMap::const_iterator it = data.mapBootOrder.find(i);
-            if (it == data.mapBootOrder.end())
-                mHWData->mBootOrder[i] = DeviceType_Null;
-            else
-                mHWData->mBootOrder[i] = it->second;
-        }
-
-        mHWData->mGraphicsControllerType = data.graphicsControllerType;
-        mHWData->mVRAMSize      = data.ulVRAMSizeMB;
-        mHWData->mMonitorCount  = data.cMonitors;
-        mHWData->mAccelerate3DEnabled = data.fAccelerate3D;
-        mHWData->mAccelerate2DVideoEnabled = data.fAccelerate2DVideo;
-        mHWData->mVideoCaptureWidth = data.ulVideoCaptureHorzRes;
-        mHWData->mVideoCaptureHeight = data.ulVideoCaptureVertRes;
-        mHWData->mVideoCaptureEnabled = data.fVideoCaptureEnabled;
-        for (unsigned i = 0; i < RT_ELEMENTS(mHWData->maVideoCaptureScreens); i++)
-            mHWData->maVideoCaptureScreens[i] = ASMBitTest(&data.u64VideoCaptureScreens, i);
-        AssertCompile(RT_ELEMENTS(mHWData->maVideoCaptureScreens) == sizeof(data.u64VideoCaptureScreens) * 8);
-        mHWData->mVideoCaptureRate = data.ulVideoCaptureRate;
-        mHWData->mVideoCaptureFPS = data.ulVideoCaptureFPS;
-        if (!data.strVideoCaptureFile.isEmpty())
-            calculateFullPath(data.strVideoCaptureFile, mHWData->mVideoCaptureFile);
-        else
-            mHWData->mVideoCaptureFile.setNull();
-        mHWData->mFirmwareType = data.firmwareType;
-        mHWData->mPointingHIDType = data.pointingHIDType;
-        mHWData->mKeyboardHIDType = data.keyboardHIDType;
-        mHWData->mChipsetType = data.chipsetType;
-        mHWData->mEmulatedUSBWebcamEnabled = data.fEmulatedUSBWebcam;
-        mHWData->mEmulatedUSBCardReaderEnabled = data.fEmulatedUSBCardReader;
-        mHWData->mHPETEnabled = data.fHPETEnabled;
-
-        /* VRDEServer */
-        rc = mVRDEServer->loadSettings(data.vrdeSettings);
-        if (FAILED(rc)) return rc;
-
-        /* BIOS */
-        rc = mBIOSSettings->loadSettings(data.biosSettings);
-        if (FAILED(rc)) return rc;
-
-        // Bandwidth control (must come before network adapters)
-        rc = mBandwidthControl->loadSettings(data.ioSettings);
-        if (FAILED(rc)) return rc;
-
-        /* Shared folders */
-        for (settings::USBControllerList::const_iterator it = data.usbSettings.llUSBControllers.begin();
-             it != data.usbSettings.llUSBControllers.end();
-             ++it)
-        {
-            const settings::USBController &settingsCtrl = *it;
-            ComObjPtr<USBController> newCtrl;
-
-            newCtrl.createObject();
-            newCtrl->init(this, settingsCtrl.strName, settingsCtrl.enmType);
-            mUSBControllers->push_back(newCtrl);
-        }
-
-        /* USB device filters */
-        rc = mUSBDeviceFilters->loadSettings(data.usbSettings);
-        if (FAILED(rc)) return rc;
-
-        // network adapters
-        uint32_t newCount = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
-        uint32_t oldCount = mNetworkAdapters.size();
-        if (newCount > oldCount)
-        {
-            mNetworkAdapters.resize(newCount);
-            for (ULONG slot = oldCount; slot < mNetworkAdapters.size(); slot++)
-            {
-                unconst(mNetworkAdapters[slot]).createObject();
-                mNetworkAdapters[slot]->init(this, slot);
-            }
-        }
-        else if (newCount < oldCount)
-            mNetworkAdapters.resize(newCount);
-        for (settings::NetworkAdaptersList::const_iterator it = data.llNetworkAdapters.begin();
-            it != data.llNetworkAdapters.end();
-            ++it)
-        {
-            const settings::NetworkAdapter &nic = *it;
-
-            /* slot unicity is guaranteed by XML Schema */
-            AssertBreak(nic.ulSlot < mNetworkAdapters.size());
-            rc = mNetworkAdapters[nic.ulSlot]->loadSettings(mBandwidthControl, nic);
-            if (FAILED(rc)) return rc;
-        }
-
-        // serial ports
-        for (settings::SerialPortsList::const_iterator it = data.llSerialPorts.begin();
-            it != data.llSerialPorts.end();
-            ++it)
-        {
-            const settings::SerialPort &s = *it;
-
-            AssertBreak(s.ulSlot < RT_ELEMENTS(mSerialPorts));
-            rc = mSerialPorts[s.ulSlot]->loadSettings(s);
-            if (FAILED(rc)) return rc;
-        }
-
-        // parallel ports (optional)
-        for (settings::ParallelPortsList::const_iterator it = data.llParallelPorts.begin();
-            it != data.llParallelPorts.end();
-            ++it)
-        {
-            const settings::ParallelPort &p = *it;
-
-            AssertBreak(p.ulSlot < RT_ELEMENTS(mParallelPorts));
-            rc = mParallelPorts[p.ulSlot]->loadSettings(p);
-            if (FAILED(rc)) return rc;
-        }
-
-        /* AudioAdapter */
-        rc = mAudioAdapter->loadSettings(data.audioAdapter);
-        if (FAILED(rc)) return rc;
-
-        /* Shared folders */
-        for (settings::SharedFoldersList::const_iterator it = data.llSharedFolders.begin();
-             it != data.llSharedFolders.end();
-             ++it)
-        {
-            const settings::SharedFolder &sf = *it;
-
-            ComObjPtr<SharedFolder> sharedFolder;
-            /* Check for double entries. Not allowed! */
-            rc = findSharedFolder(sf.strName, sharedFolder, false /* aSetError */);
-            if (SUCCEEDED(rc))
-                return setError(VBOX_E_OBJECT_IN_USE,
-                                tr("Shared folder named '%s' already exists"),
-                                sf.strName.c_str());
-
-            /* Create the new shared folder. Don't break on error. This will be
-             * reported when the machine starts. */
-            sharedFolder.createObject();
-            rc = sharedFolder->init(getMachine(),
-                                    sf.strName,
-                                    sf.strHostPath,
-                                    RT_BOOL(sf.fWritable),
-                                    RT_BOOL(sf.fAutoMount),
-                                    false /* fFailOnError */);
-            if (FAILED(rc)) return rc;
-            mHWData->mSharedFolders.push_back(sharedFolder);
-        }
-
-        // Clipboard
-        mHWData->mClipboardMode = data.clipboardMode;
-
-        // drag'n'drop
-        mHWData->mDragAndDropMode = data.dragAndDropMode;
-
-        // guest settings
-        mHWData->mMemoryBalloonSize = data.ulMemoryBalloonSize;
-
-        // IO settings
-        mHWData->mIOCacheEnabled = data.ioSettings.fIOCacheEnabled;
-        mHWData->mIOCacheSize = data.ioSettings.ulIOCacheSize;
-
-        // Host PCI devices
-        for (settings::HostPCIDeviceAttachmentList::const_iterator it = data.pciAttachments.begin();
-             it != data.pciAttachments.end();
-             ++it)
-        {
-            const settings::HostPCIDeviceAttachment &hpda = *it;
-            ComObjPtr<PCIDeviceAttachment> pda;
-
-            pda.createObject();
-            pda->loadSettings(this, hpda);
-            mHWData->mPCIDeviceAssignments.push_back(pda);
-        }
-
-        /*
-         * (The following isn't really real hardware, but it lives in HWData
-         * for reasons of convenience.)
-         */
-
-#ifdef VBOX_WITH_GUEST_PROPS
-        /* Guest properties (optional) */
-        for (settings::GuestPropertiesList::const_iterator it = data.llGuestProperties.begin();
-            it != data.llGuestProperties.end();
-            ++it)
-        {
-            const settings::GuestProperty &prop = *it;
-            uint32_t fFlags = guestProp::NILFLAG;
-            guestProp::validateFlags(prop.strFlags.c_str(), &fFlags);
-            HWData::GuestProperty property = { prop.strValue, (LONG64) prop.timestamp, fFlags };
-            mHWData->mGuestProperties[prop.strName] = property;
-        }
-
-        mHWData->mGuestPropertyNotificationPatterns = data.strNotificationPatterns;
-#endif /* VBOX_WITH_GUEST_PROPS defined */
-
-        rc = loadDebugging(pDbg);
-        if (FAILED(rc))
-            return rc;
-
-        mHWData->mAutostart = *pAutostart;
-
-        /* default frontend */
-        mHWData->mDefaultFrontend = data.strDefaultFrontend;
-    }
-    catch(std::bad_alloc &)
-    {
-        return E_OUTOFMEMORY;
-    }
-
-    AssertComRC(rc);
-    return rc;
-}
-
-/**
- * Called from Machine::loadHardware() to load the debugging settings of the
- * machine.
- *
- * @param   pDbg        Pointer to the settings.
- */
-HRESULT Machine::loadDebugging(const settings::Debugging *pDbg)
-{
-    mHWData->mDebugging = *pDbg;
-    /* no more processing currently required, this will probably change. */
-    return S_OK;
-}
-
-/**
- *  Called from loadMachineDataFromSettings() for the storage controller data, including media.
- *
- * @param data
- * @param puuidRegistry media registry ID to set media to or NULL; see Machine::loadMachineDataFromSettings()
- * @param puuidSnapshot
- * @return
- */
-HRESULT Machine::loadStorageControllers(const settings::Storage &data,
-                                        const Guid *puuidRegistry,
-                                        const Guid *puuidSnapshot)
-{
-    AssertReturn(!isSessionMachine(), E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    for (settings::StorageControllersList::const_iterator it = data.llStorageControllers.begin();
-         it != data.llStorageControllers.end();
-         ++it)
-    {
-        const settings::StorageController &ctlData = *it;
-
-        ComObjPtr<StorageController> pCtl;
-        /* Try to find one with the name first. */
-        rc = getStorageControllerByName(ctlData.strName, pCtl, false /* aSetError */);
-        if (SUCCEEDED(rc))
-            return setError(VBOX_E_OBJECT_IN_USE,
-                            tr("Storage controller named '%s' already exists"),
-                            ctlData.strName.c_str());
-
-        pCtl.createObject();
-        rc = pCtl->init(this,
-                        ctlData.strName,
-                        ctlData.storageBus,
-                        ctlData.ulInstance,
-                        ctlData.fBootable);
-        if (FAILED(rc)) return rc;
-
-        mStorageControllers->push_back(pCtl);
-
-        rc = pCtl->COMSETTER(ControllerType)(ctlData.controllerType);
-        if (FAILED(rc)) return rc;
-
-        rc = pCtl->COMSETTER(PortCount)(ctlData.ulPortCount);
-        if (FAILED(rc)) return rc;
-
-        rc = pCtl->COMSETTER(UseHostIOCache)(ctlData.fUseHostIOCache);
-        if (FAILED(rc)) return rc;
-
-        /* Set IDE emulation settings (only for AHCI controller). */
-        if (ctlData.controllerType == StorageControllerType_IntelAhci)
-        {
-            if (    (FAILED(rc = pCtl->setIDEEmulationPort(0, ctlData.lIDE0MasterEmulationPort)))
-                 || (FAILED(rc = pCtl->setIDEEmulationPort(1, ctlData.lIDE0SlaveEmulationPort)))
-                 || (FAILED(rc = pCtl->setIDEEmulationPort(2, ctlData.lIDE1MasterEmulationPort)))
-                 || (FAILED(rc = pCtl->setIDEEmulationPort(3, ctlData.lIDE1SlaveEmulationPort)))
-               )
-                return rc;
-        }
-
-        /* Load the attached devices now. */
-        rc = loadStorageDevices(pCtl,
-                                ctlData,
-                                puuidRegistry,
-                                puuidSnapshot);
-        if (FAILED(rc)) return rc;
-    }
-
-    return S_OK;
-}
-
-/**
- * Called from loadStorageControllers for a controller's devices.
- *
- * @param aStorageController
- * @param data
- * @param puuidRegistry media registry ID to set media to or NULL; see Machine::loadMachineDataFromSettings()
- * @param aSnapshotId  pointer to the snapshot ID if this is a snapshot machine
- * @return
- */
-HRESULT Machine::loadStorageDevices(StorageController *aStorageController,
-                                    const settings::StorageController &data,
-                                    const Guid *puuidRegistry,
-                                    const Guid *puuidSnapshot)
-{
-    HRESULT rc = S_OK;
-
-    /* paranoia: detect duplicate attachments */
-    for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
-         it != data.llAttachedDevices.end();
-         ++it)
-    {
-        const settings::AttachedDevice &ad = *it;
-
-        for (settings::AttachedDevicesList::const_iterator it2 = it;
-             it2 != data.llAttachedDevices.end();
-             ++it2)
-        {
-            if (it == it2)
-                continue;
-
-            const settings::AttachedDevice &ad2 = *it2;
-
-            if (   ad.lPort == ad2.lPort
-                && ad.lDevice == ad2.lDevice)
-            {
-                return setError(E_FAIL,
-                                tr("Duplicate attachments for storage controller '%s', port %d, device %d of the virtual machine '%s'"),
-                                aStorageController->getName().c_str(),
-                                ad.lPort,
-                                ad.lDevice,
-                                mUserData->s.strName.c_str());
-            }
-        }
-    }
-
-    for (settings::AttachedDevicesList::const_iterator it = data.llAttachedDevices.begin();
-         it != data.llAttachedDevices.end();
-         ++it)
-    {
-        const settings::AttachedDevice &dev = *it;
-        ComObjPtr<Medium> medium;
-
-        switch (dev.deviceType)
-        {
-            case DeviceType_Floppy:
-            case DeviceType_DVD:
-                if (dev.strHostDriveSrc.isNotEmpty())
-                    rc = mParent->host()->findHostDriveByName(dev.deviceType, dev.strHostDriveSrc, false /* fRefresh */, medium);
-                else
-                    rc = mParent->findRemoveableMedium(dev.deviceType,
-                                                       dev.uuid,
-                                                       false /* fRefresh */,
-                                                       false /* aSetError */,
-                                                       medium);
-                if (rc == VBOX_E_OBJECT_NOT_FOUND)
-                    // This is not an error. The host drive or UUID might have vanished, so just go ahead without this removeable medium attachment
-                    rc = S_OK;
-            break;
-
-            case DeviceType_HardDisk:
-            {
-                /* find a hard disk by UUID */
-                rc = mParent->findHardDiskById(dev.uuid, true /* aDoSetError */, &medium);
-                if (FAILED(rc))
-                {
-                    if (isSnapshotMachine())
-                    {
-                        // wrap another error message around the "cannot find hard disk" set by findHardDisk
-                        // so the user knows that the bad disk is in a snapshot somewhere
-                        com::ErrorInfo info;
-                        return setError(E_FAIL,
-                                        tr("A differencing image of snapshot {%RTuuid} could not be found. %ls"),
-                                        puuidSnapshot->raw(),
-                                        info.getText().raw());
-                    }
-                    else
-                        return rc;
-                }
-
-                AutoWriteLock hdLock(medium COMMA_LOCKVAL_SRC_POS);
-
-                if (medium->getType() == MediumType_Immutable)
-                {
-                    if (isSnapshotMachine())
-                        return setError(E_FAIL,
-                                        tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
-                                           "of the virtual machine '%s' ('%s')"),
-                                        medium->getLocationFull().c_str(),
-                                        dev.uuid.raw(),
-                                        puuidSnapshot->raw(),
-                                        mUserData->s.strName.c_str(),
-                                        mData->m_strConfigFileFull.c_str());
-
-                    return setError(E_FAIL,
-                                    tr("Immutable hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
-                                    medium->getLocationFull().c_str(),
-                                    dev.uuid.raw(),
-                                    mUserData->s.strName.c_str(),
-                                    mData->m_strConfigFileFull.c_str());
-                }
-
-                if (medium->getType() == MediumType_MultiAttach)
-                {
-                    if (isSnapshotMachine())
-                        return setError(E_FAIL,
-                                        tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to snapshot with UUID {%RTuuid} "
-                                           "of the virtual machine '%s' ('%s')"),
-                                        medium->getLocationFull().c_str(),
-                                        dev.uuid.raw(),
-                                        puuidSnapshot->raw(),
-                                        mUserData->s.strName.c_str(),
-                                        mData->m_strConfigFileFull.c_str());
-
-                    return setError(E_FAIL,
-                                    tr("Multi-attach hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s')"),
-                                    medium->getLocationFull().c_str(),
-                                    dev.uuid.raw(),
-                                    mUserData->s.strName.c_str(),
-                                    mData->m_strConfigFileFull.c_str());
-                }
-
-                if (    !isSnapshotMachine()
-                     && medium->getChildren().size() != 0
-                   )
-                    return setError(E_FAIL,
-                                    tr("Hard disk '%s' with UUID {%RTuuid} cannot be directly attached to the virtual machine '%s' ('%s') "
-                                       "because it has %d differencing child hard disks"),
-                                    medium->getLocationFull().c_str(),
-                                    dev.uuid.raw(),
-                                    mUserData->s.strName.c_str(),
-                                    mData->m_strConfigFileFull.c_str(),
-                                    medium->getChildren().size());
-
-                if (findAttachment(mMediaData->mAttachments,
-                                   medium))
-                    return setError(E_FAIL,
-                                    tr("Hard disk '%s' with UUID {%RTuuid} is already attached to the virtual machine '%s' ('%s')"),
-                                    medium->getLocationFull().c_str(),
-                                    dev.uuid.raw(),
-                                    mUserData->s.strName.c_str(),
-                                    mData->m_strConfigFileFull.c_str());
-
-                break;
-            }
-
-            default:
-                return setError(E_FAIL,
-                                tr("Device '%s' with unknown type is attached to the virtual machine '%s' ('%s')"),
-                                medium->getLocationFull().c_str(),
-                                mUserData->s.strName.c_str(),
-                                mData->m_strConfigFileFull.c_str());
-        }
-
-        if (FAILED(rc))
-            break;
-
-        /* Bandwidth groups are loaded at this point. */
-        ComObjPtr<BandwidthGroup> pBwGroup;
-
-        if (!dev.strBwGroup.isEmpty())
-        {
-            rc = mBandwidthControl->getBandwidthGroupByName(dev.strBwGroup, pBwGroup, false /* aSetError */);
-            if (FAILED(rc))
-                return setError(E_FAIL,
-                                tr("Device '%s' with unknown bandwidth group '%s' is attached to the virtual machine '%s' ('%s')"),
-                                medium->getLocationFull().c_str(),
-                                dev.strBwGroup.c_str(),
-                                mUserData->s.strName.c_str(),
-                                mData->m_strConfigFileFull.c_str());
-            pBwGroup->reference();
-        }
-
-        const Bstr controllerName = aStorageController->getName();
-        ComObjPtr<MediumAttachment> pAttachment;
-        pAttachment.createObject();
-        rc = pAttachment->init(this,
-                               medium,
-                               controllerName,
-                               dev.lPort,
-                               dev.lDevice,
-                               dev.deviceType,
-                               false,
-                               dev.fPassThrough,
-                               dev.fTempEject,
-                               dev.fNonRotational,
-                               dev.fDiscard,
-                               pBwGroup.isNull() ? Utf8Str::Empty : pBwGroup->getName());
-        if (FAILED(rc)) break;
-
-        /* associate the medium with this machine and snapshot */
-        if (!medium.isNull())
-        {
-            AutoCaller medCaller(medium);
-            if (FAILED(medCaller.rc())) return medCaller.rc();
-            AutoWriteLock mlock(medium COMMA_LOCKVAL_SRC_POS);
-
-            if (isSnapshotMachine())
-                rc = medium->addBackReference(mData->mUuid, *puuidSnapshot);
-            else
-                rc = medium->addBackReference(mData->mUuid);
-            /* If the medium->addBackReference fails it sets an appropriate
-             * error message, so no need to do any guesswork here. */
-
-            if (puuidRegistry)
-                // caller wants registry ID to be set on all attached media (OVF import case)
-                medium->addRegistry(*puuidRegistry, false /* fRecurse */);
-        }
-
-        if (FAILED(rc))
-            break;
-
-        /* back up mMediaData to let registeredInit() properly rollback on failure
-         * (= limited accessibility) */
-        setModified(IsModified_Storage);
-        mMediaData.backup();
-        mMediaData->mAttachments.push_back(pAttachment);
-    }
-
-    return rc;
-}
-
-/**
- *  Returns the snapshot with the given UUID or fails of no such snapshot exists.
- *
- *  @param aId          snapshot UUID to find (empty UUID refers the first snapshot)
- *  @param aSnapshot    where to return the found snapshot
- *  @param aSetError    true to set extended error info on failure
- */
-HRESULT Machine::findSnapshotById(const Guid &aId,
-                                  ComObjPtr<Snapshot> &aSnapshot,
-                                  bool aSetError /* = false */)
-{
-    AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mData->mFirstSnapshot)
-    {
-        if (aSetError)
-            return setError(E_FAIL, tr("This machine does not have any snapshots"));
-        return E_FAIL;
-    }
-
-    if (aId.isZero())
-        aSnapshot = mData->mFirstSnapshot;
-    else
-        aSnapshot = mData->mFirstSnapshot->findChildOrSelf(aId.ref());
-
-    if (!aSnapshot)
-    {
-        if (aSetError)
-            return setError(E_FAIL,
-                            tr("Could not find a snapshot with UUID {%s}"),
-                            aId.toString().c_str());
-        return E_FAIL;
-    }
-
-    return S_OK;
-}
-
-/**
- *  Returns the snapshot with the given name or fails of no such snapshot.
- *
- *  @param aName        snapshot name to find
- *  @param aSnapshot    where to return the found snapshot
- *  @param aSetError    true to set extended error info on failure
- */
-HRESULT Machine::findSnapshotByName(const Utf8Str &strName,
-                                    ComObjPtr<Snapshot> &aSnapshot,
-                                    bool aSetError /* = false */)
-{
-    AssertReturn(!strName.isEmpty(), E_INVALIDARG);
-
-    AutoReadLock chlock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mData->mFirstSnapshot)
-    {
-        if (aSetError)
-            return setError(VBOX_E_OBJECT_NOT_FOUND,
-                            tr("This machine does not have any snapshots"));
-        return VBOX_E_OBJECT_NOT_FOUND;
-    }
-
-    aSnapshot = mData->mFirstSnapshot->findChildOrSelf(strName);
-
-    if (!aSnapshot)
-    {
-        if (aSetError)
-            return setError(VBOX_E_OBJECT_NOT_FOUND,
-                            tr("Could not find a snapshot named '%s'"), strName.c_str());
-        return VBOX_E_OBJECT_NOT_FOUND;
-    }
-
-    return S_OK;
-}
-
-/**
- * Returns a storage controller object with the given name.
- *
- *  @param aName                 storage controller name to find
- *  @param aStorageController    where to return the found storage controller
- *  @param aSetError             true to set extended error info on failure
- */
-HRESULT Machine::getStorageControllerByName(const Utf8Str &aName,
-                                            ComObjPtr<StorageController> &aStorageController,
-                                            bool aSetError /* = false */)
-{
-    AssertReturn(!aName.isEmpty(), E_INVALIDARG);
-
-    for (StorageControllerList::const_iterator it = mStorageControllers->begin();
-         it != mStorageControllers->end();
-         ++it)
-    {
-        if ((*it)->getName() == aName)
-        {
-            aStorageController = (*it);
-            return S_OK;
-        }
-    }
-
-    if (aSetError)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("Could not find a storage controller named '%s'"),
-                        aName.c_str());
-    return VBOX_E_OBJECT_NOT_FOUND;
-}
-
-/**
- * Returns a USB controller object with the given name.
- *
- *  @param aName                 USB controller name to find
- *  @param aUSBController        where to return the found USB controller
- *  @param aSetError             true to set extended error info on failure
- */
-HRESULT Machine::getUSBControllerByName(const Utf8Str &aName,
-                                        ComObjPtr<USBController> &aUSBController,
-                                        bool aSetError /* = false */)
-{
-    AssertReturn(!aName.isEmpty(), E_INVALIDARG);
-
-    for (USBControllerList::const_iterator it = mUSBControllers->begin();
-         it != mUSBControllers->end();
-         ++it)
-    {
-        if ((*it)->getName() == aName)
-        {
-            aUSBController = (*it);
-            return S_OK;
-        }
-    }
-
-    if (aSetError)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("Could not find a storage controller named '%s'"),
-                        aName.c_str());
-    return VBOX_E_OBJECT_NOT_FOUND;
-}
-
-/**
- * Returns the number of USB controller instance of the given type.
- *
- * @param enmType                USB controller type.
- */
-ULONG Machine::getUSBControllerCountByType(USBControllerType_T enmType)
-{
-    ULONG cCtrls = 0;
-
-    for (USBControllerList::const_iterator it = mUSBControllers->begin();
-         it != mUSBControllers->end();
-         ++it)
-    {
-        if ((*it)->getControllerType() == enmType)
-            cCtrls++;
-    }
-
-    return cCtrls;
-}
-
-HRESULT Machine::getMediumAttachmentsOfController(CBSTR aName,
-                                                  MediaData::AttachmentList &atts)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    for (MediaData::AttachmentList::iterator it = mMediaData->mAttachments.begin();
-         it != mMediaData->mAttachments.end();
-         ++it)
-    {
-        const ComObjPtr<MediumAttachment> &pAtt = *it;
-
-        // should never happen, but deal with NULL pointers in the list.
-        AssertStmt(!pAtt.isNull(), continue);
-
-        // getControllerName() needs caller+read lock
-        AutoCaller autoAttCaller(pAtt);
-        if (FAILED(autoAttCaller.rc()))
-        {
-            atts.clear();
-            return autoAttCaller.rc();
-        }
-        AutoReadLock attLock(pAtt COMMA_LOCKVAL_SRC_POS);
-
-        if (pAtt->getControllerName() == aName)
-            atts.push_back(pAtt);
-    }
-
-    return S_OK;
-}
-
-/**
- *  Helper for #saveSettings. Cares about renaming the settings directory and
- *  file if the machine name was changed and about creating a new settings file
- *  if this is a new machine.
- *
- *  @note Must be never called directly but only from #saveSettings().
- */
-HRESULT Machine::prepareSaveSettings(bool *pfNeedsGlobalSaveSettings)
-{
-    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    bool fSettingsFileIsNew = !mData->pMachineConfigFile->fileExists();
-
-    /// @todo need to handle primary group change, too
-
-    /* attempt to rename the settings file if machine name is changed */
-    if (    mUserData->s.fNameSync
-         && mUserData.isBackedUp()
-         && (   mUserData.backedUpData()->s.strName != mUserData->s.strName
-             || mUserData.backedUpData()->s.llGroups.front() != mUserData->s.llGroups.front())
-       )
-    {
-        bool dirRenamed = false;
-        bool fileRenamed = false;
-
-        Utf8Str configFile, newConfigFile;
-        Utf8Str configFilePrev, newConfigFilePrev;
-        Utf8Str configDir, newConfigDir;
-
-        do
-        {
-            int vrc = VINF_SUCCESS;
-
-            Utf8Str name = mUserData.backedUpData()->s.strName;
-            Utf8Str newName = mUserData->s.strName;
-            Utf8Str group = mUserData.backedUpData()->s.llGroups.front();
-            if (group == "/")
-                group.setNull();
-            Utf8Str newGroup = mUserData->s.llGroups.front();
-            if (newGroup == "/")
-                newGroup.setNull();
-
-            configFile = mData->m_strConfigFileFull;
-
-            /* first, rename the directory if it matches the group and machine name */
-            Utf8Str groupPlusName = Utf8StrFmt("%s%c%s",
-                group.c_str(), RTPATH_DELIMITER, name.c_str());
-            /** @todo hack, make somehow use of ComposeMachineFilename */
-            if (mUserData->s.fDirectoryIncludesUUID)
-                groupPlusName += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
-            Utf8Str newGroupPlusName = Utf8StrFmt("%s%c%s",
-                newGroup.c_str(), RTPATH_DELIMITER, newName.c_str());
-            /** @todo hack, make somehow use of ComposeMachineFilename */
-            if (mUserData->s.fDirectoryIncludesUUID)
-                newGroupPlusName += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
-            configDir = configFile;
-            configDir.stripFilename();
-            newConfigDir = configDir;
-            if (   configDir.length() >= groupPlusName.length()
-                && !RTPathCompare(configDir.substr(configDir.length() - groupPlusName.length(), groupPlusName.length()).c_str(), groupPlusName.c_str()))
-            {
-                newConfigDir = newConfigDir.substr(0, configDir.length() - groupPlusName.length());
-                Utf8Str newConfigBaseDir(newConfigDir);
-                newConfigDir.append(newGroupPlusName);
-                /* consistency: use \ if appropriate on the platform */
-                RTPathChangeToDosSlashes(newConfigDir.mutableRaw(), false);
-                /* new dir and old dir cannot be equal here because of 'if'
-                 * above and because name != newName */
-                Assert(configDir != newConfigDir);
-                if (!fSettingsFileIsNew)
-                {
-                    /* perform real rename only if the machine is not new */
-                    vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
-                    if (   vrc == VERR_FILE_NOT_FOUND
-                        || vrc == VERR_PATH_NOT_FOUND)
-                    {
-                        /* create the parent directory, then retry renaming */
-                        Utf8Str parent(newConfigDir);
-                        parent.stripFilename();
-                        (void)RTDirCreateFullPath(parent.c_str(), 0700);
-                        vrc = RTPathRename(configDir.c_str(), newConfigDir.c_str(), 0);
-                    }
-                    if (RT_FAILURE(vrc))
-                    {
-                        rc = setError(E_FAIL,
-                                      tr("Could not rename the directory '%s' to '%s' to save the settings file (%Rrc)"),
-                                      configDir.c_str(),
-                                      newConfigDir.c_str(),
-                                      vrc);
-                        break;
-                    }
-                    /* delete subdirectories which are no longer needed */
-                    Utf8Str dir(configDir);
-                    dir.stripFilename();
-                    while (dir != newConfigBaseDir && dir != ".")
-                    {
-                        vrc = RTDirRemove(dir.c_str());
-                        if (RT_FAILURE(vrc))
-                            break;
-                        dir.stripFilename();
-                    }
-                    dirRenamed = true;
-                }
-            }
-
-            newConfigFile = Utf8StrFmt("%s%c%s.vbox",
-                newConfigDir.c_str(), RTPATH_DELIMITER, newName.c_str());
-
-            /* then try to rename the settings file itself */
-            if (newConfigFile != configFile)
-            {
-                /* get the path to old settings file in renamed directory */
-                configFile = Utf8StrFmt("%s%c%s",
-                                        newConfigDir.c_str(),
-                                        RTPATH_DELIMITER,
-                                        RTPathFilename(configFile.c_str()));
-                if (!fSettingsFileIsNew)
-                {
-                    /* perform real rename only if the machine is not new */
-                    vrc = RTFileRename(configFile.c_str(), newConfigFile.c_str(), 0);
-                    if (RT_FAILURE(vrc))
-                    {
-                        rc = setError(E_FAIL,
-                                      tr("Could not rename the settings file '%s' to '%s' (%Rrc)"),
-                                      configFile.c_str(),
-                                      newConfigFile.c_str(),
-                                      vrc);
-                        break;
-                    }
-                    fileRenamed = true;
-                    configFilePrev = configFile;
-                    configFilePrev += "-prev";
-                    newConfigFilePrev = newConfigFile;
-                    newConfigFilePrev += "-prev";
-                    RTFileRename(configFilePrev.c_str(), newConfigFilePrev.c_str(), 0);
-                }
-            }
-
-            // update m_strConfigFileFull amd mConfigFile
-            mData->m_strConfigFileFull = newConfigFile;
-            // compute the relative path too
-            mParent->copyPathRelativeToConfig(newConfigFile, mData->m_strConfigFile);
-
-            // store the old and new so that VirtualBox::saveSettings() can update
-            // the media registry
-            if (    mData->mRegistered
-                 && configDir != newConfigDir)
-            {
-                mParent->rememberMachineNameChangeForMedia(configDir, newConfigDir);
-
-                if (pfNeedsGlobalSaveSettings)
-                    *pfNeedsGlobalSaveSettings = true;
-            }
-
-            // in the saved state file path, replace the old directory with the new directory
-            if (RTPathStartsWith(mSSData->strStateFilePath.c_str(), configDir.c_str()))
-                mSSData->strStateFilePath = newConfigDir.append(mSSData->strStateFilePath.c_str() + configDir.length());
-
-            // and do the same thing for the saved state file paths of all the online snapshots
-            if (mData->mFirstSnapshot)
-                mData->mFirstSnapshot->updateSavedStatePaths(configDir.c_str(),
-                                                             newConfigDir.c_str());
-        }
-        while (0);
-
-        if (FAILED(rc))
-        {
-            /* silently try to rename everything back */
-            if (fileRenamed)
-            {
-                RTFileRename(newConfigFilePrev.c_str(), configFilePrev.c_str(), 0);
-                RTFileRename(newConfigFile.c_str(), configFile.c_str(), 0);
-            }
-            if (dirRenamed)
-                RTPathRename(newConfigDir.c_str(), configDir.c_str(), 0);
-        }
-
-        if (FAILED(rc)) return rc;
-    }
-
-    if (fSettingsFileIsNew)
-    {
-        /* create a virgin config file */
-        int vrc = VINF_SUCCESS;
-
-        /* ensure the settings directory exists */
-        Utf8Str path(mData->m_strConfigFileFull);
-        path.stripFilename();
-        if (!RTDirExists(path.c_str()))
-        {
-            vrc = RTDirCreateFullPath(path.c_str(), 0700);
-            if (RT_FAILURE(vrc))
-            {
-                return setError(E_FAIL,
-                                tr("Could not create a directory '%s' to save the settings file (%Rrc)"),
-                                path.c_str(),
-                                vrc);
-            }
-        }
-
-        /* Note: open flags must correlate with RTFileOpen() in lockConfig() */
-        path = Utf8Str(mData->m_strConfigFileFull);
-        RTFILE f = NIL_RTFILE;
-        vrc = RTFileOpen(&f, path.c_str(),
-                         RTFILE_O_READWRITE | RTFILE_O_CREATE | RTFILE_O_DENY_WRITE);
-        if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Could not create the settings file '%s' (%Rrc)"),
-                            path.c_str(),
-                            vrc);
-        RTFileClose(f);
-    }
-
-    return rc;
-}
-
-/**
- * Saves and commits machine data, user data and hardware data.
- *
- * Note that on failure, the data remains uncommitted.
- *
- * @a aFlags may combine the following flags:
- *
- *  - SaveS_ResetCurStateModified: Resets mData->mCurrentStateModified to FALSE.
- *    Used when saving settings after an operation that makes them 100%
- *    correspond to the settings from the current snapshot.
- *  - SaveS_InformCallbacksAnyway: Callbacks will be informed even if
- *    #isReallyModified() returns false. This is necessary for cases when we
- *    change machine data directly, not through the backup()/commit() mechanism.
- *  - SaveS_Force: settings will be saved without doing a deep compare of the
- *    settings structures. This is used when this is called because snapshots
- *    have changed to avoid the overhead of the deep compare.
- *
- * @note Must be called from under this object's write lock. Locks children for
- * writing.
- *
- * @param pfNeedsGlobalSaveSettings Optional pointer to a bool that must have been
- *          initialized to false and that will be set to true by this function if
- *          the caller must invoke VirtualBox::saveSettings() because the global
- *          settings have changed. This will happen if a machine rename has been
- *          saved and the global machine and media registries will therefore need
- *          updating.
- */
-HRESULT Machine::saveSettings(bool *pfNeedsGlobalSaveSettings,
-                              int aFlags /*= 0*/)
-{
-    LogFlowThisFuncEnter();
-
-    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
-
-    /* make sure child objects are unable to modify the settings while we are
-     * saving them */
-    ensureNoStateDependencies();
-
-    AssertReturn(!isSnapshotMachine(),
-                 E_FAIL);
-
-    HRESULT rc = S_OK;
-    bool fNeedsWrite = false;
-
-    /* First, prepare to save settings. It will care about renaming the
-     * settings directory and file if the machine name was changed and about
-     * creating a new settings file if this is a new machine. */
-    rc = prepareSaveSettings(pfNeedsGlobalSaveSettings);
-    if (FAILED(rc)) return rc;
-
-    // keep a pointer to the current settings structures
-    settings::MachineConfigFile *pOldConfig = mData->pMachineConfigFile;
-    settings::MachineConfigFile *pNewConfig = NULL;
-
-    try
-    {
-        // make a fresh one to have everyone write stuff into
-        pNewConfig = new settings::MachineConfigFile(NULL);
-        pNewConfig->copyBaseFrom(*mData->pMachineConfigFile);
-
-        // now go and copy all the settings data from COM to the settings structures
-        // (this calles saveSettings() on all the COM objects in the machine)
-        copyMachineDataToSettings(*pNewConfig);
-
-        if (aFlags & SaveS_ResetCurStateModified)
-        {
-            // this gets set by takeSnapshot() (if offline snapshot) and restoreSnapshot()
-            mData->mCurrentStateModified = FALSE;
-            fNeedsWrite = true;     // always, no need to compare
-        }
-        else if (aFlags & SaveS_Force)
-        {
-            fNeedsWrite = true;     // always, no need to compare
-        }
-        else
-        {
-            if (!mData->mCurrentStateModified)
-            {
-                // do a deep compare of the settings that we just saved with the settings
-                // previously stored in the config file; this invokes MachineConfigFile::operator==
-                // which does a deep compare of all the settings, which is expensive but less expensive
-                // than writing out XML in vain
-                bool fAnySettingsChanged = !(*pNewConfig == *pOldConfig);
-
-                // could still be modified if any settings changed
-                mData->mCurrentStateModified = fAnySettingsChanged;
-
-                fNeedsWrite = fAnySettingsChanged;
-            }
-            else
-                fNeedsWrite = true;
-        }
-
-        pNewConfig->fCurrentStateModified = !!mData->mCurrentStateModified;
-
-        if (fNeedsWrite)
-            // now spit it all out!
-            pNewConfig->write(mData->m_strConfigFileFull);
-
-        mData->pMachineConfigFile = pNewConfig;
-        delete pOldConfig;
-        commit();
-
-        // after saving settings, we are no longer different from the XML on disk
-        mData->flModifications = 0;
-    }
-    catch (HRESULT err)
-    {
-        // we assume that error info is set by the thrower
-        rc = err;
-
-        // restore old config
-        delete pNewConfig;
-        mData->pMachineConfigFile = pOldConfig;
-    }
-    catch (...)
-    {
-        rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-
-    if (fNeedsWrite || (aFlags & SaveS_InformCallbacksAnyway))
-    {
-        /* Fire the data change event, even on failure (since we've already
-         * committed all data). This is done only for SessionMachines because
-         * mutable Machine instances are always not registered (i.e. private
-         * to the client process that creates them) and thus don't need to
-         * inform callbacks. */
-        if (isSessionMachine())
-            mParent->onMachineDataChange(mData->mUuid);
-    }
-
-    LogFlowThisFunc(("rc=%08X\n", rc));
-    LogFlowThisFuncLeave();
-    return rc;
-}
-
-/**
- * Implementation for saving the machine settings into the given
- * settings::MachineConfigFile instance. This copies machine extradata
- * from the previous machine config file in the instance data, if any.
- *
- * This gets called from two locations:
- *
- *  --  Machine::saveSettings(), during the regular XML writing;
- *
- *  --  Appliance::buildXMLForOneVirtualSystem(), when a machine gets
- *      exported to OVF and we write the VirtualBox proprietary XML
- *      into a <vbox:Machine> tag.
- *
- * This routine fills all the fields in there, including snapshots, *except*
- * for the following:
- *
- * -- fCurrentStateModified. There is some special logic associated with that.
- *
- * The caller can then call MachineConfigFile::write() or do something else
- * with it.
- *
- * Caller must hold the machine lock!
- *
- * This throws XML errors and HRESULT, so the caller must have a catch block!
- */
-void Machine::copyMachineDataToSettings(settings::MachineConfigFile &config)
-{
-    // deep copy extradata
-    config.mapExtraDataItems = mData->pMachineConfigFile->mapExtraDataItems;
-
-    config.uuid = mData->mUuid;
-
-    // copy name, description, OS type, teleport, UTC etc.
-    config.machineUserData = mUserData->s;
-
-    // Encode the Icon Override data from Machine and store on config userdata.
-    com::SafeArray<BYTE> iconByte;
-    COMGETTER(Icon)(ComSafeArrayAsOutParam(iconByte));
-    ssize_t cbData = iconByte.size();
-    if (cbData > 0)
-    {
-        ssize_t cchOut = RTBase64EncodedLength(cbData);
-        Utf8Str strIconData;
-        strIconData.reserve(cchOut+1);
-        int vrc = RTBase64Encode(iconByte.raw(), cbData,
-                                 strIconData.mutableRaw(), strIconData.capacity(),
-                                 NULL);
-        if (RT_FAILURE(vrc))
-            throw setError(E_FAIL, tr("Failure to Encode Icon Data. '%s' (%Rrc)"), strIconData.mutableRaw(), vrc);
-        strIconData.jolt();
-        config.machineUserData.ovIcon = strIconData;
-    }
-    else
-        config.machineUserData.ovIcon.setNull();
-
-    if (    mData->mMachineState == MachineState_Saved
-         || mData->mMachineState == MachineState_Restoring
-            // when deleting a snapshot we may or may not have a saved state in the current state,
-            // so let's not assert here please
-         || (    (   mData->mMachineState == MachineState_DeletingSnapshot
-                  || mData->mMachineState == MachineState_DeletingSnapshotOnline
-                  || mData->mMachineState == MachineState_DeletingSnapshotPaused)
-              && (!mSSData->strStateFilePath.isEmpty())
-            )
-        )
-    {
-        Assert(!mSSData->strStateFilePath.isEmpty());
-        /* try to make the file name relative to the settings file dir */
-        copyPathRelativeToMachine(mSSData->strStateFilePath, config.strStateFile);
-    }
-    else
-    {
-        Assert(mSSData->strStateFilePath.isEmpty() || mData->mMachineState == MachineState_Saving);
-        config.strStateFile.setNull();
-    }
-
-    if (mData->mCurrentSnapshot)
-        config.uuidCurrentSnapshot = mData->mCurrentSnapshot->getId();
-    else
-        config.uuidCurrentSnapshot.clear();
-
-    config.timeLastStateChange = mData->mLastStateChange;
-    config.fAborted = (mData->mMachineState == MachineState_Aborted);
-    /// @todo Live Migration:        config.fTeleported = (mData->mMachineState == MachineState_Teleported);
-
-    HRESULT rc = saveHardware(config.hardwareMachine, &config.debugging, &config.autostart);
-    if (FAILED(rc)) throw rc;
-
-    rc = saveStorageControllers(config.storageMachine);
-    if (FAILED(rc)) throw rc;
-
-    // save machine's media registry if this is VirtualBox 4.0 or later
-    if (config.canHaveOwnMediaRegistry())
-    {
-        // determine machine folder
-        Utf8Str strMachineFolder = getSettingsFileFull();
-        strMachineFolder.stripFilename();
-        mParent->saveMediaRegistry(config.mediaRegistry,
-                                   getId(),             // only media with registry ID == machine UUID
-                                   strMachineFolder);
-            // this throws HRESULT
-    }
-
-    // save snapshots
-    rc = saveAllSnapshots(config);
-    if (FAILED(rc)) throw rc;
-}
-
-/**
- * Saves all snapshots of the machine into the given machine config file. Called
- * from Machine::buildMachineXML() and SessionMachine::deleteSnapshotHandler().
- * @param config
- * @return
- */
-HRESULT Machine::saveAllSnapshots(settings::MachineConfigFile &config)
-{
-    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    try
-    {
-        config.llFirstSnapshot.clear();
-
-        if (mData->mFirstSnapshot)
-        {
-            settings::Snapshot snapNew;
-            config.llFirstSnapshot.push_back(snapNew);
-
-            // get reference to the fresh copy of the snapshot on the list and
-            // work on that copy directly to avoid excessive copying later
-            settings::Snapshot &snap = config.llFirstSnapshot.front();
-
-            rc = mData->mFirstSnapshot->saveSnapshot(snap, false /*aAttrsOnly*/);
-            if (FAILED(rc)) throw rc;
-        }
-
-//         if (mType == IsSessionMachine)
-//             mParent->onMachineDataChange(mData->mUuid);          @todo is this necessary?
-
-    }
-    catch (HRESULT err)
-    {
-        /* we assume that error info is set by the thrower */
-        rc = err;
-    }
-    catch (...)
-    {
-        rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-
-    return rc;
-}
-
-/**
- *  Saves the VM hardware configuration. It is assumed that the
- *  given node is empty.
- *
- *  @param data           Reference to the settings object for the hardware config.
- *  @param pDbg           Pointer to the settings object for the debugging config
- *                        which happens to live in mHWData.
- *  @param pAutostart     Pointer to the settings object for the autostart config
- *                        which happens to live in mHWData.
- */
-HRESULT Machine::saveHardware(settings::Hardware &data, settings::Debugging *pDbg,
-                              settings::Autostart *pAutostart)
-{
-    HRESULT rc = S_OK;
-
-    try
-    {
-        /* The hardware version attribute (optional).
-            Automatically upgrade from 1 to 2 when there is no saved state. (ugly!) */
-        if (    mHWData->mHWVersion == "1"
-             && mSSData->strStateFilePath.isEmpty()
-           )
-            mHWData->mHWVersion = "2";  /** @todo Is this safe, to update mHWVersion here? If not some other point needs to be found where this can be done. */
-
-        data.strVersion = mHWData->mHWVersion;
-        data.uuid = mHWData->mHardwareUUID;
-
-        // CPU
-        data.fHardwareVirt          = !!mHWData->mHWVirtExEnabled;
-        data.fHardwareVirtExclusive = !!mHWData->mHWVirtExExclusive;
-        data.fNestedPaging          = !!mHWData->mHWVirtExNestedPagingEnabled;
-        data.fLargePages            = !!mHWData->mHWVirtExLargePagesEnabled;
-        data.fVPID                  = !!mHWData->mHWVirtExVPIDEnabled;
-        data.fUnrestrictedExecution = !!mHWData->mHWVirtExUXEnabled;
-        data.fHardwareVirtForce     = !!mHWData->mHWVirtExForceEnabled;
-        data.fPAE                   = !!mHWData->mPAEEnabled;
-        data.enmLongMode            = mHWData->mLongMode;
-        data.fSyntheticCpu          = !!mHWData->mSyntheticCpu;
-
-        /* Standard and Extended CPUID leafs. */
-        data.llCpuIdLeafs.clear();
-        for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdStdLeafs); idx++)
-        {
-            if (mHWData->mCpuIdStdLeafs[idx].ulId != UINT32_MAX)
-                data.llCpuIdLeafs.push_back(mHWData->mCpuIdStdLeafs[idx]);
-        }
-        for (unsigned idx = 0; idx < RT_ELEMENTS(mHWData->mCpuIdExtLeafs); idx++)
-        {
-            if (mHWData->mCpuIdExtLeafs[idx].ulId != UINT32_MAX)
-                data.llCpuIdLeafs.push_back(mHWData->mCpuIdExtLeafs[idx]);
-        }
-
-        data.cCPUs             = mHWData->mCPUCount;
-        data.fCpuHotPlug       = !!mHWData->mCPUHotPlugEnabled;
-        data.ulCpuExecutionCap = mHWData->mCpuExecutionCap;
-
-        data.llCpus.clear();
-        if (data.fCpuHotPlug)
-        {
-            for (unsigned idx = 0; idx < data.cCPUs; idx++)
-            {
-                if (mHWData->mCPUAttached[idx])
-                {
-                    settings::Cpu cpu;
-                    cpu.ulId = idx;
-                    data.llCpus.push_back(cpu);
-                }
-            }
-        }
-
-        // memory
-        data.ulMemorySizeMB = mHWData->mMemorySize;
-        data.fPageFusionEnabled = !!mHWData->mPageFusionEnabled;
-
-        // firmware
-        data.firmwareType = mHWData->mFirmwareType;
-
-        // HID
-        data.pointingHIDType = mHWData->mPointingHIDType;
-        data.keyboardHIDType = mHWData->mKeyboardHIDType;
-
-        // chipset
-        data.chipsetType = mHWData->mChipsetType;
-
-        data.fEmulatedUSBWebcam     = !!mHWData->mEmulatedUSBWebcamEnabled;
-        data.fEmulatedUSBCardReader = !!mHWData->mEmulatedUSBCardReaderEnabled;
-
-        // HPET
-        data.fHPETEnabled = !!mHWData->mHPETEnabled;
-
-        // boot order
-        data.mapBootOrder.clear();
-        for (size_t i = 0;
-             i < RT_ELEMENTS(mHWData->mBootOrder);
-             ++i)
-            data.mapBootOrder[i] = mHWData->mBootOrder[i];
-
-        // display
-        data.graphicsControllerType = mHWData->mGraphicsControllerType;
-        data.ulVRAMSizeMB = mHWData->mVRAMSize;
-        data.cMonitors = mHWData->mMonitorCount;
-        data.fAccelerate3D = !!mHWData->mAccelerate3DEnabled;
-        data.fAccelerate2DVideo = !!mHWData->mAccelerate2DVideoEnabled;
-        data.ulVideoCaptureHorzRes = mHWData->mVideoCaptureWidth;
-        data.ulVideoCaptureVertRes = mHWData->mVideoCaptureHeight;
-        data.ulVideoCaptureRate = mHWData->mVideoCaptureRate;
-        data.ulVideoCaptureFPS = mHWData->mVideoCaptureFPS;
-        data.fVideoCaptureEnabled  = !!mHWData->mVideoCaptureEnabled;
-        for (unsigned i = 0; i < sizeof(data.u64VideoCaptureScreens) * 8; i++)
-        {
-            if (mHWData->maVideoCaptureScreens[i])
-                ASMBitSet(&data.u64VideoCaptureScreens, i);
-            else
-                ASMBitClear(&data.u64VideoCaptureScreens, i);
-        }
-        /* store relative video capture file if possible */
-        copyPathRelativeToMachine(mHWData->mVideoCaptureFile, data.strVideoCaptureFile);
-
-        /* VRDEServer settings (optional) */
-        rc = mVRDEServer->saveSettings(data.vrdeSettings);
-        if (FAILED(rc)) throw rc;
-
-        /* BIOS (required) */
-        rc = mBIOSSettings->saveSettings(data.biosSettings);
-        if (FAILED(rc)) throw rc;
-
-        /* USB Controller (required) */
-        for (USBControllerList::const_iterator it = mUSBControllers->begin();
-             it != mUSBControllers->end();
-             ++it)
-        {
-            ComObjPtr<USBController> ctrl = *it;
-            settings::USBController settingsCtrl;
-
-            settingsCtrl.strName = ctrl->getName();
-            settingsCtrl.enmType = ctrl->getControllerType();
-
-            data.usbSettings.llUSBControllers.push_back(settingsCtrl);
-        }
-
-        /* USB device filters (required) */
-        rc = mUSBDeviceFilters->saveSettings(data.usbSettings);
-        if (FAILED(rc)) throw rc;
-
-        /* Network adapters (required) */
-        uint32_t uMaxNICs = RT_MIN(Global::getMaxNetworkAdapters(mHWData->mChipsetType), mNetworkAdapters.size());
-        data.llNetworkAdapters.clear();
-        /* Write out only the nominal number of network adapters for this
-         * chipset type. Since Machine::commit() hasn't been called there
-         * may be extra NIC settings in the vector. */
-        for (ULONG slot = 0; slot < uMaxNICs; ++slot)
-        {
-            settings::NetworkAdapter nic;
-            nic.ulSlot = slot;
-            /* paranoia check... must not be NULL, but must not crash either. */
-            if (mNetworkAdapters[slot])
-            {
-                rc = mNetworkAdapters[slot]->saveSettings(nic);
-                if (FAILED(rc)) throw rc;
-
-                data.llNetworkAdapters.push_back(nic);
-            }
-        }
-
-        /* Serial ports */
-        data.llSerialPorts.clear();
-        for (ULONG slot = 0;
-             slot < RT_ELEMENTS(mSerialPorts);
-             ++slot)
-        {
-            settings::SerialPort s;
-            s.ulSlot = slot;
-            rc = mSerialPorts[slot]->saveSettings(s);
-            if (FAILED(rc)) return rc;
-
-            data.llSerialPorts.push_back(s);
-        }
-
-        /* Parallel ports */
-        data.llParallelPorts.clear();
-        for (ULONG slot = 0;
-             slot < RT_ELEMENTS(mParallelPorts);
-             ++slot)
-        {
-            settings::ParallelPort p;
-            p.ulSlot = slot;
-            rc = mParallelPorts[slot]->saveSettings(p);
-            if (FAILED(rc)) return rc;
-
-            data.llParallelPorts.push_back(p);
-        }
-
-        /* Audio adapter */
-        rc = mAudioAdapter->saveSettings(data.audioAdapter);
-        if (FAILED(rc)) return rc;
-
-        /* Shared folders */
-        data.llSharedFolders.clear();
-        for (HWData::SharedFolderList::const_iterator it = mHWData->mSharedFolders.begin();
-            it != mHWData->mSharedFolders.end();
-            ++it)
-        {
-            SharedFolder *pSF = *it;
-            AutoCaller sfCaller(pSF);
-            AutoReadLock sfLock(pSF COMMA_LOCKVAL_SRC_POS);
-            settings::SharedFolder sf;
-            sf.strName = pSF->getName();
-            sf.strHostPath = pSF->getHostPath();
-            sf.fWritable = !!pSF->isWritable();
-            sf.fAutoMount = !!pSF->isAutoMounted();
-
-            data.llSharedFolders.push_back(sf);
-        }
-
-        // clipboard
-        data.clipboardMode = mHWData->mClipboardMode;
-
-        // drag'n'drop
-        data.dragAndDropMode = mHWData->mDragAndDropMode;
-
-        /* Guest */
-        data.ulMemoryBalloonSize = mHWData->mMemoryBalloonSize;
-
-        // IO settings
-        data.ioSettings.fIOCacheEnabled = !!mHWData->mIOCacheEnabled;
-        data.ioSettings.ulIOCacheSize = mHWData->mIOCacheSize;
-
-        /* BandwidthControl (required) */
-        rc = mBandwidthControl->saveSettings(data.ioSettings);
-        if (FAILED(rc)) throw rc;
-
-        /* Host PCI devices */
-        for (HWData::PCIDeviceAssignmentList::const_iterator it = mHWData->mPCIDeviceAssignments.begin();
-             it != mHWData->mPCIDeviceAssignments.end();
-             ++it)
-        {
-            ComObjPtr<PCIDeviceAttachment> pda = *it;
-            settings::HostPCIDeviceAttachment hpda;
-
-            rc = pda->saveSettings(hpda);
-            if (FAILED(rc)) throw rc;
-
-            data.pciAttachments.push_back(hpda);
-        }
-
-
-        // guest properties
-        data.llGuestProperties.clear();
-#ifdef VBOX_WITH_GUEST_PROPS
-        for (HWData::GuestPropertyMap::const_iterator it = mHWData->mGuestProperties.begin();
-             it != mHWData->mGuestProperties.end();
-             ++it)
-        {
-            HWData::GuestProperty property = it->second;
-
-            /* Remove transient guest properties at shutdown unless we
-             * are saving state */
-            if (   (   mData->mMachineState == MachineState_PoweredOff
-                    || mData->mMachineState == MachineState_Aborted
-                    || mData->mMachineState == MachineState_Teleported)
-                && (   property.mFlags & guestProp::TRANSIENT
-                    || property.mFlags & guestProp::TRANSRESET))
-                continue;
-            settings::GuestProperty prop;
-            prop.strName = it->first;
-            prop.strValue = property.strValue;
-            prop.timestamp = property.mTimestamp;
-            char szFlags[guestProp::MAX_FLAGS_LEN + 1];
-            guestProp::writeFlags(property.mFlags, szFlags);
-            prop.strFlags = szFlags;
-
-            data.llGuestProperties.push_back(prop);
-        }
-
-        data.strNotificationPatterns = mHWData->mGuestPropertyNotificationPatterns;
-        /* I presume this doesn't require a backup(). */
-        mData->mGuestPropertiesModified = FALSE;
-#endif /* VBOX_WITH_GUEST_PROPS defined */
-
-        *pDbg = mHWData->mDebugging;
-        *pAutostart = mHWData->mAutostart;
-
-        data.strDefaultFrontend = mHWData->mDefaultFrontend;
-    }
-    catch(std::bad_alloc &)
-    {
-        return E_OUTOFMEMORY;
-    }
-
-    AssertComRC(rc);
-    return rc;
-}
-
-/**
- *  Saves the storage controller configuration.
- *
- *  @param aNode    <StorageControllers> node to save the VM hardware configuration to.
- */
-HRESULT Machine::saveStorageControllers(settings::Storage &data)
-{
-    data.llStorageControllers.clear();
-
-    for (StorageControllerList::const_iterator it = mStorageControllers->begin();
-         it != mStorageControllers->end();
-         ++it)
-    {
-        HRESULT rc;
-        ComObjPtr<StorageController> pCtl = *it;
-
-        settings::StorageController ctl;
-        ctl.strName = pCtl->getName();
-        ctl.controllerType = pCtl->getControllerType();
-        ctl.storageBus = pCtl->getStorageBus();
-        ctl.ulInstance = pCtl->getInstance();
-        ctl.fBootable = pCtl->getBootable();
-
-        /* Save the port count. */
-        ULONG portCount;
-        rc = pCtl->COMGETTER(PortCount)(&portCount);
-        ComAssertComRCRet(rc, rc);
-        ctl.ulPortCount = portCount;
-
-        /* Save fUseHostIOCache */
-        BOOL fUseHostIOCache;
-        rc = pCtl->COMGETTER(UseHostIOCache)(&fUseHostIOCache);
-        ComAssertComRCRet(rc, rc);
-        ctl.fUseHostIOCache = !!fUseHostIOCache;
-
-        /* Save IDE emulation settings. */
-        if (ctl.controllerType == StorageControllerType_IntelAhci)
-        {
-            if (    (FAILED(rc = pCtl->getIDEEmulationPort(0, (LONG*)&ctl.lIDE0MasterEmulationPort)))
-                 || (FAILED(rc = pCtl->getIDEEmulationPort(1, (LONG*)&ctl.lIDE0SlaveEmulationPort)))
-                 || (FAILED(rc = pCtl->getIDEEmulationPort(2, (LONG*)&ctl.lIDE1MasterEmulationPort)))
-                 || (FAILED(rc = pCtl->getIDEEmulationPort(3, (LONG*)&ctl.lIDE1SlaveEmulationPort)))
-               )
-                ComAssertComRCRet(rc, rc);
-        }
-
-        /* save the devices now. */
-        rc = saveStorageDevices(pCtl, ctl);
-        ComAssertComRCRet(rc, rc);
-
-        data.llStorageControllers.push_back(ctl);
-    }
-
-    return S_OK;
-}
-
-/**
- *  Saves the hard disk configuration.
- */
-HRESULT Machine::saveStorageDevices(ComObjPtr<StorageController> aStorageController,
-                                    settings::StorageController &data)
-{
-    MediaData::AttachmentList atts;
-
-    HRESULT rc = getMediumAttachmentsOfController(Bstr(aStorageController->getName()).raw(), atts);
-    if (FAILED(rc)) return rc;
-
-    data.llAttachedDevices.clear();
-    for (MediaData::AttachmentList::const_iterator it = atts.begin();
-         it != atts.end();
-         ++it)
-    {
-        settings::AttachedDevice dev;
-
-        MediumAttachment *pAttach = *it;
-        Medium *pMedium = pAttach->getMedium();
-
-        dev.deviceType = pAttach->getType();
-        dev.lPort = pAttach->getPort();
-        dev.lDevice = pAttach->getDevice();
-        if (pMedium)
-        {
-            if (pMedium->isHostDrive())
-                dev.strHostDriveSrc = pMedium->getLocationFull();
-            else
-                dev.uuid = pMedium->getId();
-            dev.fPassThrough = pAttach->getPassthrough();
-            dev.fTempEject = pAttach->getTempEject();
-            dev.fNonRotational = pAttach->getNonRotational();
-            dev.fDiscard = pAttach->getDiscard();
-        }
-
-        dev.strBwGroup = pAttach->getBandwidthGroup();
-
-        data.llAttachedDevices.push_back(dev);
-    }
-
-    return S_OK;
-}
-
-/**
- *  Saves machine state settings as defined by aFlags
- *  (SaveSTS_* values).
- *
- *  @param aFlags   Combination of SaveSTS_* flags.
- *
- *  @note Locks objects for writing.
- */
-HRESULT Machine::saveStateSettings(int aFlags)
-{
-    if (aFlags == 0)
-        return S_OK;
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    /* This object's write lock is also necessary to serialize file access
-     * (prevent concurrent reads and writes) */
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-
-    Assert(mData->pMachineConfigFile);
-
-    try
-    {
-        if (aFlags & SaveSTS_CurStateModified)
-            mData->pMachineConfigFile->fCurrentStateModified = true;
-
-        if (aFlags & SaveSTS_StateFilePath)
-        {
-            if (!mSSData->strStateFilePath.isEmpty())
-                /* try to make the file name relative to the settings file dir */
-                copyPathRelativeToMachine(mSSData->strStateFilePath, mData->pMachineConfigFile->strStateFile);
-            else
-                mData->pMachineConfigFile->strStateFile.setNull();
-        }
-
-        if (aFlags & SaveSTS_StateTimeStamp)
-        {
-            Assert(    mData->mMachineState != MachineState_Aborted
-                    || mSSData->strStateFilePath.isEmpty());
-
-            mData->pMachineConfigFile->timeLastStateChange = mData->mLastStateChange;
-
-            mData->pMachineConfigFile->fAborted = (mData->mMachineState == MachineState_Aborted);
-//@todo live migration             mData->pMachineConfigFile->fTeleported = (mData->mMachineState == MachineState_Teleported);
-        }
-
-        mData->pMachineConfigFile->write(mData->m_strConfigFileFull);
-    }
-    catch (...)
-    {
-        rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-
-    return rc;
-}
-
-/**
- * Ensures that the given medium is added to a media registry. If this machine
- * was created with 4.0 or later, then the machine registry is used. Otherwise
- * the global VirtualBox media registry is used.
- *
- * Caller must NOT hold machine lock, media tree or any medium locks!
- *
- * @param pMedium
- */
-void Machine::addMediumToRegistry(ComObjPtr<Medium> &pMedium)
-{
-    /* Paranoia checks: do not hold machine or media tree locks. */
-    AssertReturnVoid(!isWriteLockOnCurrentThread());
-    AssertReturnVoid(!mParent->getMediaTreeLockHandle().isWriteLockOnCurrentThread());
-
-    ComObjPtr<Medium> pBase;
-    {
-        AutoReadLock treeLock(&mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-        pBase = pMedium->getBase();
-    }
-
-    /* Paranoia checks: do not hold medium locks. */
-    AssertReturnVoid(!pMedium->isWriteLockOnCurrentThread());
-    AssertReturnVoid(!pBase->isWriteLockOnCurrentThread());
-
-    // decide which medium registry to use now that the medium is attached:
-    Guid uuid;
-    if (mData->pMachineConfigFile->canHaveOwnMediaRegistry())
-        // machine XML is VirtualBox 4.0 or higher:
-        uuid = getId();     // machine UUID
-    else
-        uuid = mParent->getGlobalRegistryId(); // VirtualBox global registry UUID
-
-    if (pMedium->addRegistry(uuid, false /* fRecurse */))
-        mParent->markRegistryModified(uuid);
-
-    /* For more complex hard disk structures it can happen that the base
-     * medium isn't yet associated with any medium registry. Do that now. */
-    if (pMedium != pBase)
-    {
-        if (pBase->addRegistry(uuid, true /* fRecurse */))
-            mParent->markRegistryModified(uuid);
-    }
-}
-
-/**
- * Creates differencing hard disks for all normal hard disks attached to this
- * machine and a new set of attachments to refer to created disks.
- *
- * Used when taking a snapshot or when deleting the current state. Gets called
- * from SessionMachine::BeginTakingSnapshot() and SessionMachine::restoreSnapshotHandler().
- *
- * This method assumes that mMediaData contains the original hard disk attachments
- * it needs to create diffs for. On success, these attachments will be replaced
- * with the created diffs. On failure, #deleteImplicitDiffs() is implicitly
- * called to delete created diffs which will also rollback mMediaData and restore
- * whatever was backed up before calling this method.
- *
- * Attachments with non-normal hard disks are left as is.
- *
- * If @a aOnline is @c false then the original hard disks that require implicit
- * diffs will be locked for reading. Otherwise it is assumed that they are
- * already locked for writing (when the VM was started). Note that in the latter
- * case it is responsibility of the caller to lock the newly created diffs for
- * writing if this method succeeds.
- *
- * @param aProgress         Progress object to run (must contain at least as
- *                          many operations left as the number of hard disks
- *                          attached).
- * @param aOnline           Whether the VM was online prior to this operation.
- *
- * @note The progress object is not marked as completed, neither on success nor
- *       on failure. This is a responsibility of the caller.
- *
- * @note Locks this object and the media tree for writing.
- */
-HRESULT Machine::createImplicitDiffs(IProgress *aProgress,
-                                     ULONG aWeight,
-                                     bool aOnline)
-{
-    LogFlowThisFunc(("aOnline=%d\n", aOnline));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoMultiWriteLock2 alock(this->lockHandle(),
-                              &mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    /* must be in a protective state because we release the lock below */
-    AssertReturn(   mData->mMachineState == MachineState_Saving
-                 || mData->mMachineState == MachineState_LiveSnapshotting
-                 || mData->mMachineState == MachineState_RestoringSnapshot
-                 || mData->mMachineState == MachineState_DeletingSnapshot
-                 , E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    // use appropriate locked media map (online or offline)
-    MediumLockListMap lockedMediaOffline;
-    MediumLockListMap *lockedMediaMap;
-    if (aOnline)
-        lockedMediaMap = &mData->mSession.mLockedMedia;
-    else
-        lockedMediaMap = &lockedMediaOffline;
-
-    try
-    {
-        if (!aOnline)
-        {
-            /* lock all attached hard disks early to detect "in use"
-             * situations before creating actual diffs */
-            for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-                 it != mMediaData->mAttachments.end();
-                 ++it)
-            {
-                MediumAttachment* pAtt = *it;
-                if (pAtt->getType() == DeviceType_HardDisk)
-                {
-                    Medium* pMedium = pAtt->getMedium();
-                    Assert(pMedium);
-
-                    MediumLockList *pMediumLockList(new MediumLockList());
-                    alock.release();
-                    rc = pMedium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                       false /* fMediumLockWrite */,
-                                                       NULL,
-                                                       *pMediumLockList);
-                    alock.acquire();
-                    if (FAILED(rc))
-                    {
-                        delete pMediumLockList;
-                        throw rc;
-                    }
-                    rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
-                    if (FAILED(rc))
-                    {
-                        throw setError(rc,
-                                       tr("Collecting locking information for all attached media failed"));
-                    }
-                }
-            }
-
-            /* Now lock all media. If this fails, nothing is locked. */
-            alock.release();
-            rc = lockedMediaMap->Lock();
-            alock.acquire();
-            if (FAILED(rc))
-            {
-                throw setError(rc,
-                               tr("Locking of attached media failed"));
-            }
-        }
-
-        /* remember the current list (note that we don't use backup() since
-         * mMediaData may be already backed up) */
-        MediaData::AttachmentList atts = mMediaData->mAttachments;
-
-        /* start from scratch */
-        mMediaData->mAttachments.clear();
-
-        /* go through remembered attachments and create diffs for normal hard
-         * disks and attach them */
-        for (MediaData::AttachmentList::const_iterator it = atts.begin();
-             it != atts.end();
-             ++it)
-        {
-            MediumAttachment* pAtt = *it;
-
-            DeviceType_T devType = pAtt->getType();
-            Medium* pMedium = pAtt->getMedium();
-
-            if (   devType != DeviceType_HardDisk
-                || pMedium == NULL
-                || pMedium->getType() != MediumType_Normal)
-            {
-                /* copy the attachment as is */
-
-                /** @todo the progress object created in Console::TakeSnaphot
-                 * only expects operations for hard disks. Later other
-                 * device types need to show up in the progress as well. */
-                if (devType == DeviceType_HardDisk)
-                {
-                    if (pMedium == NULL)
-                        aProgress->SetNextOperation(Bstr(tr("Skipping attachment without medium")).raw(),
-                                                    aWeight);        // weight
-                    else
-                        aProgress->SetNextOperation(BstrFmt(tr("Skipping medium '%s'"),
-                                                            pMedium->getBase()->getName().c_str()).raw(),
-                                                    aWeight);        // weight
-                }
-
-                mMediaData->mAttachments.push_back(pAtt);
-                continue;
-            }
-
-            /* need a diff */
-            aProgress->SetNextOperation(BstrFmt(tr("Creating differencing hard disk for '%s'"),
-                                                pMedium->getBase()->getName().c_str()).raw(),
-                                        aWeight);        // weight
-
-            Utf8Str strFullSnapshotFolder;
-            calculateFullPath(mUserData->s.strSnapshotFolder, strFullSnapshotFolder);
-
-            ComObjPtr<Medium> diff;
-            diff.createObject();
-            // store the diff in the same registry as the parent
-            // (this cannot fail here because we can't create implicit diffs for
-            // unregistered images)
-            Guid uuidRegistryParent;
-            bool fInRegistry = pMedium->getFirstRegistryMachineId(uuidRegistryParent);
-            Assert(fInRegistry); NOREF(fInRegistry);
-            rc = diff->init(mParent,
-                            pMedium->getPreferredDiffFormat(),
-                            strFullSnapshotFolder.append(RTPATH_SLASH_STR),
-                            uuidRegistryParent);
-            if (FAILED(rc)) throw rc;
-
-            /** @todo r=bird: How is the locking and diff image cleaned up if we fail before
-             *        the push_back?  Looks like we're going to release medium with the
-             *        wrong kind of lock (general issue with if we fail anywhere at all)
-             *        and an orphaned VDI in the snapshots folder. */
-
-            /* update the appropriate lock list */
-            MediumLockList *pMediumLockList;
-            rc = lockedMediaMap->Get(pAtt, pMediumLockList);
-            AssertComRCThrowRC(rc);
-            if (aOnline)
-            {
-                alock.release();
-                /* The currently attached medium will be read-only, change
-                 * the lock type to read. */
-                rc = pMediumLockList->Update(pMedium, false);
-                alock.acquire();
-                AssertComRCThrowRC(rc);
-            }
-
-            /* release the locks before the potentially lengthy operation */
-            alock.release();
-            rc = pMedium->createDiffStorage(diff, MediumVariant_Standard,
-                                            pMediumLockList,
-                                            NULL /* aProgress */,
-                                            true /* aWait */);
-            alock.acquire();
-            if (FAILED(rc)) throw rc;
-
-            /* actual lock list update is done in Medium::commitMedia */
-
-            rc = diff->addBackReference(mData->mUuid);
-            AssertComRCThrowRC(rc);
-
-            /* add a new attachment */
-            ComObjPtr<MediumAttachment> attachment;
-            attachment.createObject();
-            rc = attachment->init(this,
-                                  diff,
-                                  pAtt->getControllerName(),
-                                  pAtt->getPort(),
-                                  pAtt->getDevice(),
-                                  DeviceType_HardDisk,
-                                  true /* aImplicit */,
-                                  false /* aPassthrough */,
-                                  false /* aTempEject */,
-                                  pAtt->getNonRotational(),
-                                  pAtt->getDiscard(),
-                                  pAtt->getBandwidthGroup());
-            if (FAILED(rc)) throw rc;
-
-            rc = lockedMediaMap->ReplaceKey(pAtt, attachment);
-            AssertComRCThrowRC(rc);
-            mMediaData->mAttachments.push_back(attachment);
-        }
-    }
-    catch (HRESULT aRC) { rc = aRC; }
-
-    /* unlock all hard disks we locked when there is no VM */
-    if (!aOnline)
-    {
-        ErrorInfoKeeper eik;
-
-        HRESULT rc1 = lockedMediaMap->Clear();
-        AssertComRC(rc1);
-    }
-
-    return rc;
-}
-
-/**
- * Deletes implicit differencing hard disks created either by
- * #createImplicitDiffs() or by #AttachDevice() and rolls back mMediaData.
- *
- * Note that to delete hard disks created by #AttachDevice() this method is
- * called from #fixupMedia() when the changes are rolled back.
- *
- * @note Locks this object and the media tree for writing.
- */
-HRESULT Machine::deleteImplicitDiffs(bool aOnline)
-{
-    LogFlowThisFunc(("aOnline=%d\n", aOnline));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoMultiWriteLock2 alock(this->lockHandle(),
-                              &mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    /* We absolutely must have backed up state. */
-    AssertReturn(mMediaData.isBackedUp(), E_FAIL);
-
-    /* Check if there are any implicitly created diff images. */
-    bool fImplicitDiffs = false;
-    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-         it != mMediaData->mAttachments.end();
-         ++it)
-    {
-        const ComObjPtr<MediumAttachment> &pAtt = *it;
-        if (pAtt->isImplicit())
-        {
-            fImplicitDiffs = true;
-            break;
-        }
-    }
-    /* If there is nothing to do, leave early. This saves lots of image locking
-     * effort. It also avoids a MachineStateChanged event without real reason.
-     * This is important e.g. when loading a VM config, because there should be
-     * no events. Otherwise API clients can become thoroughly confused for
-     * inaccessible VMs (the code for loading VM configs uses this method for
-     * cleanup if the config makes no sense), as they take such events as an
-     * indication that the VM is alive, and they would force the VM config to
-     * be reread, leading to an endless loop. */
-    if (!fImplicitDiffs)
-        return S_OK;
-
-    HRESULT rc = S_OK;
-    MachineState_T oldState = mData->mMachineState;
-
-    /* will release the lock before the potentially lengthy operation,
-     * so protect with the special state (unless already protected) */
-    if (   oldState != MachineState_Saving
-        && oldState != MachineState_LiveSnapshotting
-        && oldState != MachineState_RestoringSnapshot
-        && oldState != MachineState_DeletingSnapshot
-        && oldState != MachineState_DeletingSnapshotOnline
-        && oldState != MachineState_DeletingSnapshotPaused
-       )
-        setMachineState(MachineState_SettingUp);
-
-    // use appropriate locked media map (online or offline)
-    MediumLockListMap lockedMediaOffline;
-    MediumLockListMap *lockedMediaMap;
-    if (aOnline)
-        lockedMediaMap = &mData->mSession.mLockedMedia;
-    else
-        lockedMediaMap = &lockedMediaOffline;
-
-    try
-    {
-        if (!aOnline)
-        {
-            /* lock all attached hard disks early to detect "in use"
-             * situations before deleting actual diffs */
-            for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-               it != mMediaData->mAttachments.end();
-               ++it)
-            {
-                MediumAttachment* pAtt = *it;
-                if (pAtt->getType() == DeviceType_HardDisk)
-                {
-                    Medium* pMedium = pAtt->getMedium();
-                    Assert(pMedium);
-
-                    MediumLockList *pMediumLockList(new MediumLockList());
-                    alock.release();
-                    rc = pMedium->createMediumLockList(true /* fFailIfInaccessible */,
-                                                       false /* fMediumLockWrite */,
-                                                       NULL,
-                                                       *pMediumLockList);
-                    alock.acquire();
-
-                    if (FAILED(rc))
-                    {
-                        delete pMediumLockList;
-                        throw rc;
-                    }
-
-                    rc = lockedMediaMap->Insert(pAtt, pMediumLockList);
-                    if (FAILED(rc))
-                        throw rc;
-                }
-            }
-
-            if (FAILED(rc))
-                throw rc;
-        } // end of offline
-
-        /* Lock lists are now up to date and include implicitly created media */
-
-        /* Go through remembered attachments and delete all implicitly created
-         * diffs and fix up the attachment information */
-        const MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
-        MediaData::AttachmentList implicitAtts;
-        for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-             it != mMediaData->mAttachments.end();
-             ++it)
-        {
-            ComObjPtr<MediumAttachment> pAtt = *it;
-            ComObjPtr<Medium> pMedium = pAtt->getMedium();
-            if (pMedium.isNull())
-                continue;
-
-            // Implicit attachments go on the list for deletion and back references are removed.
-            if (pAtt->isImplicit())
-            {
-                /* Deassociate and mark for deletion */
-                LogFlowThisFunc(("Detaching '%s', pending deletion\n", pAtt->getLogName()));
-                rc = pMedium->removeBackReference(mData->mUuid);
-                if (FAILED(rc))
-                   throw rc;
-                implicitAtts.push_back(pAtt);
-                continue;
-            }
-
-            /* Was this medium attached before? */
-            if (!findAttachment(oldAtts, pMedium))
-            {
-                /* no: de-associate */
-                LogFlowThisFunc(("Detaching '%s', no deletion\n", pAtt->getLogName()));
-                rc = pMedium->removeBackReference(mData->mUuid);
-                if (FAILED(rc))
-                    throw rc;
-                continue;
-            }
-            LogFlowThisFunc(("Not detaching '%s'\n", pAtt->getLogName()));
-        }
-
-        /* If there are implicit attachments to delete, throw away the lock
-         * map contents (which will unlock all media) since the medium
-         * attachments will be rolled back. Below we need to completely
-         * recreate the lock map anyway since it is infinitely complex to
-         * do this incrementally (would need reconstructing each attachment
-         * change, which would be extremely hairy). */
-        if (implicitAtts.size() != 0)
-        {
-            ErrorInfoKeeper eik;
-
-            HRESULT rc1 = lockedMediaMap->Clear();
-            AssertComRC(rc1);
-        }
-
-        /* rollback hard disk changes */
-        mMediaData.rollback();
-
-        MultiResult mrc(S_OK);
-
-        // Delete unused implicit diffs.
-        if (implicitAtts.size() != 0)
-        {
-            alock.release();
-
-            for (MediaData::AttachmentList::const_iterator it = implicitAtts.begin();
-                 it != implicitAtts.end();
-                 ++it)
-            {
-                // Remove medium associated with this attachment.
-                ComObjPtr<MediumAttachment> pAtt = *it;
-                Assert(pAtt);
-                LogFlowThisFunc(("Deleting '%s'\n", pAtt->getLogName()));
-                ComObjPtr<Medium> pMedium = pAtt->getMedium();
-                Assert(pMedium);
-
-                rc = pMedium->deleteStorage(NULL /*aProgress*/, true /*aWait*/);
-                // continue on delete failure, just collect error messages
-                AssertMsg(SUCCEEDED(rc), ("rc=%Rhrc it=%s hd=%s\n", rc, pAtt->getLogName(), pMedium->getLocationFull().c_str() ));
-                mrc = rc;
-            }
-
-            alock.acquire();
-
-            /* if there is a VM recreate media lock map as mentioned above,
-             * otherwise it is a waste of time and we leave things unlocked */
-            if (aOnline)
-            {
-                const ComObjPtr<SessionMachine> pMachine = mData->mSession.mMachine;
-                /* must never be NULL, but better safe than sorry */
-                if (!pMachine.isNull())
-                {
-                    alock.release();
-                    rc = mData->mSession.mMachine->lockMedia();
-                    alock.acquire();
-                    if (FAILED(rc))
-                        throw rc;
-                }
-            }
-        }
-    }
-    catch (HRESULT aRC) {rc = aRC;}
-
-    if (mData->mMachineState == MachineState_SettingUp)
-        setMachineState(oldState);
-
-    /* unlock all hard disks we locked when there is no VM */
-    if (!aOnline)
-    {
-        ErrorInfoKeeper eik;
-
-        HRESULT rc1 = lockedMediaMap->Clear();
-        AssertComRC(rc1);
-    }
-
-    return rc;
-}
-
-
-/**
- * Looks through the given list of media attachments for one with the given parameters
- * and returns it, or NULL if not found. The list is a parameter so that backup lists
- * can be searched as well if needed.
- *
- * @param list
- * @param aControllerName
- * @param aControllerPort
- * @param aDevice
- * @return
- */
-MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
-                                          IN_BSTR aControllerName,
-                                          LONG aControllerPort,
-                                          LONG aDevice)
-{
-   for (MediaData::AttachmentList::const_iterator it = ll.begin();
-        it != ll.end();
-        ++it)
-    {
-        MediumAttachment *pAttach = *it;
-        if (pAttach->matches(aControllerName, aControllerPort, aDevice))
-            return pAttach;
-    }
-
-    return NULL;
-}
-
-/**
- * Looks through the given list of media attachments for one with the given parameters
- * and returns it, or NULL if not found. The list is a parameter so that backup lists
- * can be searched as well if needed.
- *
- * @param list
- * @param aControllerName
- * @param aControllerPort
- * @param aDevice
- * @return
- */
-MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
-                                          ComObjPtr<Medium> pMedium)
-{
-   for (MediaData::AttachmentList::const_iterator it = ll.begin();
-        it != ll.end();
-        ++it)
-    {
-        MediumAttachment *pAttach = *it;
-        ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
-        if (pMediumThis == pMedium)
-            return pAttach;
-    }
-
-    return NULL;
-}
-
-/**
- * Looks through the given list of media attachments for one with the given parameters
- * and returns it, or NULL if not found. The list is a parameter so that backup lists
- * can be searched as well if needed.
- *
- * @param list
- * @param aControllerName
- * @param aControllerPort
- * @param aDevice
- * @return
- */
-MediumAttachment* Machine::findAttachment(const MediaData::AttachmentList &ll,
-                                          Guid &id)
-{
-   for (MediaData::AttachmentList::const_iterator it = ll.begin();
-         it != ll.end();
-         ++it)
-    {
-        MediumAttachment *pAttach = *it;
-        ComObjPtr<Medium> pMediumThis = pAttach->getMedium();
-        if (pMediumThis->getId() == id)
-            return pAttach;
-    }
-
-    return NULL;
-}
-
-/**
- * Main implementation for Machine::DetachDevice. This also gets called
- * from Machine::prepareUnregister() so it has been taken out for simplicity.
- *
- * @param pAttach Medium attachment to detach.
- * @param writeLock Machine write lock which the caller must have locked once. This may be released temporarily in here.
- * @param pSnapshot If NULL, then the detachment is for the current machine. Otherwise this is for a SnapshotMachine, and this must be its snapshot.
- * @return
- */
-HRESULT Machine::detachDevice(MediumAttachment *pAttach,
-                              AutoWriteLock &writeLock,
-                              Snapshot *pSnapshot)
-{
-    ComObjPtr<Medium> oldmedium = pAttach->getMedium();
-    DeviceType_T mediumType = pAttach->getType();
-
-    LogFlowThisFunc(("Entering, medium of attachment is %s\n", oldmedium ? oldmedium->getLocationFull().c_str() : "NULL"));
-
-    if (pAttach->isImplicit())
-    {
-        /* attempt to implicitly delete the implicitly created diff */
-
-        /// @todo move the implicit flag from MediumAttachment to Medium
-        /// and forbid any hard disk operation when it is implicit. Or maybe
-        /// a special media state for it to make it even more simple.
-
-        Assert(mMediaData.isBackedUp());
-
-        /* will release the lock before the potentially lengthy operation, so
-         * protect with the special state */
-        MachineState_T oldState = mData->mMachineState;
-        setMachineState(MachineState_SettingUp);
-
-        writeLock.release();
-
-        HRESULT rc = oldmedium->deleteStorage(NULL /*aProgress*/,
-                                              true /*aWait*/);
-
-        writeLock.acquire();
-
-        setMachineState(oldState);
-
-        if (FAILED(rc)) return rc;
-    }
-
-    setModified(IsModified_Storage);
-    mMediaData.backup();
-    mMediaData->mAttachments.remove(pAttach);
-
-    if (!oldmedium.isNull())
-    {
-        // if this is from a snapshot, do not defer detachment to commitMedia()
-        if (pSnapshot)
-            oldmedium->removeBackReference(mData->mUuid, pSnapshot->getId());
-        // else if non-hard disk media, do not defer detachment to commitMedia() either
-        else if (mediumType != DeviceType_HardDisk)
-            oldmedium->removeBackReference(mData->mUuid);
-    }
-
-    return S_OK;
-}
-
-/**
- * Goes thru all media of the given list and
- *
- * 1) calls detachDevice() on each of them for this machine and
- * 2) adds all Medium objects found in the process to the given list,
- *    depending on cleanupMode.
- *
- * If cleanupMode is CleanupMode_DetachAllReturnHardDisksOnly, this only
- * adds hard disks to the list. If it is CleanupMode_Full, this adds all
- * media to the list.
- *
- * This gets called from Machine::Unregister, both for the actual Machine and
- * the SnapshotMachine objects that might be found in the snapshots.
- *
- * Requires caller and locking. The machine lock must be passed in because it
- * will be passed on to detachDevice which needs it for temporary unlocking.
- *
- * @param writeLock Machine lock from top-level caller; this gets passed to detachDevice.
- * @param pSnapshot Must be NULL when called for a "real" Machine or a snapshot object if called for a SnapshotMachine.
- * @param cleanupMode If DetachAllReturnHardDisksOnly, only hard disk media get added to llMedia; if Full, then all media get added;
- *          otherwise no media get added.
- * @param llMedia Caller's list to receive Medium objects which got detached so caller can close() them, depending on cleanupMode.
- * @return
- */
-HRESULT Machine::detachAllMedia(AutoWriteLock &writeLock,
-                                Snapshot *pSnapshot,
-                                CleanupMode_T cleanupMode,
-                                MediaList &llMedia)
-{
-    Assert(isWriteLockOnCurrentThread());
-
-    HRESULT rc;
-
-    // make a temporary list because detachDevice invalidates iterators into
-    // mMediaData->mAttachments
-    MediaData::AttachmentList llAttachments2 = mMediaData->mAttachments;
-
-    for (MediaData::AttachmentList::iterator it = llAttachments2.begin();
-         it != llAttachments2.end();
-         ++it)
-    {
-        ComObjPtr<MediumAttachment> &pAttach = *it;
-        ComObjPtr<Medium> pMedium = pAttach->getMedium();
-
-        if (!pMedium.isNull())
-        {
-            AutoCaller mac(pMedium);
-            if (FAILED(mac.rc())) return mac.rc();
-            AutoReadLock lock(pMedium COMMA_LOCKVAL_SRC_POS);
-            DeviceType_T devType = pMedium->getDeviceType();
-            if (    (    cleanupMode == CleanupMode_DetachAllReturnHardDisksOnly
-                      && devType == DeviceType_HardDisk)
-                 || (cleanupMode == CleanupMode_Full)
-               )
-            {
-                llMedia.push_back(pMedium);
-                ComObjPtr<Medium> pParent = pMedium->getParent();
-                /*
-                 * Search for medias which are not attached to any machine, but
-                 * in the chain to an attached disk. Mediums are only consided
-                 * if they are:
-                 * - have only one child
-                 * - no references to any machines
-                 * - are of normal medium type
-                 */
-                while (!pParent.isNull())
-                {
-                    AutoCaller mac1(pParent);
-                    if (FAILED(mac1.rc())) return mac1.rc();
-                    AutoReadLock lock1(pParent COMMA_LOCKVAL_SRC_POS);
-                    if (pParent->getChildren().size() == 1)
-                    {
-                        if (   pParent->getMachineBackRefCount() == 0
-                            && pParent->getType() == MediumType_Normal
-                            && find(llMedia.begin(), llMedia.end(), pParent) == llMedia.end())
-                            llMedia.push_back(pParent);
-                    }
-                    else
-                        break;
-                    pParent = pParent->getParent();
-                }
-            }
-        }
-
-        // real machine: then we need to use the proper method
-        rc = detachDevice(pAttach, writeLock, pSnapshot);
-
-        if (FAILED(rc))
-            return rc;
-    }
-
-    return S_OK;
-}
-
-/**
- * Perform deferred hard disk detachments.
- *
- * Does nothing if the hard disk attachment data (mMediaData) is not changed (not
- * backed up).
- *
- * If @a aOnline is @c true then this method will also unlock the old hard disks
- * for which the new implicit diffs were created and will lock these new diffs for
- * writing.
- *
- * @param aOnline       Whether the VM was online prior to this operation.
- *
- * @note Locks this object for writing!
- */
-void Machine::commitMedia(bool aOnline /*= false*/)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    LogFlowThisFunc(("Entering, aOnline=%d\n", aOnline));
-
-    HRESULT rc = S_OK;
-
-    /* no attach/detach operations -- nothing to do */
-    if (!mMediaData.isBackedUp())
-        return;
-
-    MediaData::AttachmentList &oldAtts = mMediaData.backedUpData()->mAttachments;
-    bool fMediaNeedsLocking = false;
-
-    /* enumerate new attachments */
-    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-         it != mMediaData->mAttachments.end();
-         ++it)
-    {
-        MediumAttachment *pAttach = *it;
-
-        pAttach->commit();
-
-        Medium* pMedium = pAttach->getMedium();
-        bool fImplicit = pAttach->isImplicit();
-
-        LogFlowThisFunc(("Examining current medium '%s' (implicit: %d)\n",
-                         (pMedium) ? pMedium->getName().c_str() : "NULL",
-                         fImplicit));
-
-        /** @todo convert all this Machine-based voodoo to MediumAttachment
-         * based commit logic. */
-        if (fImplicit)
-        {
-            /* convert implicit attachment to normal */
-            pAttach->setImplicit(false);
-
-            if (    aOnline
-                 && pMedium
-                 && pAttach->getType() == DeviceType_HardDisk
-               )
-            {
-                ComObjPtr<Medium> parent = pMedium->getParent();
-                AutoWriteLock parentLock(parent COMMA_LOCKVAL_SRC_POS);
-
-                /* update the appropriate lock list */
-                MediumLockList *pMediumLockList;
-                rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
-                AssertComRC(rc);
-                if (pMediumLockList)
-                {
-                    /* unlock if there's a need to change the locking */
-                    if (!fMediaNeedsLocking)
-                    {
-                        rc = mData->mSession.mLockedMedia.Unlock();
-                        AssertComRC(rc);
-                        fMediaNeedsLocking = true;
-                    }
-                    rc = pMediumLockList->Update(parent, false);
-                    AssertComRC(rc);
-                    rc = pMediumLockList->Append(pMedium, true);
-                    AssertComRC(rc);
-                }
-            }
-
-            continue;
-        }
-
-        if (pMedium)
-        {
-            /* was this medium attached before? */
-            for (MediaData::AttachmentList::iterator oldIt = oldAtts.begin();
-                 oldIt != oldAtts.end();
-                 ++oldIt)
-            {
-                MediumAttachment *pOldAttach = *oldIt;
-                if (pOldAttach->getMedium() == pMedium)
-                {
-                    LogFlowThisFunc(("--> medium '%s' was attached before, will not remove\n", pMedium->getName().c_str()));
-
-                    /* yes: remove from old to avoid de-association */
-                    oldAtts.erase(oldIt);
-                    break;
-                }
-            }
-        }
-    }
-
-    /* enumerate remaining old attachments and de-associate from the
-     * current machine state */
-    for (MediaData::AttachmentList::const_iterator it = oldAtts.begin();
-         it != oldAtts.end();
-         ++it)
-    {
-        MediumAttachment *pAttach = *it;
-        Medium* pMedium = pAttach->getMedium();
-
-        /* Detach only hard disks, since DVD/floppy media is detached
-         * instantly in MountMedium. */
-        if (pAttach->getType() == DeviceType_HardDisk && pMedium)
-        {
-            LogFlowThisFunc(("detaching medium '%s' from machine\n", pMedium->getName().c_str()));
-
-            /* now de-associate from the current machine state */
-            rc = pMedium->removeBackReference(mData->mUuid);
-            AssertComRC(rc);
-
-            if (aOnline)
-            {
-                /* unlock since medium is not used anymore */
-                MediumLockList *pMediumLockList;
-                rc = mData->mSession.mLockedMedia.Get(pAttach, pMediumLockList);
-                if (RT_UNLIKELY(rc == VBOX_E_INVALID_OBJECT_STATE))
-                {
-                    /* this happens for online snapshots, there the attachment
-                     * is changing, but only to a diff image created under
-                     * the old one, so there is no separate lock list */
-                    Assert(!pMediumLockList);
-                }
-                else
-                {
-                    AssertComRC(rc);
-                    if (pMediumLockList)
-                    {
-                        rc = mData->mSession.mLockedMedia.Remove(pAttach);
-                        AssertComRC(rc);
-                    }
-                }
-            }
-        }
-    }
-
-    /* take media locks again so that the locking state is consistent */
-    if (fMediaNeedsLocking)
-    {
-        Assert(aOnline);
-        rc = mData->mSession.mLockedMedia.Lock();
-        AssertComRC(rc);
-    }
-
-    /* commit the hard disk changes */
-    mMediaData.commit();
-
-    if (isSessionMachine())
-    {
-        /*
-         * Update the parent machine to point to the new owner.
-         * This is necessary because the stored parent will point to the
-         * session machine otherwise and cause crashes or errors later
-         * when the session machine gets invalid.
-         */
-        /** @todo Change the MediumAttachment class to behave like any other
-         *        class in this regard by creating peer MediumAttachment
-         *        objects for session machines and share the data with the peer
-         *        machine.
-         */
-        for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-             it != mMediaData->mAttachments.end();
-             ++it)
-        {
-            (*it)->updateParentMachine(mPeer);
-        }
-
-        /* attach new data to the primary machine and reshare it */
-        mPeer->mMediaData.attach(mMediaData);
-    }
-
-    return;
-}
-
-/**
- * Perform deferred deletion of implicitly created diffs.
- *
- * Does nothing if the hard disk attachment data (mMediaData) is not changed (not
- * backed up).
- *
- * @note Locks this object for writing!
- */
-void Machine::rollbackMedia()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    // AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    LogFlowThisFunc(("Entering rollbackMedia\n"));
-
-    HRESULT rc = S_OK;
-
-    /* no attach/detach operations -- nothing to do */
-    if (!mMediaData.isBackedUp())
-        return;
-
-    /* enumerate new attachments */
-    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-         it != mMediaData->mAttachments.end();
-         ++it)
-    {
-        MediumAttachment *pAttach = *it;
-        /* Fix up the backrefs for DVD/floppy media. */
-        if (pAttach->getType() != DeviceType_HardDisk)
-        {
-            Medium* pMedium = pAttach->getMedium();
-            if (pMedium)
-            {
-                rc = pMedium->removeBackReference(mData->mUuid);
-                AssertComRC(rc);
-            }
-        }
-
-        (*it)->rollback();
-
-        pAttach = *it;
-        /* Fix up the backrefs for DVD/floppy media. */
-        if (pAttach->getType() != DeviceType_HardDisk)
-        {
-            Medium* pMedium = pAttach->getMedium();
-            if (pMedium)
-            {
-                rc = pMedium->addBackReference(mData->mUuid);
-                AssertComRC(rc);
-            }
-        }
-    }
-
-    /** @todo convert all this Machine-based voodoo to MediumAttachment
-     * based rollback logic. */
-    deleteImplicitDiffs(Global::IsOnline(mData->mMachineState));
-
-    return;
-}
-
-/**
- *  Returns true if the settings file is located in the directory named exactly
- *  as the machine; this means, among other things, that the machine directory
- *  should be auto-renamed.
- *
- *  @param aSettingsDir if not NULL, the full machine settings file directory
- *                      name will be assigned there.
- *
- *  @note Doesn't lock anything.
- *  @note Not thread safe (must be called from this object's lock).
- */
-bool Machine::isInOwnDir(Utf8Str *aSettingsDir /* = NULL */) const
-{
-    Utf8Str strMachineDirName(mData->m_strConfigFileFull);  // path/to/machinesfolder/vmname/vmname.vbox
-    strMachineDirName.stripFilename();                      // path/to/machinesfolder/vmname
-    if (aSettingsDir)
-        *aSettingsDir = strMachineDirName;
-    strMachineDirName.stripPath();                          // vmname
-    Utf8Str strConfigFileOnly(mData->m_strConfigFileFull);  // path/to/machinesfolder/vmname/vmname.vbox
-    strConfigFileOnly.stripPath()                           // vmname.vbox
-                     .stripExt();                           // vmname
-    /** @todo hack, make somehow use of ComposeMachineFilename */
-    if (mUserData->s.fDirectoryIncludesUUID)
-        strConfigFileOnly += Utf8StrFmt(" (%RTuuid)", mData->mUuid.raw());
-
-    AssertReturn(!strMachineDirName.isEmpty(), false);
-    AssertReturn(!strConfigFileOnly.isEmpty(), false);
-
-    return strMachineDirName == strConfigFileOnly;
-}
-
-/**
- * Discards all changes to machine settings.
- *
- * @param aNotify   Whether to notify the direct session about changes or not.
- *
- * @note Locks objects for writing!
- */
-void Machine::rollback(bool aNotify)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), (void)0);
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (!mStorageControllers.isNull())
-    {
-        if (mStorageControllers.isBackedUp())
-        {
-            /* unitialize all new devices (absent in the backed up list). */
-            StorageControllerList::const_iterator it = mStorageControllers->begin();
-            StorageControllerList *backedList = mStorageControllers.backedUpData();
-            while (it != mStorageControllers->end())
-            {
-                if (   std::find(backedList->begin(), backedList->end(), *it)
-                    == backedList->end()
-                   )
-                {
-                    (*it)->uninit();
-                }
-                ++it;
-            }
-
-            /* restore the list */
-            mStorageControllers.rollback();
-        }
-
-        /* rollback any changes to devices after restoring the list */
-        if (mData->flModifications & IsModified_Storage)
-        {
-            StorageControllerList::const_iterator it = mStorageControllers->begin();
-            while (it != mStorageControllers->end())
-            {
-                (*it)->rollback();
-                ++it;
-            }
-        }
-    }
-
-    if (!mUSBControllers.isNull())
-    {
-        if (mUSBControllers.isBackedUp())
-        {
-            /* unitialize all new devices (absent in the backed up list). */
-            USBControllerList::const_iterator it = mUSBControllers->begin();
-            USBControllerList *backedList = mUSBControllers.backedUpData();
-            while (it != mUSBControllers->end())
-            {
-                if (   std::find(backedList->begin(), backedList->end(), *it)
-                    == backedList->end()
-                   )
-                {
-                    (*it)->uninit();
-                }
-                ++it;
-            }
-
-            /* restore the list */
-            mUSBControllers.rollback();
-        }
-
-        /* rollback any changes to devices after restoring the list */
-        if (mData->flModifications & IsModified_USB)
-        {
-            USBControllerList::const_iterator it = mUSBControllers->begin();
-            while (it != mUSBControllers->end())
-            {
-                (*it)->rollback();
-                ++it;
-            }
-        }
-    }
-
-    mUserData.rollback();
-
-    mHWData.rollback();
-
-    if (mData->flModifications & IsModified_Storage)
-        rollbackMedia();
-
-    if (mBIOSSettings)
-        mBIOSSettings->rollback();
-
-    if (mVRDEServer && (mData->flModifications & IsModified_VRDEServer))
-        mVRDEServer->rollback();
-
-    if (mAudioAdapter)
-        mAudioAdapter->rollback();
-
-    if (mUSBDeviceFilters && (mData->flModifications & IsModified_USB))
-        mUSBDeviceFilters->rollback();
-
-    if (mBandwidthControl && (mData->flModifications & IsModified_BandwidthControl))
-        mBandwidthControl->rollback();
-
-    if (!mHWData.isNull())
-        mNetworkAdapters.resize(Global::getMaxNetworkAdapters(mHWData->mChipsetType));
-    NetworkAdapterVector networkAdapters(mNetworkAdapters.size());
-    ComPtr<ISerialPort> serialPorts[RT_ELEMENTS(mSerialPorts)];
-    ComPtr<IParallelPort> parallelPorts[RT_ELEMENTS(mParallelPorts)];
-
-    if (mData->flModifications & IsModified_NetworkAdapters)
-        for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
-            if (    mNetworkAdapters[slot]
-                 && mNetworkAdapters[slot]->isModified())
-            {
-                mNetworkAdapters[slot]->rollback();
-                networkAdapters[slot] = mNetworkAdapters[slot];
-            }
-
-    if (mData->flModifications & IsModified_SerialPorts)
-        for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
-            if (    mSerialPorts[slot]
-                 && mSerialPorts[slot]->isModified())
-            {
-                mSerialPorts[slot]->rollback();
-                serialPorts[slot] = mSerialPorts[slot];
-            }
-
-    if (mData->flModifications & IsModified_ParallelPorts)
-        for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-            if (    mParallelPorts[slot]
-                 && mParallelPorts[slot]->isModified())
-            {
-                mParallelPorts[slot]->rollback();
-                parallelPorts[slot] = mParallelPorts[slot];
-            }
-
-    if (aNotify)
-    {
-        /* inform the direct session about changes */
-
-        ComObjPtr<Machine> that = this;
-        uint32_t flModifications = mData->flModifications;
-        alock.release();
-
-        if (flModifications & IsModified_SharedFolders)
-            that->onSharedFolderChange();
-
-        if (flModifications & IsModified_VRDEServer)
-            that->onVRDEServerChange(/* aRestart */ TRUE);
-        if (flModifications & IsModified_USB)
-            that->onUSBControllerChange();
-
-        for (ULONG slot = 0; slot < networkAdapters.size(); slot++)
-            if (networkAdapters[slot])
-                that->onNetworkAdapterChange(networkAdapters[slot], FALSE);
-        for (ULONG slot = 0; slot < RT_ELEMENTS(serialPorts); slot++)
-            if (serialPorts[slot])
-                that->onSerialPortChange(serialPorts[slot]);
-        for (ULONG slot = 0; slot < RT_ELEMENTS(parallelPorts); slot++)
-            if (parallelPorts[slot])
-                that->onParallelPortChange(parallelPorts[slot]);
-
-        if (flModifications & IsModified_Storage)
-            that->onStorageControllerChange();
-
-#if 0
-        if (flModifications & IsModified_BandwidthControl)
-            that->onBandwidthControlChange();
-#endif
-    }
-}
-
-/**
- * Commits all the changes to machine settings.
- *
- * Note that this operation is supposed to never fail.
- *
- * @note Locks this object and children for writing.
- */
-void Machine::commit()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AutoCaller peerCaller(mPeer);
-    AssertComRCReturnVoid(peerCaller.rc());
-
-    AutoMultiWriteLock2 alock(mPeer, this COMMA_LOCKVAL_SRC_POS);
-
-    /*
-     *  use safe commit to ensure Snapshot machines (that share mUserData)
-     *  will still refer to a valid memory location
-     */
-    mUserData.commitCopy();
-
-    mHWData.commit();
-
-    if (mMediaData.isBackedUp())
-        commitMedia(Global::IsOnline(mData->mMachineState));
-
-    mBIOSSettings->commit();
-    mVRDEServer->commit();
-    mAudioAdapter->commit();
-    mUSBDeviceFilters->commit();
-    mBandwidthControl->commit();
-
-    /* Since mNetworkAdapters is a list which might have been changed (resized)
-     * without using the Backupable<> template we need to handle the copying
-     * of the list entries manually, including the creation of peers for the
-     * new objects. */
-    bool commitNetworkAdapters = false;
-    size_t newSize = Global::getMaxNetworkAdapters(mHWData->mChipsetType);
-    if (mPeer)
-    {
-        /* commit everything, even the ones which will go away */
-        for (size_t slot = 0; slot < mNetworkAdapters.size(); slot++)
-            mNetworkAdapters[slot]->commit();
-        /* copy over the new entries, creating a peer and uninit the original */
-        mPeer->mNetworkAdapters.resize(RT_MAX(newSize, mPeer->mNetworkAdapters.size()));
-        for (size_t slot = 0; slot < newSize; slot++)
-        {
-            /* look if this adapter has a peer device */
-            ComObjPtr<NetworkAdapter> peer = mNetworkAdapters[slot]->getPeer();
-            if (!peer)
-            {
-                /* no peer means the adapter is a newly created one;
-                 * create a peer owning data this data share it with */
-                peer.createObject();
-                peer->init(mPeer, mNetworkAdapters[slot], true /* aReshare */);
-            }
-            mPeer->mNetworkAdapters[slot] = peer;
-        }
-        /* uninit any no longer needed network adapters */
-        for (size_t slot = newSize; slot < mNetworkAdapters.size(); slot++)
-            mNetworkAdapters[slot]->uninit();
-        for (size_t slot = newSize; slot < mPeer->mNetworkAdapters.size(); slot++)
-        {
-            if (mPeer->mNetworkAdapters[slot])
-                mPeer->mNetworkAdapters[slot]->uninit();
-        }
-        /* Keep the original network adapter count until this point, so that
-         * discarding a chipset type change will not lose settings. */
-        mNetworkAdapters.resize(newSize);
-        mPeer->mNetworkAdapters.resize(newSize);
-    }
-    else
-    {
-        /* we have no peer (our parent is the newly created machine);
-         * just commit changes to the network adapters */
-        commitNetworkAdapters = true;
-    }
-    if (commitNetworkAdapters)
-    {
-        for (size_t slot = 0; slot < mNetworkAdapters.size(); slot++)
-            mNetworkAdapters[slot]->commit();
-    }
-
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
-        mSerialPorts[slot]->commit();
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-        mParallelPorts[slot]->commit();
-
-    bool commitStorageControllers = false;
-
-    if (mStorageControllers.isBackedUp())
-    {
-        mStorageControllers.commit();
-
-        if (mPeer)
-        {
-            /* Commit all changes to new controllers (this will reshare data with
-             * peers for those who have peers) */
-            StorageControllerList *newList = new StorageControllerList();
-            StorageControllerList::const_iterator it = mStorageControllers->begin();
-            while (it != mStorageControllers->end())
-            {
-                (*it)->commit();
-
-                /* look if this controller has a peer device */
-                ComObjPtr<StorageController> peer = (*it)->getPeer();
-                if (!peer)
-                {
-                    /* no peer means the device is a newly created one;
-                     * create a peer owning data this device share it with */
-                    peer.createObject();
-                    peer->init(mPeer, *it, true /* aReshare */);
-                }
-                else
-                {
-                    /* remove peer from the old list */
-                    mPeer->mStorageControllers->remove(peer);
-                }
-                /* and add it to the new list */
-                newList->push_back(peer);
-
-                ++it;
-            }
-
-            /* uninit old peer's controllers that are left */
-            it = mPeer->mStorageControllers->begin();
-            while (it != mPeer->mStorageControllers->end())
-            {
-                (*it)->uninit();
-                ++it;
-            }
-
-            /* attach new list of controllers to our peer */
-            mPeer->mStorageControllers.attach(newList);
-        }
-        else
-        {
-            /* we have no peer (our parent is the newly created machine);
-             * just commit changes to devices */
-            commitStorageControllers = true;
-        }
-    }
-    else
-    {
-        /* the list of controllers itself is not changed,
-         * just commit changes to controllers themselves */
-        commitStorageControllers = true;
-    }
-
-    if (commitStorageControllers)
-    {
-        StorageControllerList::const_iterator it = mStorageControllers->begin();
-        while (it != mStorageControllers->end())
-        {
-            (*it)->commit();
-            ++it;
-        }
-    }
-
-    bool commitUSBControllers = false;
-
-    if (mUSBControllers.isBackedUp())
-    {
-        mUSBControllers.commit();
-
-        if (mPeer)
-        {
-            /* Commit all changes to new controllers (this will reshare data with
-             * peers for those who have peers) */
-            USBControllerList *newList = new USBControllerList();
-            USBControllerList::const_iterator it = mUSBControllers->begin();
-            while (it != mUSBControllers->end())
-            {
-                (*it)->commit();
-
-                /* look if this controller has a peer device */
-                ComObjPtr<USBController> peer = (*it)->getPeer();
-                if (!peer)
-                {
-                    /* no peer means the device is a newly created one;
-                     * create a peer owning data this device share it with */
-                    peer.createObject();
-                    peer->init(mPeer, *it, true /* aReshare */);
-                }
-                else
-                {
-                    /* remove peer from the old list */
-                    mPeer->mUSBControllers->remove(peer);
-                }
-                /* and add it to the new list */
-                newList->push_back(peer);
-
-                ++it;
-            }
-
-            /* uninit old peer's controllers that are left */
-            it = mPeer->mUSBControllers->begin();
-            while (it != mPeer->mUSBControllers->end())
-            {
-                (*it)->uninit();
-                ++it;
-            }
-
-            /* attach new list of controllers to our peer */
-            mPeer->mUSBControllers.attach(newList);
-        }
-        else
-        {
-            /* we have no peer (our parent is the newly created machine);
-             * just commit changes to devices */
-            commitUSBControllers = true;
-        }
-    }
-    else
-    {
-        /* the list of controllers itself is not changed,
-         * just commit changes to controllers themselves */
-        commitUSBControllers = true;
-    }
-
-    if (commitUSBControllers)
-    {
-        USBControllerList::const_iterator it = mUSBControllers->begin();
-        while (it != mUSBControllers->end())
-        {
-            (*it)->commit();
-            ++it;
-        }
-    }
-
-    if (isSessionMachine())
-    {
-        /* attach new data to the primary machine and reshare it */
-        mPeer->mUserData.attach(mUserData);
-        mPeer->mHWData.attach(mHWData);
-        /* mMediaData is reshared by fixupMedia */
-        // mPeer->mMediaData.attach(mMediaData);
-        Assert(mPeer->mMediaData.data() == mMediaData.data());
-    }
-}
-
-/**
- * Copies all the hardware data from the given machine.
- *
- * Currently, only called when the VM is being restored from a snapshot. In
- * particular, this implies that the VM is not running during this method's
- * call.
- *
- * @note This method must be called from under this object's lock.
- *
- * @note This method doesn't call #commit(), so all data remains backed up and
- *       unsaved.
- */
-void Machine::copyFrom(Machine *aThat)
-{
-    AssertReturnVoid(!isSnapshotMachine());
-    AssertReturnVoid(aThat->isSnapshotMachine());
-
-    AssertReturnVoid(!Global::IsOnline(mData->mMachineState));
-
-    mHWData.assignCopy(aThat->mHWData);
-
-    // create copies of all shared folders (mHWData after attaching a copy
-    // contains just references to original objects)
-    for (HWData::SharedFolderList::iterator it = mHWData->mSharedFolders.begin();
-         it != mHWData->mSharedFolders.end();
-         ++it)
-    {
-        ComObjPtr<SharedFolder> folder;
-        folder.createObject();
-        HRESULT rc = folder->initCopy(getMachine(), *it);
-        AssertComRC(rc);
-        *it = folder;
-    }
-
-    mBIOSSettings->copyFrom(aThat->mBIOSSettings);
-    mVRDEServer->copyFrom(aThat->mVRDEServer);
-    mAudioAdapter->copyFrom(aThat->mAudioAdapter);
-    mUSBDeviceFilters->copyFrom(aThat->mUSBDeviceFilters);
-    mBandwidthControl->copyFrom(aThat->mBandwidthControl);
-
-    /* create private copies of all controllers */
-    mStorageControllers.backup();
-    mStorageControllers->clear();
-    for (StorageControllerList::iterator it = aThat->mStorageControllers->begin();
-         it != aThat->mStorageControllers->end();
-         ++it)
-    {
-        ComObjPtr<StorageController> ctrl;
-        ctrl.createObject();
-        ctrl->initCopy(this, *it);
-        mStorageControllers->push_back(ctrl);
-    }
-
-    /* create private copies of all USB controllers */
-    mUSBControllers.backup();
-    mUSBControllers->clear();
-    for (USBControllerList::iterator it = aThat->mUSBControllers->begin();
-         it != aThat->mUSBControllers->end();
-         ++it)
-    {
-        ComObjPtr<USBController> ctrl;
-        ctrl.createObject();
-        ctrl->initCopy(this, *it);
-        mUSBControllers->push_back(ctrl);
-    }
-
-    mNetworkAdapters.resize(aThat->mNetworkAdapters.size());
-    for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
-        mNetworkAdapters[slot]->copyFrom(aThat->mNetworkAdapters[slot]);
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
-        mSerialPorts[slot]->copyFrom(aThat->mSerialPorts[slot]);
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-        mParallelPorts[slot]->copyFrom(aThat->mParallelPorts[slot]);
-}
-
-/**
- * Returns whether the given storage controller is hotplug capable.
- *
- * @returns true if the controller supports hotplugging
- *          false otherwise.
- * @param   enmCtrlType    The controller type to check for.
- */
-bool Machine::isControllerHotplugCapable(StorageControllerType_T enmCtrlType)
-{
-    switch (enmCtrlType)
-    {
-        case StorageControllerType_IntelAhci:
-            return true;
-        case StorageControllerType_LsiLogic:
-        case StorageControllerType_LsiLogicSas:
-        case StorageControllerType_BusLogic:
-        case StorageControllerType_PIIX3:
-        case StorageControllerType_PIIX4:
-        case StorageControllerType_ICH6:
-        case StorageControllerType_I82078:
-        default:
-            return false;
-    }
-}
-
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-
-void Machine::getDiskList(MediaList &list)
-{
-    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-         it != mMediaData->mAttachments.end();
-         ++it)
-    {
-        MediumAttachment* pAttach = *it;
-        /* just in case */
-        AssertStmt(pAttach, continue);
-
-        AutoCaller localAutoCallerA(pAttach);
-        if (FAILED(localAutoCallerA.rc())) continue;
-
-        AutoReadLock local_alockA(pAttach COMMA_LOCKVAL_SRC_POS);
-
-        if (pAttach->getType() == DeviceType_HardDisk)
-            list.push_back(pAttach->getMedium());
-    }
-}
-
-void Machine::registerMetrics(PerformanceCollector *aCollector, Machine *aMachine, RTPROCESS pid)
-{
-    AssertReturnVoid(isWriteLockOnCurrentThread());
-    AssertPtrReturnVoid(aCollector);
-
-    pm::CollectorHAL *hal = aCollector->getHAL();
-    /* Create sub metrics */
-    pm::SubMetric *cpuLoadUser = new pm::SubMetric("CPU/Load/User",
-        "Percentage of processor time spent in user mode by the VM process.");
-    pm::SubMetric *cpuLoadKernel = new pm::SubMetric("CPU/Load/Kernel",
-        "Percentage of processor time spent in kernel mode by the VM process.");
-    pm::SubMetric *ramUsageUsed  = new pm::SubMetric("RAM/Usage/Used",
-        "Size of resident portion of VM process in memory.");
-    pm::SubMetric *diskUsageUsed  = new pm::SubMetric("Disk/Usage/Used",
-        "Actual size of all VM disks combined.");
-    pm::SubMetric *machineNetRx = new pm::SubMetric("Net/Rate/Rx",
-        "Network receive rate.");
-    pm::SubMetric *machineNetTx = new pm::SubMetric("Net/Rate/Tx",
-        "Network transmit rate.");
-    /* Create and register base metrics */
-    pm::BaseMetric *cpuLoad = new pm::MachineCpuLoadRaw(hal, aMachine, pid,
-                                                        cpuLoadUser, cpuLoadKernel);
-    aCollector->registerBaseMetric(cpuLoad);
-    pm::BaseMetric *ramUsage = new pm::MachineRamUsage(hal, aMachine, pid,
-                                                       ramUsageUsed);
-    aCollector->registerBaseMetric(ramUsage);
-    MediaList disks;
-    getDiskList(disks);
-    pm::BaseMetric *diskUsage = new pm::MachineDiskUsage(hal, aMachine, disks,
-                                                         diskUsageUsed);
-    aCollector->registerBaseMetric(diskUsage);
-
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser, 0));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
-                                                new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
-                                              new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadUser,
-                                              new pm::AggregateMax()));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel, 0));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
-                                              new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
-                                              new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(cpuLoad, cpuLoadKernel,
-                                              new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed, 0));
-    aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
-                                              new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
-                                              new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(ramUsage, ramUsageUsed,
-                                              new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed, 0));
-    aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
-                                              new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
-                                              new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(diskUsage, diskUsageUsed,
-                                              new pm::AggregateMax()));
-
-
-    /* Guest metrics collector */
-    mCollectorGuest = new pm::CollectorGuest(aMachine, pid);
-    aCollector->registerGuest(mCollectorGuest);
-    LogAleksey(("{%p} " LOG_FN_FMT ": mCollectorGuest=%p\n",
-                this, __PRETTY_FUNCTION__, mCollectorGuest));
-
-    /* Create sub metrics */
-    pm::SubMetric *guestLoadUser = new pm::SubMetric("Guest/CPU/Load/User",
-        "Percentage of processor time spent in user mode as seen by the guest.");
-    pm::SubMetric *guestLoadKernel = new pm::SubMetric("Guest/CPU/Load/Kernel",
-        "Percentage of processor time spent in kernel mode as seen by the guest.");
-    pm::SubMetric *guestLoadIdle = new pm::SubMetric("Guest/CPU/Load/Idle",
-        "Percentage of processor time spent idling as seen by the guest.");
-
-    /* The total amount of physical ram is fixed now, but we'll support dynamic guest ram configurations in the future. */
-    pm::SubMetric *guestMemTotal = new pm::SubMetric("Guest/RAM/Usage/Total",      "Total amount of physical guest RAM.");
-    pm::SubMetric *guestMemFree = new pm::SubMetric("Guest/RAM/Usage/Free",        "Free amount of physical guest RAM.");
-    pm::SubMetric *guestMemBalloon = new pm::SubMetric("Guest/RAM/Usage/Balloon",  "Amount of ballooned physical guest RAM.");
-    pm::SubMetric *guestMemShared = new pm::SubMetric("Guest/RAM/Usage/Shared",  "Amount of shared physical guest RAM.");
-    pm::SubMetric *guestMemCache = new pm::SubMetric("Guest/RAM/Usage/Cache",        "Total amount of guest (disk) cache memory.");
-
-    pm::SubMetric *guestPagedTotal = new pm::SubMetric("Guest/Pagefile/Usage/Total",    "Total amount of space in the page file.");
-
-    /* Create and register base metrics */
-    pm::BaseMetric *machineNetRate = new pm::MachineNetRate(mCollectorGuest, aMachine,
-                                                            machineNetRx, machineNetTx);
-    aCollector->registerBaseMetric(machineNetRate);
-
-    pm::BaseMetric *guestCpuLoad = new pm::GuestCpuLoad(mCollectorGuest, aMachine,
-                                                        guestLoadUser, guestLoadKernel, guestLoadIdle);
-    aCollector->registerBaseMetric(guestCpuLoad);
-
-    pm::BaseMetric *guestCpuMem = new pm::GuestRamUsage(mCollectorGuest, aMachine,
-                                                        guestMemTotal, guestMemFree,
-                                                        guestMemBalloon, guestMemShared,
-                                                        guestMemCache, guestPagedTotal);
-    aCollector->registerBaseMetric(guestCpuMem);
-
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, 0));
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetRx, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, 0));
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(machineNetRate, machineNetTx, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadUser, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadKernel, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuLoad, guestLoadIdle, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemTotal, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemFree, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemBalloon, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemShared, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestMemCache, new pm::AggregateMax()));
-
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, 0));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateAvg()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMin()));
-    aCollector->registerMetric(new pm::Metric(guestCpuMem, guestPagedTotal, new pm::AggregateMax()));
-}
-
-void Machine::unregisterMetrics(PerformanceCollector *aCollector, Machine *aMachine)
-{
-    AssertReturnVoid(isWriteLockOnCurrentThread());
-
-    if (aCollector)
-    {
-        aCollector->unregisterMetricsFor(aMachine);
-        aCollector->unregisterBaseMetricsFor(aMachine);
-    }
-}
-
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-DEFINE_EMPTY_CTOR_DTOR(SessionMachine)
-
-HRESULT SessionMachine::FinalConstruct()
-{
-    LogFlowThisFunc(("\n"));
-
+    if (mClientToken != NULLHANDLE)
+        ::DosCloseMutexSem(mClientToken);
+#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+    if (mClientToken >= 0)
+        ::semctl(mClientToken, 0, IPC_RMID);
+# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
+    mClientTokenId = "0";
+# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
+#else
+# error "Port me!"
+#endif
+    mClientToken = CTTOKENARG;
+}
+
+Machine::ClientToken::ClientToken(const ComObjPtr<Machine> &pMachine) :
+    mMachine(pMachine)
+{
 #if defined(RT_OS_WINDOWS)
-    mIPCSem = NULL;
-#elif defined(RT_OS_OS2)
-    mIPCSem = NULLHANDLE;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    mIPCSem = -1;
-#else
-# error "Port me!"
-#endif
-
-    return BaseFinalConstruct();
-}
-
-void SessionMachine::FinalRelease()
-{
-    LogFlowThisFunc(("\n"));
-
-    uninit(Uninit::Unexpected);
-
-    BaseFinalRelease();
-}
-
-/**
- *  @note Must be called only by Machine::openSession() from its own write lock.
- */
-HRESULT SessionMachine::init(Machine *aMachine)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("mName={%s}\n", aMachine->mUserData->s.strName.c_str()));
-
-    AssertReturn(aMachine, E_INVALIDARG);
-
-    AssertReturn(aMachine->lockHandle()->isWriteLockOnCurrentThread(), E_FAIL);
-
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    /* create the interprocess semaphore */
-#if defined(RT_OS_WINDOWS)
-    mIPCSemName = aMachine->mData->m_strConfigFileFull;
-    for (size_t i = 0; i < mIPCSemName.length(); i++)
-        if (mIPCSemName.raw()[i] == '\\')
-            mIPCSemName.raw()[i] = '/';
-    mIPCSem = ::CreateMutex(NULL, FALSE, mIPCSemName.raw());
-    ComAssertMsgRet(mIPCSem,
-                    ("Cannot create IPC mutex '%ls', err=%d",
-                     mIPCSemName.raw(), ::GetLastError()),
-                    E_FAIL);
+    Bstr tokenId = pMachine->mData->m_strConfigFileFull;
+    for (size_t i = 0; i < tokenId.length(); i++)
+        if (tokenId.raw()[i] == '\\')
+            tokenId.raw()[i] = '/';
+    mClientToken = ::CreateMutex(NULL, FALSE, tokenId.raw());
+    mClientTokenId = tokenId;
+    AssertMsg(mClientToken,
+              ("Cannot create token '%s', err=%d",
+               mClientTokenId.c_str(), ::GetLastError()));
 #elif defined(RT_OS_OS2)
     Utf8Str ipcSem = Utf8StrFmt("\\SEM32\\VBOX\\VM\\{%RTuuid}",
-                                aMachine->mData->mUuid.raw());
-    mIPCSemName = ipcSem;
-    APIRET arc = ::DosCreateMutexSem((PSZ)ipcSem.c_str(), &mIPCSem, 0, FALSE);
-    ComAssertMsgRet(arc == NO_ERROR,
-                    ("Cannot create IPC mutex '%s', arc=%ld",
-                     ipcSem.c_str(), arc),
-                    E_FAIL);
+                                pMachine->mData->mUuid.raw());
+    mClientTokenId = ipcSem;
+    APIRET arc = ::DosCreateMutexSem((PSZ)ipcSem.c_str(), &mClientToken, 0, FALSE);
+    AssertMsg(arc == NO_ERROR,
+              ("Cannot create token '%s', arc=%ld",
+               ipcSem.c_str(), arc));
 #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
 # ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
@@ -12747 +94 @@
 #  endif
     key_t key;
-    mIPCSem = -1;
-    mIPCKey = "0";
+    mClientToken = -1;
+    mClientTokenId = "0";
     for (uint32_t i = 0; i < 1 << 24; i++)
     {
@@ -12755 +102 @@
         if (sem >= 0 || (errno != EEXIST && errno != EACCES))
         {
-            mIPCSem = sem;
+            mClientToken = sem;
             if (sem >= 0)
-                mIPCKey = BstrFmt("%u", key);
+                mClientTokenId = BstrFmt("%u", key);
             break;
         }
     }
 # else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    Utf8Str semName = aMachine->mData->m_strConfigFileFull;
+    Utf8Str semName = pMachine->mData->m_strConfigFileFull;
     char *pszSemName = NULL;
     RTStrUtf8ToCurrentCP(&pszSemName, semName);
@@ -12768 +115 @@
     RTStrFree(pszSemName);
 
-    mIPCSem = ::semget(key, 1, S_IRWXU | S_IRWXG | S_IRWXO | IPC_CREAT);
+    mClientToken = ::semget(key, 1, S_IRWXU | S_IRWXG | S_IRWXO | IPC_CREAT);
 # endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
 
     int errnoSave = errno;
-    if (mIPCSem < 0 && errnoSave == ENOSYS)
-    {
-        setError(E_FAIL,
-                 tr("Cannot create IPC semaphore. Most likely your host kernel lacks "
-                    "support for SysV IPC. Check the host kernel configuration for "
-                    "CONFIG_SYSVIPC=y"));
-        return E_FAIL;
+    if (mClientToken < 0 && errnoSave == ENOSYS)
+    {
+        mMachine->setError(E_FAIL,
+                           tr("Cannot create IPC semaphore. Most likely your host kernel lacks "
+                              "support for SysV IPC. Check the host kernel configuration for "
+                              "CONFIG_SYSVIPC=y"));
+        mClientToken = CTTOKENARG;
+        return;
     }
     /* ENOSPC can also be the result of VBoxSVC crashes without properly freeing
-     * the IPC semaphores */
-    if (mIPCSem < 0 && errnoSave == ENOSPC)
+     * the token */
+    if (mClientToken < 0 && errnoSave == ENOSPC)
     {
 #ifdef RT_OS_LINUX
-        setError(E_FAIL,
-                 tr("Cannot create IPC semaphore because the system limit for the "
-                    "maximum number of semaphore sets (SEMMNI), or the system wide "
-                    "maximum number of semaphores (SEMMNS) would be exceeded. The "
-                    "current set of SysV IPC semaphores can be determined from "
-                    "the file /proc/sysvipc/sem"));
-#else
-        setError(E_FAIL,
-                 tr("Cannot create IPC semaphore because the system-imposed limit "
-                    "on the maximum number of allowed  semaphores or semaphore "
-                    "identifiers system-wide would be exceeded"));
-#endif
-        return E_FAIL;
-    }
-    ComAssertMsgRet(mIPCSem >= 0, ("Cannot create IPC semaphore, errno=%d", errnoSave),
-                    E_FAIL);
+        mMachine->setError(E_FAIL,
+                           tr("Cannot create IPC semaphore because the system limit for the "
+                              "maximum number of semaphore sets (SEMMNI), or the system wide "
+                              "maximum number of semaphores (SEMMNS) would be exceeded. The "
+                              "current set of SysV IPC semaphores can be determined from "
+                              "the file /proc/sysvipc/sem"));
+#else
+        mMachine->setError(E_FAIL,
+                           tr("Cannot create IPC semaphore because the system-imposed limit "
+                              "on the maximum number of allowed  semaphores or semaphore "
+                              "identifiers system-wide would be exceeded"));
+#endif
+        mClientToken = CTTOKENARG;
+        return;
+    }
+    AssertMsgReturnVoid(mClientToken >= 0, ("Cannot create token, errno=%d", errnoSave));
     /* set the initial value to 1 */
-    int rv = ::semctl(mIPCSem, 0, SETVAL, 1);
-    ComAssertMsgRet(rv == 0, ("Cannot init IPC semaphore, errno=%d", errno),
-                    E_FAIL);
+    int rv = ::semctl(mClientToken, 0, SETVAL, 1);
+    errnoSave = errno;
+    if (rv != 0)
+    {
+        ::semctl(mClientToken, 0, IPC_RMID);
+        mClientToken = CTTOKENARG;
+        AssertMsgFailedReturnVoid(("Cannot init token, errno=%d", errnoSave));
+    }
 #else
 # error "Port me!"
 #endif
-
-    /* memorize the peer Machine */
-    unconst(mPeer) = aMachine;
-    /* share the parent pointer */
-    unconst(mParent) = aMachine->mParent;
-
-    /* take the pointers to data to share */
-    mData.share(aMachine->mData);
-    mSSData.share(aMachine->mSSData);
-
-    mUserData.share(aMachine->mUserData);
-    mHWData.share(aMachine->mHWData);
-    mMediaData.share(aMachine->mMediaData);
-
-    mStorageControllers.allocate();
-    for (StorageControllerList::const_iterator it = aMachine->mStorageControllers->begin();
-         it != aMachine->mStorageControllers->end();
-         ++it)
-    {
-        ComObjPtr<StorageController> ctl;
-        ctl.createObject();
-        ctl->init(this, *it);
-        mStorageControllers->push_back(ctl);
-    }
-
-    mUSBControllers.allocate();
-    for (USBControllerList::const_iterator it = aMachine->mUSBControllers->begin();
-         it != aMachine->mUSBControllers->end();
-         ++it)
-    {
-        ComObjPtr<USBController> ctl;
-        ctl.createObject();
-        ctl->init(this, *it);
-        mUSBControllers->push_back(ctl);
-    }
-
-    unconst(mBIOSSettings).createObject();
-    mBIOSSettings->init(this, aMachine->mBIOSSettings);
-    /* create another VRDEServer object that will be mutable */
-    unconst(mVRDEServer).createObject();
-    mVRDEServer->init(this, aMachine->mVRDEServer);
-    /* create another audio adapter object that will be mutable */
-    unconst(mAudioAdapter).createObject();
-    mAudioAdapter->init(this, aMachine->mAudioAdapter);
-    /* create a list of serial ports that will be mutable */
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mSerialPorts); slot++)
-    {
-        unconst(mSerialPorts[slot]).createObject();
-        mSerialPorts[slot]->init(this, aMachine->mSerialPorts[slot]);
-    }
-    /* create a list of parallel ports that will be mutable */
-    for (ULONG slot = 0; slot < RT_ELEMENTS(mParallelPorts); slot++)
-    {
-        unconst(mParallelPorts[slot]).createObject();
-        mParallelPorts[slot]->init(this, aMachine->mParallelPorts[slot]);
-    }
-
-    /* create another USB device filters object that will be mutable */
-    unconst(mUSBDeviceFilters).createObject();
-    mUSBDeviceFilters->init(this, aMachine->mUSBDeviceFilters);
-
-    /* create a list of network adapters that will be mutable */
-    mNetworkAdapters.resize(aMachine->mNetworkAdapters.size());
-    for (ULONG slot = 0; slot < mNetworkAdapters.size(); slot++)
-    {
-        unconst(mNetworkAdapters[slot]).createObject();
-        mNetworkAdapters[slot]->init(this, aMachine->mNetworkAdapters[slot]);
-    }
-
-    /* create another bandwidth control object that will be mutable */
-    unconst(mBandwidthControl).createObject();
-    mBandwidthControl->init(this, aMachine->mBandwidthControl);
-
-    /* default is to delete saved state on Saved -> PoweredOff transition */
-    mRemoveSavedState = true;
-
-    /* Confirm a successful initialization when it's the case */
-    autoInitSpan.setSucceeded();
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-/**
- *  Uninitializes this session object. If the reason is other than
- *  Uninit::Unexpected, then this method MUST be called from #checkForDeath().
- *
- *  @param aReason          uninitialization reason
- *
- *  @note Locks mParent + this object for writing.
- */
-void SessionMachine::uninit(Uninit::Reason aReason)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("reason=%d\n", aReason));
-
-    /*
-     *  Strongly reference ourselves to prevent this object deletion after
-     *  mData->mSession.mMachine.setNull() below (which can release the last
-     *  reference and call the destructor). Important: this must be done before
-     *  accessing any members (and before AutoUninitSpan that does it as well).
-     *  This self reference will be released as the very last step on return.
-     */
-    ComObjPtr<SessionMachine> selfRef = this;
-
-    /* Enclose the state transition Ready->InUninit->NotReady */
-    AutoUninitSpan autoUninitSpan(this);
-    if (autoUninitSpan.uninitDone())
-    {
-        LogFlowThisFunc(("Already uninitialized\n"));
-        LogFlowThisFuncLeave();
-        return;
-    }
-
-    if (autoUninitSpan.initFailed())
-    {
-        /* We've been called by init() because it's failed. It's not really
-         * necessary (nor it's safe) to perform the regular uninit sequence
-         * below, the following is enough.
-         */
-        LogFlowThisFunc(("Initialization failed.\n"));
+}
+
+bool Machine::ClientToken::isReady()
+{
+    return mClientToken != CTTOKENARG;
+}
+
+void Machine::ClientToken::getId(Utf8Str &strId)
+{
+    strId = mClientTokenId;
+}
+
+CTTOKENTYPE Machine::ClientToken::getToken()
+{
+    return mClientToken;
+}
+
+bool Machine::ClientToken::release()
+{
+    bool terminated = false;
+
 #if defined(RT_OS_WINDOWS)
-        if (mIPCSem)
-            ::CloseHandle(mIPCSem);
-        mIPCSem = NULL;
+    AssertMsg(mClientToken, ("semaphore must be created"));
+
+    /* release the token */
+    ::ReleaseMutex(mClientToken);
+    terminated = true;
 #elif defined(RT_OS_OS2)
-        if (mIPCSem != NULLHANDLE)
-            ::DosCloseMutexSem(mIPCSem);
-        mIPCSem = NULLHANDLE;
+    AssertMsg(mClientToken, ("semaphore must be created"));
+
+    /* release the token */
+    ::DosReleaseMutexSem(mClientToken);
+    terminated = true;
 #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-        if (mIPCSem >= 0)
-            ::semctl(mIPCSem, 0, IPC_RMID);
-        mIPCSem = -1;
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-        mIPCKey = "0";
-# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
+    AssertMsg(mClientToken >= 0, ("semaphore must be created"));
+    int val = ::semctl(mClientToken, 0, GETVAL);
+    if (val > 0)
+    {
+        /* the semaphore is signaled, meaning the session is terminated */
+        terminated = true;
+    }
 #else
 # error "Port me!"
 #endif
-        uninitDataAndChildObjects();
-        mData.free();
-        unconst(mParent) = NULL;
-        unconst(mPeer) = NULL;
-        LogFlowThisFuncLeave();
-        return;
-    }
-
-    MachineState_T lastState;
-    {
-        AutoReadLock tempLock(this COMMA_LOCKVAL_SRC_POS);
-        lastState = mData->mMachineState;
-    }
-    NOREF(lastState);
-
-#ifdef VBOX_WITH_USB
-    // release all captured USB devices, but do this before requesting the locks below
-    if (aReason == Uninit::Abnormal && Global::IsOnline(lastState))
-    {
-        /* Console::captureUSBDevices() is called in the VM process only after
-         * setting the machine state to Starting or Restoring.
-         * Console::detachAllUSBDevices() will be called upon successful
-         * termination. So, we need to release USB devices only if there was
-         * an abnormal termination of a running VM.
-         *
-         * This is identical to SessionMachine::DetachAllUSBDevices except
-         * for the aAbnormal argument. */
-        HRESULT rc = mUSBDeviceFilters->notifyProxy(false /* aInsertFilters */);
-        AssertComRC(rc);
-        NOREF(rc);
-
-        USBProxyService *service = mParent->host()->usbProxyService();
-        if (service)
-            service->detachAllDevicesFromVM(this, true /* aDone */, true /* aAbnormal */);
-    }
-#endif /* VBOX_WITH_USB */
-
-    // we need to lock this object in uninit() because the lock is shared
-    // with mPeer (as well as data we modify below). mParent->addProcessToReap()
-    // and others need mParent lock, and USB needs host lock.
-    AutoMultiWriteLock3 multilock(mParent, mParent->host(), this COMMA_LOCKVAL_SRC_POS);
-
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-    /*
-     * It is safe to call Machine::unregisterMetrics() here because
-     * PerformanceCollector::samplerCallback no longer accesses guest methods
-     * holding the lock.
-     */
-    unregisterMetrics(mParent->performanceCollector(), mPeer);
-    /* The guest must be unregistered after its metrics (@bugref{5949}). */
-    LogAleksey(("{%p} " LOG_FN_FMT ": mCollectorGuest=%p\n",
-                this, __PRETTY_FUNCTION__, mCollectorGuest));
-    if (mCollectorGuest)
-    {
-        mParent->performanceCollector()->unregisterGuest(mCollectorGuest);
-        // delete mCollectorGuest; => CollectorGuestManager::destroyUnregistered()
-        mCollectorGuest = NULL;
-    }
-#endif
-
-    if (aReason == Uninit::Abnormal)
-    {
-        LogWarningThisFunc(("ABNORMAL client termination! (wasBusy=%d)\n",
-                             Global::IsOnlineOrTransient(lastState)));
-
-        /* reset the state to Aborted */
-        if (mData->mMachineState != MachineState_Aborted)
-            setMachineState(MachineState_Aborted);
-    }
-
-    // any machine settings modified?
-    if (mData->flModifications)
-    {
-        LogWarningThisFunc(("Discarding unsaved settings changes!\n"));
-        rollback(false /* aNotify */);
-    }
-
-    Assert(    mConsoleTaskData.strStateFilePath.isEmpty()
-            || !mConsoleTaskData.mSnapshot);
-    if (!mConsoleTaskData.strStateFilePath.isEmpty())
-    {
-        LogWarningThisFunc(("canceling failed save state request!\n"));
-        endSavingState(E_FAIL, tr("Machine terminated with pending save state!"));
-    }
-    else if (!mConsoleTaskData.mSnapshot.isNull())
-    {
-        LogWarningThisFunc(("canceling untaken snapshot!\n"));
-
-        /* delete all differencing hard disks created (this will also attach
-         * their parents back by rolling back mMediaData) */
-        rollbackMedia();
-
-        // delete the saved state file (it might have been already created)
-        // AFTER killing the snapshot so that releaseSavedStateFile() won't
-        // think it's still in use
-        Utf8Str strStateFile = mConsoleTaskData.mSnapshot->getStateFilePath();
-        mConsoleTaskData.mSnapshot->uninit();
-        releaseSavedStateFile(strStateFile, NULL /* pSnapshotToIgnore */ );
-    }
-
-    if (!mData->mSession.mType.isEmpty())
-    {
-        /* mType is not null when this machine's process has been started by
-         * Machine::LaunchVMProcess(), therefore it is our child.  We
-         * need to queue the PID to reap the process (and avoid zombies on
-         * Linux). */
-        Assert(mData->mSession.mPID != NIL_RTPROCESS);
-        mParent->addProcessToReap(mData->mSession.mPID);
-    }
-
-    mData->mSession.mPID = NIL_RTPROCESS;
-
-    if (aReason == Uninit::Unexpected)
-    {
-        /* Uninitialization didn't come from #checkForDeath(), so tell the
-         * client watcher thread to update the set of machines that have open
-         * sessions. */
-        mParent->updateClientWatcher();
-    }
-
-    /* uninitialize all remote controls */
-    if (mData->mSession.mRemoteControls.size())
-    {
-        LogFlowThisFunc(("Closing remote sessions (%d):\n",
-                          mData->mSession.mRemoteControls.size()));
-
-        Data::Session::RemoteControlList::iterator it =
-            mData->mSession.mRemoteControls.begin();
-        while (it != mData->mSession.mRemoteControls.end())
-        {
-            LogFlowThisFunc(("  Calling remoteControl->Uninitialize()...\n"));
-            HRESULT rc = (*it)->Uninitialize();
-            LogFlowThisFunc(("  remoteControl->Uninitialize() returned %08X\n", rc));
-            if (FAILED(rc))
-                LogWarningThisFunc(("Forgot to close the remote session?\n"));
-            ++it;
-        }
-        mData->mSession.mRemoteControls.clear();
-    }
-
-    /*
-     *  An expected uninitialization can come only from #checkForDeath().
-     *  Otherwise it means that something's gone really wrong (for example,
-     *  the Session implementation has released the VirtualBox reference
-     *  before it triggered #OnSessionEnd(), or before releasing IPC semaphore,
-     *  etc). However, it's also possible, that the client releases the IPC
-     *  semaphore correctly (i.e. before it releases the VirtualBox reference),
-     *  but the VirtualBox release event comes first to the server process.
-     *  This case is practically possible, so we should not assert on an
-     *  unexpected uninit, just log a warning.
-     */
-
-    if ((aReason == Uninit::Unexpected))
-        LogWarningThisFunc(("Unexpected SessionMachine uninitialization!\n"));
-
-    if (aReason != Uninit::Normal)
-    {
-        mData->mSession.mDirectControl.setNull();
-    }
-    else
-    {
-        /* this must be null here (see #OnSessionEnd()) */
-        Assert(mData->mSession.mDirectControl.isNull());
-        Assert(mData->mSession.mState == SessionState_Unlocking);
-        Assert(!mData->mSession.mProgress.isNull());
-    }
-    if (mData->mSession.mProgress)
-    {
-        if (aReason == Uninit::Normal)
-            mData->mSession.mProgress->notifyComplete(S_OK);
-        else
-            mData->mSession.mProgress->notifyComplete(E_FAIL,
-                                                      COM_IIDOF(ISession),
-                                                      getComponentName(),
-                                                      tr("The VM session was aborted"));
-        mData->mSession.mProgress.setNull();
-    }
-
-    /* remove the association between the peer machine and this session machine */
-    Assert(   (SessionMachine*)mData->mSession.mMachine == this
-            || aReason == Uninit::Unexpected);
-
-    /* reset the rest of session data */
-    mData->mSession.mMachine.setNull();
-    mData->mSession.mState = SessionState_Unlocked;
-    mData->mSession.mType.setNull();
-
-    /* close the interprocess semaphore before leaving the exclusive lock */
-#if defined(RT_OS_WINDOWS)
-    if (mIPCSem)
-        ::CloseHandle(mIPCSem);
-    mIPCSem = NULL;
-#elif defined(RT_OS_OS2)
-    if (mIPCSem != NULLHANDLE)
-        ::DosCloseMutexSem(mIPCSem);
-    mIPCSem = NULLHANDLE;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    if (mIPCSem >= 0)
-        ::semctl(mIPCSem, 0, IPC_RMID);
-    mIPCSem = -1;
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    mIPCKey = "0";
-# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
-#else
-# error "Port me!"
-#endif
-
-    /* fire an event */
-    mParent->onSessionStateChange(mData->mUuid, SessionState_Unlocked);
-
-    uninitDataAndChildObjects();
-
-    /* free the essential data structure last */
-    mData.free();
-
-    /* release the exclusive lock before setting the below two to NULL */
-    multilock.release();
-
-    unconst(mParent) = NULL;
-    unconst(mPeer) = NULL;
-
-    LogFlowThisFuncLeave();
-}
-
-// util::Lockable interface
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Overrides VirtualBoxBase::lockHandle() in order to share the lock handle
- *  with the primary Machine instance (mPeer).
- */
-RWLockHandle *SessionMachine::lockHandle() const
-{
-    AssertReturn(mPeer != NULL, NULL);
-    return mPeer->lockHandle();
-}
-
-// IInternalMachineControl methods
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Passes collected guest statistics to performance collector object
- */
-STDMETHODIMP SessionMachine::ReportVmStatistics(ULONG aValidStats, ULONG aCpuUser,
-                                                ULONG aCpuKernel, ULONG aCpuIdle,
-                                                ULONG aMemTotal, ULONG aMemFree,
-                                                ULONG aMemBalloon, ULONG aMemShared,
-                                                ULONG aMemCache, ULONG aPageTotal,
-                                                ULONG aAllocVMM, ULONG aFreeVMM,
-                                                ULONG aBalloonedVMM, ULONG aSharedVMM,
-                                                ULONG aVmNetRx, ULONG aVmNetTx)
-{
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-    if (mCollectorGuest)
-        mCollectorGuest->updateStats(aValidStats, aCpuUser, aCpuKernel, aCpuIdle,
-                                     aMemTotal, aMemFree, aMemBalloon, aMemShared,
-                                     aMemCache, aPageTotal, aAllocVMM, aFreeVMM,
-                                     aBalloonedVMM, aSharedVMM, aVmNetRx, aVmNetTx);
-
-    return S_OK;
-#else
-    NOREF(aValidStats);
-    NOREF(aCpuUser);
-    NOREF(aCpuKernel);
-    NOREF(aCpuIdle);
-    NOREF(aMemTotal);
-    NOREF(aMemFree);
-    NOREF(aMemBalloon);
-    NOREF(aMemShared);
-    NOREF(aMemCache);
-    NOREF(aPageTotal);
-    NOREF(aAllocVMM);
-    NOREF(aFreeVMM);
-    NOREF(aBalloonedVMM);
-    NOREF(aSharedVMM);
-    NOREF(aVmNetRx);
-    NOREF(aVmNetTx);
-    return E_NOTIMPL;
-#endif
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::SetRemoveSavedStateFile(BOOL aRemove)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    mRemoveSavedState = aRemove;
-
-    return S_OK;
-}
-
-/**
- *  @note Locks the same as #setMachineState() does.
- */
-STDMETHODIMP SessionMachine::UpdateState(MachineState_T aMachineState)
-{
-    return setMachineState(aMachineState);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-STDMETHODIMP SessionMachine::GetIPCId(BSTR *aId)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-    mIPCSemName.cloneTo(aId);
-    return S_OK;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    mIPCKey.cloneTo(aId);
-# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    mData->m_strConfigFileFull.cloneTo(aId);
-# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    return S_OK;
-#else
-# error "Port me!"
-#endif
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::BeginPowerUp(IProgress *aProgress)
-{
-    LogFlowThisFunc(("aProgress=%p\n", aProgress));
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mData->mSession.mState != SessionState_Locked)
-        return VBOX_E_INVALID_OBJECT_STATE;
-
-    if (!mData->mSession.mProgress.isNull())
-        mData->mSession.mProgress->setOtherProgressObject(aProgress);
-
-    LogFlowThisFunc(("returns S_OK.\n"));
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::EndPowerUp(LONG iResult)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    if (mData->mSession.mState != SessionState_Locked)
-        return VBOX_E_INVALID_OBJECT_STATE;
-
-    /* Finalize the LaunchVMProcess progress object. */
-    if (mData->mSession.mProgress)
-    {
-        mData->mSession.mProgress->notifyComplete((HRESULT)iResult);
-        mData->mSession.mProgress.setNull();
-    }
-
-    if (SUCCEEDED((HRESULT)iResult))
-    {
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-        /* The VM has been powered up successfully, so it makes sense
-         * now to offer the performance metrics for a running machine
-         * object. Doing it earlier wouldn't be safe. */
-        registerMetrics(mParent->performanceCollector(), mPeer,
-                        mData->mSession.mPID);
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-    }
-
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::BeginPoweringDown(IProgress **aProgress)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aProgress);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(mConsoleTaskData.mLastState == MachineState_Null,
-                 E_FAIL);
-
-    /* create a progress object to track operation completion */
-    ComObjPtr<Progress> pProgress;
-    pProgress.createObject();
-    pProgress->init(getVirtualBox(),
-                    static_cast<IMachine *>(this) /* aInitiator */,
-                    Bstr(tr("Stopping the virtual machine")).raw(),
-                    FALSE /* aCancelable */);
-
-    /* fill in the console task data */
-    mConsoleTaskData.mLastState = mData->mMachineState;
-    mConsoleTaskData.mProgress = pProgress;
-
-    /* set the state to Stopping (this is expected by Console::PowerDown()) */
-    setMachineState(MachineState_Stopping);
-
-    pProgress.queryInterfaceTo(aProgress);
-
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::EndPoweringDown(LONG iResult, IN_BSTR aErrMsg)
-{
-    LogFlowThisFuncEnter();
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(    (   (SUCCEEDED(iResult) && mData->mMachineState == MachineState_PoweredOff)
-                      || (FAILED(iResult) && mData->mMachineState == MachineState_Stopping))
-                  && mConsoleTaskData.mLastState != MachineState_Null,
-                 E_FAIL);
-
-    /*
-     * On failure, set the state to the state we had when BeginPoweringDown()
-     * was called (this is expected by Console::PowerDown() and the associated
-     * task). On success the VM process already changed the state to
-     * MachineState_PoweredOff, so no need to do anything.
-     */
-    if (FAILED(iResult))
-        setMachineState(mConsoleTaskData.mLastState);
-
-    /* notify the progress object about operation completion */
-    Assert(mConsoleTaskData.mProgress);
-    if (SUCCEEDED(iResult))
-        mConsoleTaskData.mProgress->notifyComplete(S_OK);
-    else
-    {
-        Utf8Str strErrMsg(aErrMsg);
-        if (strErrMsg.length())
-            mConsoleTaskData.mProgress->notifyComplete(iResult,
-                                                       COM_IIDOF(ISession),
-                                                       getComponentName(),
-                                                       strErrMsg.c_str());
-        else
-            mConsoleTaskData.mProgress->notifyComplete(iResult);
-    }
-
-    /* clear out the temporary saved state data */
-    mConsoleTaskData.mLastState = MachineState_Null;
-    mConsoleTaskData.mProgress.setNull();
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-
-/**
- *  Goes through the USB filters of the given machine to see if the given
- *  device matches any filter or not.
- *
- *  @note Locks the same as USBController::hasMatchingFilter() does.
- */
-STDMETHODIMP SessionMachine::RunUSBDeviceFilters(IUSBDevice *aUSBDevice,
-                                                 BOOL *aMatched,
-                                                 ULONG *aMaskedIfs)
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgNotNull(aUSBDevice);
-    CheckComArgOutPointerValid(aMatched);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-#ifdef VBOX_WITH_USB
-    *aMatched = mUSBDeviceFilters->hasMatchingFilter(aUSBDevice, aMaskedIfs);
-#else
-    NOREF(aUSBDevice);
-    NOREF(aMaskedIfs);
-    *aMatched = FALSE;
-#endif
-
-    return S_OK;
-}
-
-/**
- *  @note Locks the same as Host::captureUSBDevice() does.
- */
-STDMETHODIMP SessionMachine::CaptureUSBDevice(IN_BSTR aId)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-#ifdef VBOX_WITH_USB
-    /* if captureDeviceForVM() fails, it must have set extended error info */
-    clearError();
-    MultiResult rc = mParent->host()->checkUSBProxyService();
-    if (FAILED(rc)) return rc;
-
-    USBProxyService *service = mParent->host()->usbProxyService();
-    AssertReturn(service, E_FAIL);
-    return service->captureDeviceForVM(this, Guid(aId).ref());
-#else
-    NOREF(aId);
-    return E_NOTIMPL;
-#endif
-}
-
-/**
- *  @note Locks the same as Host::detachUSBDevice() does.
- */
-STDMETHODIMP SessionMachine::DetachUSBDevice(IN_BSTR aId, BOOL aDone)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-#ifdef VBOX_WITH_USB
-    USBProxyService *service = mParent->host()->usbProxyService();
-    AssertReturn(service, E_FAIL);
-    return service->detachDeviceFromVM(this, Guid(aId).ref(), !!aDone);
-#else
-    NOREF(aId);
-    NOREF(aDone);
-    return E_NOTIMPL;
-#endif
-}
-
-/**
- *  Inserts all machine filters to the USB proxy service and then calls
- *  Host::autoCaptureUSBDevices().
- *
- *  Called by Console from the VM process upon VM startup.
- *
- *  @note Locks what called methods lock.
- */
-STDMETHODIMP SessionMachine::AutoCaptureUSBDevices()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-#ifdef VBOX_WITH_USB
-    HRESULT rc = mUSBDeviceFilters->notifyProxy(true /* aInsertFilters */);
-    AssertComRC(rc);
-    NOREF(rc);
-
-    USBProxyService *service = mParent->host()->usbProxyService();
-    AssertReturn(service, E_FAIL);
-    return service->autoCaptureDevicesForVM(this);
-#else
-    return S_OK;
-#endif
-}
-
-/**
- *  Removes all machine filters from the USB proxy service and then calls
- *  Host::detachAllUSBDevices().
- *
- *  Called by Console from the VM process upon normal VM termination or by
- *  SessionMachine::uninit() upon abnormal VM termination (from under the
- *  Machine/SessionMachine lock).
- *
- *  @note Locks what called methods lock.
- */
-STDMETHODIMP SessionMachine::DetachAllUSBDevices(BOOL aDone)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-#ifdef VBOX_WITH_USB
-    HRESULT rc = mUSBDeviceFilters->notifyProxy(false /* aInsertFilters */);
-    AssertComRC(rc);
-    NOREF(rc);
-
-    USBProxyService *service = mParent->host()->usbProxyService();
-    AssertReturn(service, E_FAIL);
-    return service->detachAllDevicesFromVM(this, !!aDone, false /* aAbnormal */);
-#else
-    NOREF(aDone);
-    return S_OK;
-#endif
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::OnSessionEnd(ISession *aSession,
-                                          IProgress **aProgress)
-{
-    LogFlowThisFuncEnter();
-
-    AssertReturn(aSession, E_INVALIDARG);
-    AssertReturn(aProgress, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-
-    LogFlowThisFunc(("callerstate=%d\n", autoCaller.state()));
-    /*
-     *  We don't assert below because it might happen that a non-direct session
-     *  informs us it is closed right after we've been uninitialized -- it's ok.
-     */
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* get IInternalSessionControl interface */
-    ComPtr<IInternalSessionControl> control(aSession);
-
-    ComAssertRet(!control.isNull(), E_INVALIDARG);
-
-    /* Creating a Progress object requires the VirtualBox lock, and
-     * thus locking it here is required by the lock order rules. */
-    AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
-
-    if (control == mData->mSession.mDirectControl)
-    {
-        ComAssertRet(aProgress, E_POINTER);
-
-        /* The direct session is being normally closed by the client process
-         * ----------------------------------------------------------------- */
-
-        /* go to the closing state (essential for all open*Session() calls and
-         * for #checkForDeath()) */
-        Assert(mData->mSession.mState == SessionState_Locked);
-        mData->mSession.mState = SessionState_Unlocking;
-
-        /* set direct control to NULL to release the remote instance */
-        mData->mSession.mDirectControl.setNull();
-        LogFlowThisFunc(("Direct control is set to NULL\n"));
-
-        if (mData->mSession.mProgress)
-        {
-            /* finalize the progress, someone might wait if a frontend
-             * closes the session before powering on the VM. */
-            mData->mSession.mProgress->notifyComplete(E_FAIL,
-                                                      COM_IIDOF(ISession),
-                                                      getComponentName(),
-                                                      tr("The VM session was closed before any attempt to power it on"));
-            mData->mSession.mProgress.setNull();
-        }
-
-        /*  Create the progress object the client will use to wait until
-         * #checkForDeath() is called to uninitialize this session object after
-         * it releases the IPC semaphore.
-         * Note! Because we're "reusing" mProgress here, this must be a proxy
-         *       object just like for LaunchVMProcess. */
-        Assert(mData->mSession.mProgress.isNull());
-        ComObjPtr<ProgressProxy> progress;
-        progress.createObject();
-        ComPtr<IUnknown> pPeer(mPeer);
-        progress->init(mParent, pPeer,
-                       Bstr(tr("Closing session")).raw(),
-                       FALSE /* aCancelable */);
-        progress.queryInterfaceTo(aProgress);
-        mData->mSession.mProgress = progress;
-    }
-    else
-    {
-        /* the remote session is being normally closed */
-        Data::Session::RemoteControlList::iterator it =
-            mData->mSession.mRemoteControls.begin();
-        while (it != mData->mSession.mRemoteControls.end())
-        {
-            if (control == *it)
-                break;
-            ++it;
-        }
-        BOOL found = it != mData->mSession.mRemoteControls.end();
-        ComAssertMsgRet(found, ("The session is not found in the session list!"),
-                         E_INVALIDARG);
-        // This MUST be erase(it), not remove(*it) as the latter triggers a
-        // very nasty use after free due to the place where the value "lives".
-        mData->mSession.mRemoteControls.erase(it);
-    }
-
-    /* signal the client watcher thread, because the client is going away */
-    mParent->updateClientWatcher();
-
-    LogFlowThisFuncLeave();
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::BeginSavingState(IProgress **aProgress, BSTR *aStateFilePath)
-{
-    LogFlowThisFuncEnter();
-
-    CheckComArgOutPointerValid(aProgress);
-    CheckComArgOutPointerValid(aStateFilePath);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(    mData->mMachineState == MachineState_Paused
-                  && mConsoleTaskData.mLastState == MachineState_Null
-                  && mConsoleTaskData.strStateFilePath.isEmpty(),
-                 E_FAIL);
-
-    /* create a progress object to track operation completion */
-    ComObjPtr<Progress> pProgress;
-    pProgress.createObject();
-    pProgress->init(getVirtualBox(),
-                    static_cast<IMachine *>(this) /* aInitiator */,
-                    Bstr(tr("Saving the execution state of the virtual machine")).raw(),
-                    FALSE /* aCancelable */);
-
-    Utf8Str strStateFilePath;
-    /* stateFilePath is null when the machine is not running */
-    if (mData->mMachineState == MachineState_Paused)
-        composeSavedStateFilename(strStateFilePath);
-
-    /* fill in the console task data */
-    mConsoleTaskData.mLastState = mData->mMachineState;
-    mConsoleTaskData.strStateFilePath = strStateFilePath;
-    mConsoleTaskData.mProgress = pProgress;
-
-    /* set the state to Saving (this is expected by Console::SaveState()) */
-    setMachineState(MachineState_Saving);
-
-    strStateFilePath.cloneTo(aStateFilePath);
-    pProgress.queryInterfaceTo(aProgress);
-
-    return S_OK;
-}
-
-/**
- *  @note Locks mParent + this object for writing.
- */
-STDMETHODIMP SessionMachine::EndSavingState(LONG iResult, IN_BSTR aErrMsg)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    /* endSavingState() need mParent lock */
-    AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(    (   (SUCCEEDED(iResult) && mData->mMachineState == MachineState_Saved)
-                      || (FAILED(iResult) && mData->mMachineState == MachineState_Saving))
-                  && mConsoleTaskData.mLastState != MachineState_Null
-                  && !mConsoleTaskData.strStateFilePath.isEmpty(),
-                 E_FAIL);
-
-    /*
-     * On failure, set the state to the state we had when BeginSavingState()
-     * was called (this is expected by Console::SaveState() and the associated
-     * task). On success the VM process already changed the state to
-     * MachineState_Saved, so no need to do anything.
-     */
-    if (FAILED(iResult))
-        setMachineState(mConsoleTaskData.mLastState);
-
-    return endSavingState(iResult, aErrMsg);
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP SessionMachine::AdoptSavedState(IN_BSTR aSavedStateFile)
-{
-    LogFlowThisFunc(("\n"));
-
-    CheckComArgStrNotEmptyOrNull(aSavedStateFile);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(   mData->mMachineState == MachineState_PoweredOff
-                 || mData->mMachineState == MachineState_Teleported
-                 || mData->mMachineState == MachineState_Aborted
-                 , E_FAIL); /** @todo setError. */
-
-    Utf8Str stateFilePathFull = aSavedStateFile;
-    int vrc = calculateFullPath(stateFilePathFull, stateFilePathFull);
-    if (RT_FAILURE(vrc))
-        return setError(VBOX_E_FILE_ERROR,
-                        tr("Invalid saved state file path '%ls' (%Rrc)"),
-                        aSavedStateFile,
-                        vrc);
-
-    mSSData->strStateFilePath = stateFilePathFull;
-
-    /* The below setMachineState() will detect the state transition and will
-     * update the settings file */
-
-    return setMachineState(MachineState_Saved);
-}
-
-STDMETHODIMP SessionMachine::PullGuestProperties(ComSafeArrayOut(BSTR, aNames),
-                                                 ComSafeArrayOut(BSTR, aValues),
-                                                 ComSafeArrayOut(LONG64, aTimestamps),
-                                                 ComSafeArrayOut(BSTR, aFlags))
-{
-    LogFlowThisFunc(("\n"));
-
-#ifdef VBOX_WITH_GUEST_PROPS
-    using namespace guestProp;
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    CheckComArgOutSafeArrayPointerValid(aNames);
-    CheckComArgOutSafeArrayPointerValid(aValues);
-    CheckComArgOutSafeArrayPointerValid(aTimestamps);
-    CheckComArgOutSafeArrayPointerValid(aFlags);
-
-    size_t cEntries = mHWData->mGuestProperties.size();
-    com::SafeArray<BSTR> names(cEntries);
-    com::SafeArray<BSTR> values(cEntries);
-    com::SafeArray<LONG64> timestamps(cEntries);
-    com::SafeArray<BSTR> flags(cEntries);
-    unsigned i = 0;
-    for (HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.begin();
-         it != mHWData->mGuestProperties.end();
-         ++it)
-    {
-        char szFlags[MAX_FLAGS_LEN + 1];
-        it->first.cloneTo(&names[i]);
-        it->second.strValue.cloneTo(&values[i]);
-        timestamps[i] = it->second.mTimestamp;
-        /* If it is NULL, keep it NULL. */
-        if (it->second.mFlags)
-        {
-            writeFlags(it->second.mFlags, szFlags);
-            Bstr(szFlags).cloneTo(&flags[i]);
-        }
-        else
-            flags[i] = NULL;
-        ++i;
-    }
-    names.detachTo(ComSafeArrayOutArg(aNames));
-    values.detachTo(ComSafeArrayOutArg(aValues));
-    timestamps.detachTo(ComSafeArrayOutArg(aTimestamps));
-    flags.detachTo(ComSafeArrayOutArg(aFlags));
-    return S_OK;
-#else
-    ReturnComNotImplemented();
-#endif
-}
-
-STDMETHODIMP SessionMachine::PushGuestProperty(IN_BSTR aName,
-                                               IN_BSTR aValue,
-                                               LONG64 aTimestamp,
-                                               IN_BSTR aFlags)
-{
-    LogFlowThisFunc(("\n"));
-
-#ifdef VBOX_WITH_GUEST_PROPS
-    using namespace guestProp;
-
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgNotNull(aValue);
-    CheckComArgNotNull(aFlags);
-
-    try
-    {
-        /*
-         * Convert input up front.
-         */
-        Utf8Str  utf8Name(aName);
-        uint32_t fFlags = NILFLAG;
-        if (aFlags)
-        {
-            Utf8Str utf8Flags(aFlags);
-            int vrc = validateFlags(utf8Flags.c_str(), &fFlags);
-            AssertRCReturn(vrc, E_INVALIDARG);
-        }
-
-        /*
-         * Now grab the object lock, validate the state and do the update.
-         */
-        AutoCaller autoCaller(this);
-        if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        switch (mData->mMachineState)
-        {
-            case MachineState_Paused:
-            case MachineState_Running:
-            case MachineState_Teleporting:
-            case MachineState_TeleportingPausedVM:
-            case MachineState_LiveSnapshotting:
-            case MachineState_DeletingSnapshotOnline:
-            case MachineState_DeletingSnapshotPaused:
-            case MachineState_Saving:
-            case MachineState_Stopping:
-                break;
-
-            default:
-                AssertMsgFailedReturn(("%s\n", Global::stringifyMachineState(mData->mMachineState)),
-                                      VBOX_E_INVALID_VM_STATE);
-        }
-
-        setModified(IsModified_MachineData);
-        mHWData.backup();
-
-        bool fDelete = !RT_VALID_PTR(aValue) || *(aValue) == '\0';
-        HWData::GuestPropertyMap::iterator it = mHWData->mGuestProperties.find(utf8Name);
-        if (it != mHWData->mGuestProperties.end())
-        {
-            if (!fDelete)
-            {
-                it->second.strValue   = aValue;
-                it->second.mTimestamp = aTimestamp;
-                it->second.mFlags     = fFlags;
-            }
-            else
-                mHWData->mGuestProperties.erase(it);
-
-            mData->mGuestPropertiesModified = TRUE;
-        }
-        else if (!fDelete)
-        {
-            HWData::GuestProperty prop;
-            prop.strValue   = aValue;
-            prop.mTimestamp = aTimestamp;
-            prop.mFlags     = fFlags;
-
-            mHWData->mGuestProperties[utf8Name] = prop;
-            mData->mGuestPropertiesModified = TRUE;
-        }
-
-        /*
-         * Send a callback notification if appropriate
-         */
-        if (    mHWData->mGuestPropertyNotificationPatterns.isEmpty()
-             || RTStrSimplePatternMultiMatch(mHWData->mGuestPropertyNotificationPatterns.c_str(),
-                                             RTSTR_MAX,
-                                             utf8Name.c_str(),
-                                             RTSTR_MAX, NULL)
-           )
-        {
-            alock.release();
-
-            mParent->onGuestPropertyChange(mData->mUuid,
-                                           aName,
-                                           aValue,
-                                           aFlags);
-        }
-    }
-    catch (...)
-    {
-        return VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-    return S_OK;
-#else
-    ReturnComNotImplemented();
-#endif
-}
-
-STDMETHODIMP SessionMachine::LockMedia()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoMultiWriteLock2 alock(this->lockHandle(),
-                              &mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    AssertReturn(   mData->mMachineState == MachineState_Starting
-                 || mData->mMachineState == MachineState_Restoring
-                 || mData->mMachineState == MachineState_TeleportingIn, E_FAIL);
-
-    clearError();
-    alock.release();
-    return lockMedia();
-}
-
-STDMETHODIMP SessionMachine::UnlockMedia()
-{
-    unlockMedia();
-    return S_OK;
-}
-
-STDMETHODIMP SessionMachine::EjectMedium(IMediumAttachment *aAttachment,
-                                         IMediumAttachment **aNewAttachment)
-{
-    CheckComArgNotNull(aAttachment);
-    CheckComArgOutPointerValid(aNewAttachment);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    // request the host lock first, since might be calling Host methods for getting host drives;
-    // next, protect the media tree all the while we're in here, as well as our member variables
-    AutoMultiWriteLock3 multiLock(mParent->host()->lockHandle(),
-                                  this->lockHandle(),
-                                  &mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    ComObjPtr<MediumAttachment> pAttach = static_cast<MediumAttachment *>(aAttachment);
-
-    Bstr ctrlName;
-    LONG lPort;
-    LONG lDevice;
-    bool fTempEject;
-    {
-        AutoCaller autoAttachCaller(this);
-        if (FAILED(autoAttachCaller.rc())) return autoAttachCaller.rc();
-
-        AutoReadLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-
-        /* Need to query the details first, as the IMediumAttachment reference
-         * might be to the original settings, which we are going to change. */
-        ctrlName = pAttach->getControllerName();
-        lPort = pAttach->getPort();
-        lDevice = pAttach->getDevice();
-        fTempEject = pAttach->getTempEject();
-    }
-
-    if (!fTempEject)
-    {
-        /* Remember previously mounted medium. The medium before taking the
-         * backup is not necessarily the same thing. */
-        ComObjPtr<Medium> oldmedium;
-        oldmedium = pAttach->getMedium();
-
-        setModified(IsModified_Storage);
-        mMediaData.backup();
-
-        // The backup operation makes the pAttach reference point to the
-        // old settings. Re-get the correct reference.
-        pAttach = findAttachment(mMediaData->mAttachments,
-                                 ctrlName.raw(),
-                                 lPort,
-                                 lDevice);
-
-        {
-            AutoCaller autoAttachCaller(this);
-            if (FAILED(autoAttachCaller.rc())) return autoAttachCaller.rc();
-
-            AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-            if (!oldmedium.isNull())
-                oldmedium->removeBackReference(mData->mUuid);
-
-            pAttach->updateMedium(NULL);
-            pAttach->updateEjected();
-        }
-
-        setModified(IsModified_Storage);
-    }
-    else
-    {
-        {
-            AutoWriteLock attLock(pAttach COMMA_LOCKVAL_SRC_POS);
-            pAttach->updateEjected();
-        }
-    }
-
-    pAttach.queryInterfaceTo(aNewAttachment);
-
-    return S_OK;
-}
-
-// public methods only for internal purposes
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- * Called from the client watcher thread to check for expected or unexpected
- * death of the client process that has a direct session to this machine.
- *
- * On Win32 and on OS/2, this method is called only when we've got the
- * mutex (i.e. the client has either died or terminated normally) so it always
- * returns @c true (the client is terminated, the session machine is
- * uninitialized).
- *
- * On other platforms, the method returns @c true if the client process has
- * terminated normally or abnormally and the session machine was uninitialized,
- * and @c false if the client process is still alive.
- *
- * @note Locks this object for writing.
- */
-bool SessionMachine::checkForDeath()
-{
-    Uninit::Reason reason;
-    bool terminated = false;
-
-    /* Enclose autoCaller with a block because calling uninit() from under it
-     * will deadlock. */
-    {
-        AutoCaller autoCaller(this);
-        if (!autoCaller.isOk())
-        {
-            /* return true if not ready, to cause the client watcher to exclude
-             * the corresponding session from watching */
-            LogFlowThisFunc(("Already uninitialized!\n"));
-            return true;
-        }
-
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        /* Determine the reason of death: if the session state is Closing here,
-         * everything is fine. Otherwise it means that the client did not call
-         * OnSessionEnd() before it released the IPC semaphore. This may happen
-         * either because the client process has abnormally terminated, or
-         * because it simply forgot to call ISession::Close() before exiting. We
-         * threat the latter also as an abnormal termination (see
-         * Session::uninit() for details). */
-        reason = mData->mSession.mState == SessionState_Unlocking ?
-                 Uninit::Normal :
-                 Uninit::Abnormal;
-
-#if defined(RT_OS_WINDOWS)
-
-        AssertMsg(mIPCSem, ("semaphore must be created"));
-
-        /* release the IPC mutex */
-        ::ReleaseMutex(mIPCSem);
-
-        terminated = true;
-
-#elif defined(RT_OS_OS2)
-
-        AssertMsg(mIPCSem, ("semaphore must be created"));
-
-        /* release the IPC mutex */
-        ::DosReleaseMutexSem(mIPCSem);
-
-        terminated = true;
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-        AssertMsg(mIPCSem >= 0, ("semaphore must be created"));
-
-        int val = ::semctl(mIPCSem, 0, GETVAL);
-        if (val > 0)
-        {
-            /* the semaphore is signaled, meaning the session is terminated */
-            terminated = true;
-        }
-
-#else
-# error "Port me!"
-#endif
-
-    } /* AutoCaller block */
-
-    if (terminated)
-        uninit(reason);
-
     return terminated;
 }
 
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onNetworkAdapterChange(INetworkAdapter *networkAdapter, BOOL changeAdapter)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnNetworkAdapterChange(networkAdapter, changeAdapter);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onNATRedirectRuleChange(ULONG ulSlot, BOOL aNatRuleRemove, IN_BSTR aRuleName,
-                                 NATProtocol_T aProto, IN_BSTR aHostIp, LONG aHostPort, IN_BSTR aGuestIp, LONG aGuestPort)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-    /*
-     * instead acting like callback we ask IVirtualBox deliver corresponding event
-     */
-
-    mParent->onNatRedirectChange(getId(), ulSlot, RT_BOOL(aNatRuleRemove), aRuleName, aProto, aHostIp, (uint16_t)aHostPort, aGuestIp, (uint16_t)aGuestPort);
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onSerialPortChange(ISerialPort *serialPort)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnSerialPortChange(serialPort);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onParallelPortChange(IParallelPort *parallelPort)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnParallelPortChange(parallelPort);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onStorageControllerChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnStorageControllerChange();
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onMediumChange(IMediumAttachment *aAttachment, BOOL aForce)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnMediumChange(aAttachment, aForce);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onCPUChange(ULONG aCPU, BOOL aRemove)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnCPUChange(aCPU, aRemove);
-}
-
-HRESULT SessionMachine::onCPUExecutionCapChange(ULONG aExecutionCap)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnCPUExecutionCapChange(aExecutionCap);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onVRDEServerChange(BOOL aRestart)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnVRDEServerChange(aRestart);
-}
-
-/**
- * @note Locks this object for reading.
- */
-HRESULT SessionMachine::onVideoCaptureChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnVideoCaptureChange();
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onUSBControllerChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnUSBControllerChange();
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onSharedFolderChange()
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnSharedFolderChange(FALSE /* aGlobal */);
-}
-
-/**
- * @note Locks this object for reading.
- */
-HRESULT SessionMachine::onClipboardModeChange(ClipboardMode_T aClipboardMode)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnClipboardModeChange(aClipboardMode);
-}
-
-/**
- * @note Locks this object for reading.
- */
-HRESULT SessionMachine::onDragAndDropModeChange(DragAndDropMode_T aDragAndDropMode)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturnRC(autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnDragAndDropModeChange(aDragAndDropMode);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onBandwidthGroupChange(IBandwidthGroup *aBandwidthGroup)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnBandwidthGroupChange(aBandwidthGroup);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-HRESULT SessionMachine::onStorageDeviceChange(IMediumAttachment *aAttachment, BOOL aRemove, BOOL aSilent)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* ignore notifications sent after #OnSessionEnd() is called */
-    if (!directControl)
-        return S_OK;
-
-    return directControl->OnStorageDeviceChange(aAttachment, aRemove, aSilent);
-}
-
-/**
- *  Returns @c true if this machine's USB controller reports it has a matching
- *  filter for the given USB device and @c false otherwise.
- *
- *  @note locks this object for reading.
- */
-bool SessionMachine::hasMatchingUSBFilter(const ComObjPtr<HostUSBDevice> &aDevice, ULONG *aMaskedIfs)
-{
-    AutoCaller autoCaller(this);
-    /* silently return if not ready -- this method may be called after the
-     * direct machine session has been called */
-    if (!autoCaller.isOk())
-        return false;
-
-#ifdef VBOX_WITH_USB
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    switch (mData->mMachineState)
-    {
-        case MachineState_Starting:
-        case MachineState_Restoring:
-        case MachineState_TeleportingIn:
-        case MachineState_Paused:
-        case MachineState_Running:
-        /** @todo Live Migration: snapshoting & teleporting. Need to fend things of
-         *        elsewhere... */
-            alock.release();
-            return mUSBDeviceFilters->hasMatchingFilter(aDevice, aMaskedIfs);
-        default: break;
-    }
-#else
-    NOREF(aDevice);
-    NOREF(aMaskedIfs);
-#endif
-    return false;
-}
-
-/**
- *  @note The calls shall hold no locks. Will temporarily lock this object for reading.
- */
-HRESULT SessionMachine::onUSBDeviceAttach(IUSBDevice *aDevice,
-                                          IVirtualBoxErrorInfo *aError,
-                                          ULONG aMaskedIfs)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-
-    /* This notification may happen after the machine object has been
-     * uninitialized (the session was closed), so don't assert. */
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* fail on notifications sent after #OnSessionEnd() is called, it is
-     * expected by the caller */
-    if (!directControl)
-        return E_FAIL;
-
-    /* No locks should be held at this point. */
-    AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
-    AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
-
-    return directControl->OnUSBDeviceAttach(aDevice, aError, aMaskedIfs);
-}
-
-/**
- *  @note The calls shall hold no locks. Will temporarily lock this object for reading.
- */
-HRESULT SessionMachine::onUSBDeviceDetach(IN_BSTR aId,
-                                          IVirtualBoxErrorInfo *aError)
-{
-    LogFlowThisFunc(("\n"));
-
-    AutoCaller autoCaller(this);
-
-    /* This notification may happen after the machine object has been
-     * uninitialized (the session was closed), so don't assert. */
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        directControl = mData->mSession.mDirectControl;
-    }
-
-    /* fail on notifications sent after #OnSessionEnd() is called, it is
-     * expected by the caller */
-    if (!directControl)
-        return E_FAIL;
-
-    /* No locks should be held at this point. */
-    AssertMsg(RTLockValidatorWriteLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorWriteLockGetCount(RTThreadSelf())));
-    AssertMsg(RTLockValidatorReadLockGetCount(RTThreadSelf()) == 0, ("%d\n", RTLockValidatorReadLockGetCount(RTThreadSelf())));
-
-    return directControl->OnUSBDeviceDetach(aId, aError);
-}
-
-// protected methods
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Helper method to finalize saving the state.
- *
- *  @note Must be called from under this object's lock.
- *
- *  @param aRc      S_OK if the snapshot has been taken successfully
- *  @param aErrMsg  human readable error message for failure
- *
- *  @note Locks mParent + this objects for writing.
- */
-HRESULT SessionMachine::endSavingState(HRESULT aRc, const Utf8Str &aErrMsg)
-{
-    LogFlowThisFuncEnter();
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-
-    if (SUCCEEDED(aRc))
-    {
-        mSSData->strStateFilePath = mConsoleTaskData.strStateFilePath;
-
-        /* save all VM settings */
-        rc = saveSettings(NULL);
-                // no need to check whether VirtualBox.xml needs saving also since
-                // we can't have a name change pending at this point
-    }
-    else
-    {
-        // delete the saved state file (it might have been already created);
-        // we need not check whether this is shared with a snapshot here because
-        // we certainly created this saved state file here anew
-        RTFileDelete(mConsoleTaskData.strStateFilePath.c_str());
-    }
-
-    /* notify the progress object about operation completion */
-    Assert(mConsoleTaskData.mProgress);
-    if (SUCCEEDED(aRc))
-        mConsoleTaskData.mProgress->notifyComplete(S_OK);
-    else
-    {
-        if (aErrMsg.length())
-            mConsoleTaskData.mProgress->notifyComplete(aRc,
-                                                       COM_IIDOF(ISession),
-                                                       getComponentName(),
-                                                       aErrMsg.c_str());
-        else
-            mConsoleTaskData.mProgress->notifyComplete(aRc);
-    }
-
-    /* clear out the temporary saved state data */
-    mConsoleTaskData.mLastState = MachineState_Null;
-    mConsoleTaskData.strStateFilePath.setNull();
-    mConsoleTaskData.mProgress.setNull();
-
-    LogFlowThisFuncLeave();
-    return rc;
-}
-
-/**
- * Deletes the given file if it is no longer in use by either the current machine state
- * (if the machine is "saved") or any of the machine's snapshots.
- *
- * Note: This checks mSSData->strStateFilePath, which is shared by the Machine and SessionMachine
- * but is different for each SnapshotMachine. When calling this, the order of calling this
- * function on the one hand and changing that variable OR the snapshots tree on the other hand
- * is therefore critical. I know, it's all rather messy.
- *
- * @param strStateFile
- * @param pSnapshotToIgnore  Passed to Snapshot::sharesSavedStateFile(); this snapshot is ignored in the test for whether the saved state file is in use.
- */
-void SessionMachine::releaseSavedStateFile(const Utf8Str &strStateFile,
-                                           Snapshot *pSnapshotToIgnore)
-{
-    // it is safe to delete this saved state file if it is not currently in use by the machine ...
-    if (    (strStateFile.isNotEmpty())
-         && (strStateFile != mSSData->strStateFilePath)     // session machine's saved state
-       )
-        // ... and it must also not be shared with other snapshots
-        if (    !mData->mFirstSnapshot
-             || !mData->mFirstSnapshot->sharesSavedStateFile(strStateFile, pSnapshotToIgnore)
-                                // this checks the SnapshotMachine's state file paths
-           )
-            RTFileDelete(strStateFile.c_str());
-}
-
-/**
- * Locks the attached media.
- *
- * All attached hard disks are locked for writing and DVD/floppy are locked for
- * reading. Parents of attached hard disks (if any) are locked for reading.
- *
- * This method also performs accessibility check of all media it locks: if some
- * media is inaccessible, the method will return a failure and a bunch of
- * extended error info objects per each inaccessible medium.
- *
- * Note that this method is atomic: if it returns a success, all media are
- * locked as described above; on failure no media is locked at all (all
- * succeeded individual locks will be undone).
- *
- * The caller is responsible for doing the necessary state sanity checks.
- *
- * The locks made by this method must be undone by calling #unlockMedia() when
- * no more needed.
- */
-HRESULT SessionMachine::lockMedia()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoMultiWriteLock2 alock(this->lockHandle(),
-                              &mParent->getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    /* bail out if trying to lock things with already set up locking */
-    AssertReturn(mData->mSession.mLockedMedia.IsEmpty(), E_FAIL);
-
-    MultiResult mrc(S_OK);
-
-    /* Collect locking information for all medium objects attached to the VM. */
-    for (MediaData::AttachmentList::const_iterator it = mMediaData->mAttachments.begin();
-         it != mMediaData->mAttachments.end();
-         ++it)
-    {
-        MediumAttachment* pAtt = *it;
-        DeviceType_T devType = pAtt->getType();
-        Medium *pMedium = pAtt->getMedium();
-
-        MediumLockList *pMediumLockList(new MediumLockList());
-        // There can be attachments without a medium (floppy/dvd), and thus
-        // it's impossible to create a medium lock list. It still makes sense
-        // to have the empty medium lock list in the map in case a medium is
-        // attached later.
-        if (pMedium != NULL)
-        {
-            MediumType_T mediumType = pMedium->getType();
-            bool fIsReadOnlyLock =    mediumType == MediumType_Readonly
-                                   || mediumType == MediumType_Shareable;
-            bool fIsVitalImage = (devType == DeviceType_HardDisk);
-
-            alock.release();
-            mrc = pMedium->createMediumLockList(fIsVitalImage /* fFailIfInaccessible */,
-                                                !fIsReadOnlyLock /* fMediumLockWrite */,
-                                                NULL,
-                                                *pMediumLockList);
-            alock.acquire();
-            if (FAILED(mrc))
-            {
-                delete pMediumLockList;
-                mData->mSession.mLockedMedia.Clear();
-                break;
-            }
-        }
-
-        HRESULT rc = mData->mSession.mLockedMedia.Insert(pAtt, pMediumLockList);
-        if (FAILED(rc))
-        {
-            mData->mSession.mLockedMedia.Clear();
-            mrc = setError(rc,
-                           tr("Collecting locking information for all attached media failed"));
-            break;
-        }
-    }
-
-    if (SUCCEEDED(mrc))
-    {
-        /* Now lock all media. If this fails, nothing is locked. */
-        alock.release();
-        HRESULT rc = mData->mSession.mLockedMedia.Lock();
-        alock.acquire();
-        if (FAILED(rc))
-        {
-            mrc = setError(rc,
-                           tr("Locking of attached media failed"));
-        }
-    }
-
-    return mrc;
-}
-
-/**
- * Undoes the locks made by by #lockMedia().
- */
-void SessionMachine::unlockMedia()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    /* we may be holding important error info on the current thread;
-     * preserve it */
-    ErrorInfoKeeper eik;
-
-    HRESULT rc = mData->mSession.mLockedMedia.Clear();
-    AssertComRC(rc);
-}
-
-/**
- * Helper to change the machine state (reimplementation).
- *
- * @note Locks this object for writing.
- * @note This method must not call saveSettings or SaveSettings, otherwise
- *       it can cause crashes in random places due to unexpectedly committing
- *       the current settings. The caller is responsible for that. The call
- *       to saveStateSettings is fine, because this method does not commit.
- */
-HRESULT SessionMachine::setMachineState(MachineState_T aMachineState)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aMachineState=%s\n", Global::stringifyMachineState(aMachineState) ));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    MachineState_T oldMachineState = mData->mMachineState;
-
-    AssertMsgReturn(oldMachineState != aMachineState,
-                    ("oldMachineState=%s, aMachineState=%s\n",
-                     Global::stringifyMachineState(oldMachineState), Global::stringifyMachineState(aMachineState)),
-                    E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    int stsFlags = 0;
-    bool deleteSavedState = false;
-
-    /* detect some state transitions */
-
-    if (   (   oldMachineState == MachineState_Saved
-            && aMachineState   == MachineState_Restoring)
-        || (   (   oldMachineState == MachineState_PoweredOff
-                || oldMachineState == MachineState_Teleported
-                || oldMachineState == MachineState_Aborted
-               )
-            && (   aMachineState   == MachineState_TeleportingIn
-                || aMachineState   == MachineState_Starting
-               )
-           )
-       )
-    {
-        /* The EMT thread is about to start */
-
-        /* Nothing to do here for now... */
-
-        /// @todo NEWMEDIA don't let mDVDDrive and other children
-        /// change anything when in the Starting/Restoring state
-    }
-    else if (   (   oldMachineState == MachineState_Running
-                 || oldMachineState == MachineState_Paused
-                 || oldMachineState == MachineState_Teleporting
-                 || oldMachineState == MachineState_LiveSnapshotting
-                 || oldMachineState == MachineState_Stuck
-                 || oldMachineState == MachineState_Starting
-                 || oldMachineState == MachineState_Stopping
-                 || oldMachineState == MachineState_Saving
-                 || oldMachineState == MachineState_Restoring
-                 || oldMachineState == MachineState_TeleportingPausedVM
-                 || oldMachineState == MachineState_TeleportingIn
-                 )
-             && (   aMachineState == MachineState_PoweredOff
-                 || aMachineState == MachineState_Saved
-                 || aMachineState == MachineState_Teleported
-                 || aMachineState == MachineState_Aborted
-                )
-             /* ignore PoweredOff->Saving->PoweredOff transition when taking a
-              * snapshot */
-             && (   mConsoleTaskData.mSnapshot.isNull()
-                 || mConsoleTaskData.mLastState >= MachineState_Running /** @todo Live Migration: clean up (lazy bird) */
-                )
-            )
-    {
-        /* The EMT thread has just stopped, unlock attached media. Note that as
-         * opposed to locking that is done from Console, we do unlocking here
-         * because the VM process may have aborted before having a chance to
-         * properly unlock all media it locked. */
-
-        unlockMedia();
-    }
-
-    if (oldMachineState == MachineState_Restoring)
-    {
-        if (aMachineState != MachineState_Saved)
-        {
-            /*
-             *  delete the saved state file once the machine has finished
-             *  restoring from it (note that Console sets the state from
-             *  Restoring to Saved if the VM couldn't restore successfully,
-             *  to give the user an ability to fix an error and retry --
-             *  we keep the saved state file in this case)
-             */
-            deleteSavedState = true;
-        }
-    }
-    else if (   oldMachineState == MachineState_Saved
-             && (   aMachineState == MachineState_PoweredOff
-                 || aMachineState == MachineState_Aborted
-                 || aMachineState == MachineState_Teleported
-                )
-            )
-    {
-        /*
-         *  delete the saved state after Console::ForgetSavedState() is called
-         *  or if the VM process (owning a direct VM session) crashed while the
-         *  VM was Saved
-         */
-
-        /// @todo (dmik)
-        //      Not sure that deleting the saved state file just because of the
-        //      client death before it attempted to restore the VM is a good
-        //      thing. But when it crashes we need to go to the Aborted state
-        //      which cannot have the saved state file associated... The only
-        //      way to fix this is to make the Aborted condition not a VM state
-        //      but a bool flag: i.e., when a crash occurs, set it to true and
-        //      change the state to PoweredOff or Saved depending on the
-        //      saved state presence.
-
-        deleteSavedState = true;
-        mData->mCurrentStateModified = TRUE;
-        stsFlags |= SaveSTS_CurStateModified;
-    }
-
-    if (   aMachineState == MachineState_Starting
-        || aMachineState == MachineState_Restoring
-        || aMachineState == MachineState_TeleportingIn
-       )
-    {
-        /* set the current state modified flag to indicate that the current
-         * state is no more identical to the state in the
-         * current snapshot */
-        if (!mData->mCurrentSnapshot.isNull())
-        {
-            mData->mCurrentStateModified = TRUE;
-            stsFlags |= SaveSTS_CurStateModified;
-        }
-    }
-
-    if (deleteSavedState)
-    {
-        if (mRemoveSavedState)
-        {
-            Assert(!mSSData->strStateFilePath.isEmpty());
-
-            // it is safe to delete the saved state file if ...
-            if (    !mData->mFirstSnapshot      // ... we have no snapshots or
-                 || !mData->mFirstSnapshot->sharesSavedStateFile(mSSData->strStateFilePath, NULL /* pSnapshotToIgnore */)
-                                                // ... none of the snapshots share the saved state file
-               )
-                RTFileDelete(mSSData->strStateFilePath.c_str());
-        }
-
-        mSSData->strStateFilePath.setNull();
-        stsFlags |= SaveSTS_StateFilePath;
-    }
-
-    /* redirect to the underlying peer machine */
-    mPeer->setMachineState(aMachineState);
-
-    if (   aMachineState == MachineState_PoweredOff
-        || aMachineState == MachineState_Teleported
-        || aMachineState == MachineState_Aborted
-        || aMachineState == MachineState_Saved)
-    {
-        /* the machine has stopped execution
-         * (or the saved state file was adopted) */
-        stsFlags |= SaveSTS_StateTimeStamp;
-    }
-
-    if (   (   oldMachineState == MachineState_PoweredOff
-            || oldMachineState == MachineState_Aborted
-            || oldMachineState == MachineState_Teleported
-           )
-        && aMachineState == MachineState_Saved)
-    {
-        /* the saved state file was adopted */
-        Assert(!mSSData->strStateFilePath.isEmpty());
-        stsFlags |= SaveSTS_StateFilePath;
-    }
-
-#ifdef VBOX_WITH_GUEST_PROPS
-    if (   aMachineState == MachineState_PoweredOff
-        || aMachineState == MachineState_Aborted
-        || aMachineState == MachineState_Teleported)
-    {
-        /* Make sure any transient guest properties get removed from the
-         * property store on shutdown. */
-
-        HWData::GuestPropertyMap::const_iterator it;
-        BOOL fNeedsSaving = mData->mGuestPropertiesModified;
-        if (!fNeedsSaving)
-            for (it = mHWData->mGuestProperties.begin();
-                 it != mHWData->mGuestProperties.end(); ++it)
-                if (   (it->second.mFlags & guestProp::TRANSIENT)
-                    || (it->second.mFlags & guestProp::TRANSRESET))
-                {
-                    fNeedsSaving = true;
-                    break;
-                }
-        if (fNeedsSaving)
-        {
-            mData->mCurrentStateModified = TRUE;
-            stsFlags |= SaveSTS_CurStateModified;
-        }
-    }
-#endif
-
-    rc = saveStateSettings(stsFlags);
-
-    if (   (   oldMachineState != MachineState_PoweredOff
-            && oldMachineState != MachineState_Aborted
-            && oldMachineState != MachineState_Teleported
-           )
-        && (   aMachineState == MachineState_PoweredOff
-            || aMachineState == MachineState_Aborted
-            || aMachineState == MachineState_Teleported
-           )
-       )
-    {
-        /* we've been shut down for any reason */
-        /* no special action so far */
-    }
-
-    LogFlowThisFunc(("rc=%Rhrc [%s]\n", rc, Global::stringifyMachineState(mData->mMachineState) ));
-    LogFlowThisFuncLeave();
-    return rc;
-}
-
-/**
- *  Sends the current machine state value to the VM process.
- *
- *  @note Locks this object for reading, then calls a client process.
- */
-HRESULT SessionMachine::updateMachineStateOnClient()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    ComPtr<IInternalSessionControl> directControl;
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-        AssertReturn(!!mData, E_FAIL);
-        directControl = mData->mSession.mDirectControl;
-
-        /* directControl may be already set to NULL here in #OnSessionEnd()
-         * called too early by the direct session process while there is still
-         * some operation (like deleting the snapshot) in progress. The client
-         * process in this case is waiting inside Session::close() for the
-         * "end session" process object to complete, while #uninit() called by
-         * #checkForDeath() on the Watcher thread is waiting for the pending
-         * operation to complete. For now, we accept this inconsistent behavior
-         * and simply do nothing here. */
-
-        if (mData->mSession.mState == SessionState_Unlocking)
-            return S_OK;
-
-        AssertReturn(!directControl.isNull(), E_FAIL);
-    }
-
-    return directControl->UpdateMachineState(mData->mMachineState);
-}
+/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -1 @@
-/* $Id$ */
 /** @file
- * Implementation of IVirtualBox in VBoxSVC.
+ *
+ * VirtualBox API client crash watcher
  */
 
@@ -17 +17 @@
 
 #include <iprt/asm.h>
-#include <iprt/base64.h>
-#include <iprt/buildconfig.h>
-#include <iprt/cpp/utils.h>
-#include <iprt/dir.h>
-#include <iprt/env.h>
-#include <iprt/file.h>
-#include <iprt/path.h>
+#include <iprt/assert.h>
+#include <iprt/log.h>
+#include <iprt/semaphore.h>
 #include <iprt/process.h>
-#include <iprt/rand.h>
-#include <iprt/sha.h>
-#include <iprt/string.h>
-#include <iprt/stream.h>
-#include <iprt/thread.h>
-#include <iprt/uuid.h>
-#include <iprt/cpp/xml.h>
-
-#include <VBox/com/com.h>
-#include <VBox/com/array.h>
-#include "VBox/com/EventQueue.h"
-
-#include <VBox/err.h>
-#include <VBox/param.h>
-#include <VBox/settings.h>
-#include <VBox/version.h>
-
-#include <package-generated.h>
-
-#include <algorithm>
-#include <set>
+
+#include <VBox/com/defs.h>
+
 #include <vector>
-#include <memory> // for auto_ptr
-
+
+#include "VirtualBoxBase.h"
+#include "AutoCaller.h"
+#include "ClientWatcher.h"
+#include "ClientToken.h"
 #include "VirtualBoxImpl.h"
-
-#include "Global.h"
 #include "MachineImpl.h"
-#include "MediumImpl.h"
-#include "SharedFolderImpl.h"
-#include "ProgressImpl.h"
-#include "ProgressProxyImpl.h"
-#include "HostImpl.h"
-#include "USBControllerImpl.h"
-#include "SystemPropertiesImpl.h"
-#include "GuestOSTypeImpl.h"
-#include "NetworkServiceRunner.h"
-#include "DHCPServerImpl.h"
-#include "NATNetworkImpl.h"
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-# include "PerformanceImpl.h"
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-#include "EventImpl.h"
-#include "VBoxEvents.h"
-#ifdef VBOX_WITH_EXTPACK
-# include "ExtPackManagerImpl.h"
-#endif
-#include "AutostartDb.h"
-
-#include "AutoCaller.h"
-#include "Logging.h"
-#include "objectslist.h"
-
-#ifdef RT_OS_WINDOWS
-# include "win/svchlp.h"
-# include "win/VBoxComEvents.h"
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Definitions
-//
-////////////////////////////////////////////////////////////////////////////////
-
-#define VBOX_GLOBAL_SETTINGS_FILE "VirtualBox.xml"
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// Global variables
-//
-////////////////////////////////////////////////////////////////////////////////
-
-// static
-Bstr VirtualBox::sVersion;
-
-// static
-Bstr VirtualBox::sVersionNormalized;
-
-// static
-ULONG VirtualBox::sRevision;
-
-// static
-Bstr VirtualBox::sPackageType;
-
-// static
-Bstr VirtualBox::sAPIVersion;
 
 #ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-/** Table for adaptive timeouts in the client watcher. The counter starts at
- * the maximum value and decreases to 0. */
-static const RTMSINTERVAL s_updateAdaptTimeouts[] = { 500, 200, 100, 50, 20, 10, 5 };
-#endif
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// CallbackEvent class
-//
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Abstract callback event class to asynchronously call VirtualBox callbacks
- *  on a dedicated event thread. Subclasses reimplement #handleCallback()
- *  to call appropriate IVirtualBoxCallback methods depending on the event
- *  to be dispatched.
- *
- *  @note The VirtualBox instance passed to the constructor is strongly
- *  referenced, so that the VirtualBox singleton won't be released until the
- *  event gets handled by the event thread.
- */
-class VirtualBox::CallbackEvent : public Event
+/** Table for adaptive timeouts. After an update the counter starts at the
+ * maximum value and decreases to 0, i.e. first the short timeouts are used
+ * and then the longer ones. This minimizes the detection latency in the
+ * cases where a change is expected, for crashes. */
+static const RTMSINTERVAL s_aUpdateTimeoutSteps[] = { 500, 200, 100, 50, 20, 10, 5 };
+#endif
+
+
+
+VirtualBox::ClientWatcher::ClientWatcher() :
+    mLock(LOCKCLASS_OBJECTSTATE)
 {
-public:
-
-    CallbackEvent(VirtualBox *aVirtualBox, VBoxEventType_T aWhat)
-        : mVirtualBox(aVirtualBox), mWhat(aWhat)
+    AssertReleaseFailed();
+}
+
+VirtualBox::ClientWatcher::~ClientWatcher()
+{
+    if (mThread != NIL_RTTHREAD)
     {
-        Assert(aVirtualBox);
+        /* signal the client watcher thread, should be exiting now */
+        update();
+        /* wait for termination */
+        RTThreadWait(mThread, RT_INDEFINITE_WAIT, NULL);
+        mThread = NIL_RTTHREAD;
     }
-
-    void *handler();
-
-    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc) = 0;
-
-private:
-
-    /**
-     *  Note that this is a weak ref -- the CallbackEvent handler thread
-     *  is bound to the lifetime of the VirtualBox instance, so it's safe.
-     */
-    VirtualBox         *mVirtualBox;
-protected:
-    VBoxEventType_T     mWhat;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// VirtualBox private member data definition
-//
-////////////////////////////////////////////////////////////////////////////////
-
+    mProcesses.clear();
 #if defined(RT_OS_WINDOWS)
-    #define UPDATEREQARG NULL
-    #define UPDATEREQTYPE HANDLE
-#elif defined(RT_OS_OS2)
-    #define UPDATEREQARG NIL_RTSEMEVENT
-    #define UPDATEREQTYPE RTSEMEVENT
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    #define UPDATEREQARG
-    #define UPDATEREQTYPE RTSEMEVENT
-#else
-# error "Port me!"
-#endif
-
-typedef ObjectsList<Machine> MachinesOList;
-typedef ObjectsList<Medium> MediaOList;
-typedef ObjectsList<GuestOSType> GuestOSTypesOList;
-typedef ObjectsList<SharedFolder> SharedFoldersOList;
-typedef ObjectsList<DHCPServer> DHCPServersOList;
-typedef ObjectsList<NATNetwork> NATNetworksOList;
-
-typedef std::map<Guid, ComPtr<IProgress> > ProgressMap;
-typedef std::map<Guid, ComObjPtr<Medium> > HardDiskMap;
-
-/**
- *  Main VirtualBox data structure.
- *  @note |const| members are persistent during lifetime so can be accessed
- *  without locking.
- */
-struct VirtualBox::Data
-{
-    Data()
-        : pMainConfigFile(NULL),
-          uuidMediaRegistry("48024e5c-fdd9-470f-93af-ec29f7ea518c"),
-          uRegistryNeedsSaving(0),
-          lockMachines(LOCKCLASS_LISTOFMACHINES),
-          allMachines(lockMachines),
-          lockGuestOSTypes(LOCKCLASS_LISTOFOTHEROBJECTS),
-          allGuestOSTypes(lockGuestOSTypes),
-          lockMedia(LOCKCLASS_LISTOFMEDIA),
-          allHardDisks(lockMedia),
-          allDVDImages(lockMedia),
-          allFloppyImages(lockMedia),
-          lockSharedFolders(LOCKCLASS_LISTOFOTHEROBJECTS),
-          allSharedFolders(lockSharedFolders),
-          lockDHCPServers(LOCKCLASS_LISTOFOTHEROBJECTS),
-          allDHCPServers(lockDHCPServers),
-          lockNATNetworks(LOCKCLASS_LISTOFOTHEROBJECTS),
-          allNATNetworks(lockNATNetworks),
-          mtxProgressOperations(LOCKCLASS_PROGRESSLIST),
-          updateReq(UPDATEREQARG),
-          threadClientWatcher(NIL_RTTHREAD),
-          threadAsyncEvent(NIL_RTTHREAD),
-          pAsyncEventQ(NULL),
-          pAutostartDb(NULL),
-          fSettingsCipherKeySet(false)
+    if (mUpdateReq != NULL)
     {
+        ::CloseHandle(mUpdateReq);
+        mUpdateReq = NULL;
     }
-
-    ~Data()
+#elif defined(RT_OS_OS2) || defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+    if (mUpdateReq != NIL_RTSEMEVENT)
     {
-        if (pMainConfigFile)
-        {
-            delete pMainConfigFile;
-            pMainConfigFile = NULL;
-        }
-    };
-
-    // const data members not requiring locking
-    const Utf8Str                       strHomeDir;
-
-    // VirtualBox main settings file
-    const Utf8Str                       strSettingsFilePath;
-    settings::MainConfigFile            *pMainConfigFile;
-
-    // constant pseudo-machine ID for global media registry
-    const Guid                          uuidMediaRegistry;
-
-    // counter if global media registry needs saving, updated using atomic
-    // operations, without requiring any locks
-    uint64_t                            uRegistryNeedsSaving;
-
-    // const objects not requiring locking
-    const ComObjPtr<Host>               pHost;
-    const ComObjPtr<SystemProperties>   pSystemProperties;
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-    const ComObjPtr<PerformanceCollector> pPerformanceCollector;
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-    // Each of the following lists use a particular lock handle that protects the
-    // list as a whole. As opposed to version 3.1 and earlier, these lists no
-    // longer need the main VirtualBox object lock, but only the respective list
-    // lock. In each case, the locking order is defined that the list must be
-    // requested before object locks of members of the lists (see the order definitions
-    // in AutoLock.h; e.g. LOCKCLASS_LISTOFMACHINES before LOCKCLASS_MACHINEOBJECT).
-    RWLockHandle                        lockMachines;
-    MachinesOList                       allMachines;
-
-    RWLockHandle                        lockGuestOSTypes;
-    GuestOSTypesOList                   allGuestOSTypes;
-
-    // All the media lists are protected by the following locking handle:
-    RWLockHandle                        lockMedia;
-    MediaOList                          allHardDisks,           // base images only!
-                                        allDVDImages,
-                                        allFloppyImages;
-    // the hard disks map is an additional map sorted by UUID for quick lookup
-    // and contains ALL hard disks (base and differencing); it is protected by
-    // the same lock as the other media lists above
-    HardDiskMap                         mapHardDisks;
-
-    // list of pending machine renames (also protected by media tree lock;
-    // see VirtualBox::rememberMachineNameChangeForMedia())
-    struct PendingMachineRename
-    {
-        Utf8Str     strConfigDirOld;
-        Utf8Str     strConfigDirNew;
-    };
-    typedef std::list<PendingMachineRename> PendingMachineRenamesList;
-    PendingMachineRenamesList           llPendingMachineRenames;
-
-    RWLockHandle                        lockSharedFolders;
-    SharedFoldersOList                  allSharedFolders;
-
-    RWLockHandle                        lockDHCPServers;
-    DHCPServersOList                    allDHCPServers;
-    
-    RWLockHandle                         lockNATNetworks;
-    NATNetworksOList                     allNATNetworks;
-
-    RWLockHandle                        mtxProgressOperations;
-    ProgressMap                         mapProgressOperations;
-
-    // the following are data for the client watcher thread
-    const UPDATEREQTYPE                 updateReq;
-#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-    uint8_t                             updateAdaptCtr;
-#endif
-    const RTTHREAD                      threadClientWatcher;
-    typedef std::list<RTPROCESS> ProcessList;
-    ProcessList                         llProcesses;
-
-    // the following are data for the async event thread
-    const RTTHREAD                      threadAsyncEvent;
-    EventQueue * const                  pAsyncEventQ;
-    const ComObjPtr<EventSource>        pEventSource;
-
-#ifdef VBOX_WITH_EXTPACK
-    /** The extension pack manager object lives here. */
-    const ComObjPtr<ExtPackManager>     ptrExtPackManager;
-#endif
-
-    /** The global autostart database for the user. */
-    AutostartDb * const                 pAutostartDb;
-
-    /** Settings secret */
-    bool                                fSettingsCipherKeySet;
-    uint8_t                             SettingsCipherKey[RTSHA512_HASH_SIZE];
-};
-
-
-// constructor / destructor
-/////////////////////////////////////////////////////////////////////////////
-
-VirtualBox::VirtualBox()
-{}
-
-VirtualBox::~VirtualBox()
-{}
-
-HRESULT VirtualBox::FinalConstruct()
-{
-    LogFlowThisFunc(("\n"));
-
-    HRESULT rc = init();
-
-    BaseFinalConstruct();
-
-    return rc;
-}
-
-void VirtualBox::FinalRelease()
-{
-    LogFlowThisFunc(("\n"));
-
-    uninit();
-
-    BaseFinalRelease();
-}
-
-// public initializer/uninitializer for internal purposes only
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Initializes the VirtualBox object.
- *
- *  @return COM result code
- */
-HRESULT VirtualBox::init()
-{
-    /* Enclose the state transition NotReady->InInit->Ready */
-    AutoInitSpan autoInitSpan(this);
-    AssertReturn(autoInitSpan.isOk(), E_FAIL);
-
-    /* Locking this object for writing during init sounds a bit paradoxical,
-     * but in the current locking mess this avoids that some code gets a
-     * read lock and later calls code which wants the same write lock. */
-    AutoWriteLock lock(this COMMA_LOCKVAL_SRC_POS);
-
-    // allocate our instance data
-    m = new Data;
-
-    LogFlow(("===========================================================\n"));
-    LogFlowThisFuncEnter();
-
-    if (sVersion.isEmpty())
-        sVersion = RTBldCfgVersion();
-    if (sVersionNormalized.isEmpty())
-    {
-        Utf8Str tmp(RTBldCfgVersion());
-        if (tmp.endsWith(VBOX_BUILD_PUBLISHER))
-            tmp = tmp.substr(0, tmp.length() - strlen(VBOX_BUILD_PUBLISHER));
-        sVersionNormalized = tmp;
-    }
-    sRevision = RTBldCfgRevision();
-    if (sPackageType.isEmpty())
-        sPackageType = VBOX_PACKAGE_STRING;
-    if (sAPIVersion.isEmpty())
-        sAPIVersion = VBOX_API_VERSION_STRING;
-    LogFlowThisFunc(("Version: %ls, Package: %ls, API Version: %ls\n", sVersion.raw(), sPackageType.raw(), sAPIVersion.raw()));
-
-    /* Get the VirtualBox home directory. */
-    {
-        char szHomeDir[RTPATH_MAX];
-        int vrc = com::GetVBoxUserHomeDirectory(szHomeDir, sizeof(szHomeDir));
-        if (RT_FAILURE(vrc))
-            return setError(E_FAIL,
-                            tr("Could not create the VirtualBox home directory '%s' (%Rrc)"),
-                            szHomeDir, vrc);
-
-        unconst(m->strHomeDir) = szHomeDir;
-    }
-
-    /* compose the VirtualBox.xml file name */
-    unconst(m->strSettingsFilePath) = Utf8StrFmt("%s%c%s",
-                                                 m->strHomeDir.c_str(),
-                                                 RTPATH_DELIMITER,
-                                                 VBOX_GLOBAL_SETTINGS_FILE);
-    HRESULT rc = S_OK;
-    bool fCreate = false;
-    try
-    {
-        // load and parse VirtualBox.xml; this will throw on XML or logic errors
-        try
-        {
-            m->pMainConfigFile = new settings::MainConfigFile(&m->strSettingsFilePath);
-        }
-        catch (xml::EIPRTFailure &e)
-        {
-            // this is thrown by the XML backend if the RTOpen() call fails;
-            // only if the main settings file does not exist, create it,
-            // if there's something more serious, then do fail!
-            if (e.rc() == VERR_FILE_NOT_FOUND)
-                fCreate = true;
-            else
-                throw;
-        }
-
-        if (fCreate)
-            m->pMainConfigFile = new settings::MainConfigFile(NULL);
-
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-        /* create the performance collector object BEFORE host */
-        unconst(m->pPerformanceCollector).createObject();
-        rc = m->pPerformanceCollector->init();
-        ComAssertComRCThrowRC(rc);
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-        /* create the host object early, machines will need it */
-        unconst(m->pHost).createObject();
-        rc = m->pHost->init(this);
-        ComAssertComRCThrowRC(rc);
-
-        rc = m->pHost->loadSettings(m->pMainConfigFile->host);
-        if (FAILED(rc)) throw rc;
-
-        /*
-         * Create autostart database object early, because the system properties
-         * might need it.
-         */
-        unconst(m->pAutostartDb) = new AutostartDb;
-
-        /* create the system properties object, someone may need it too */
-        unconst(m->pSystemProperties).createObject();
-        rc = m->pSystemProperties->init(this);
-        ComAssertComRCThrowRC(rc);
-
-        rc = m->pSystemProperties->loadSettings(m->pMainConfigFile->systemProperties);
-        if (FAILED(rc)) throw rc;
-
-        /* guest OS type objects, needed by machines */
-        for (size_t i = 0; i < Global::cOSTypes; ++i)
-        {
-            ComObjPtr<GuestOSType> guestOSTypeObj;
-            rc = guestOSTypeObj.createObject();
-            if (SUCCEEDED(rc))
-            {
-                rc = guestOSTypeObj->init(Global::sOSTypes[i]);
-                if (SUCCEEDED(rc))
-                    m->allGuestOSTypes.addChild(guestOSTypeObj);
-            }
-            ComAssertComRCThrowRC(rc);
-        }
-
-        /* all registered media, needed by machines */
-        if (FAILED(rc = initMedia(m->uuidMediaRegistry,
-                                  m->pMainConfigFile->mediaRegistry,
-                                  Utf8Str::Empty)))     // const Utf8Str &machineFolder
-            throw rc;
-
-        /* machines */
-        if (FAILED(rc = initMachines()))
-            throw rc;
-
-#ifdef DEBUG
-        LogFlowThisFunc(("Dumping media backreferences\n"));
-        dumpAllBackRefs();
-#endif
-
-        /* net services - dhcp services */
-        for (settings::DHCPServersList::const_iterator it = m->pMainConfigFile->llDhcpServers.begin();
-             it != m->pMainConfigFile->llDhcpServers.end();
-             ++it)
-        {
-            const settings::DHCPServer &data = *it;
-
-            ComObjPtr<DHCPServer> pDhcpServer;
-            if (SUCCEEDED(rc = pDhcpServer.createObject()))
-                rc = pDhcpServer->init(this, data);
-            if (FAILED(rc)) throw rc;
-
-            rc = registerDHCPServer(pDhcpServer, false /* aSaveRegistry */);
-            if (FAILED(rc)) throw rc;
-        }
-
-        /* net services - nat networks */
-        for (settings::NATNetworksList::const_iterator it = m->pMainConfigFile->llNATNetworks.begin();
-             it != m->pMainConfigFile->llNATNetworks.end();
-             ++it)
-        {
-            const settings::NATNetwork &net = *it;
-
-            ComObjPtr<NATNetwork> pNATNetwork;
-            if (SUCCEEDED(rc = pNATNetwork.createObject()))
-                rc = pNATNetwork->init(this, net);
-            if (FAILED(rc)) throw rc;
-
-            rc = registerNATNetwork(pNATNetwork, false /* aSaveRegistry */);
-            if (FAILED(rc)) throw rc;
-        }
-
-        /* events */
-        if (SUCCEEDED(rc = unconst(m->pEventSource).createObject()))
-            rc = m->pEventSource->init(static_cast<IVirtualBox*>(this));
-        if (FAILED(rc)) throw rc;
-
-#ifdef VBOX_WITH_EXTPACK
-        /* extension manager */
-        rc = unconst(m->ptrExtPackManager).createObject();
-        if (SUCCEEDED(rc))
-            rc = m->ptrExtPackManager->initExtPackManager(this, VBOXEXTPACKCTX_PER_USER_DAEMON);
-        if (FAILED(rc))
-            throw rc;
-#endif
-    }
-    catch (HRESULT err)
-    {
-        /* we assume that error info is set by the thrower */
-        rc = err;
-    }
-    catch (...)
-    {
-        rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        /* start the client watcher thread */
-#if defined(RT_OS_WINDOWS)
-        unconst(m->updateReq) = ::CreateEvent(NULL, FALSE, FALSE, NULL);
-#elif defined(RT_OS_OS2)
-        RTSemEventCreate(&unconst(m->updateReq));
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-        RTSemEventCreate(&unconst(m->updateReq));
-        ASMAtomicUoWriteU8(&m->updateAdaptCtr, 0);
-#else
-# error "Port me!"
-#endif
-        int vrc = RTThreadCreate(&unconst(m->threadClientWatcher),
-                                 ClientWatcher,
-                                 (void *)this,
-                                 0,
-                                 RTTHREADTYPE_MAIN_WORKER,
-                                 RTTHREADFLAGS_WAITABLE,
-                                 "Watcher");
-        ComAssertRC(vrc);
-        if (RT_FAILURE(vrc))
-            rc = E_FAIL;
-    }
-
-    if (SUCCEEDED(rc))
-    {
-        try
-        {
-            /* start the async event handler thread */
-            int vrc = RTThreadCreate(&unconst(m->threadAsyncEvent),
-                                     AsyncEventHandler,
-                                     &unconst(m->pAsyncEventQ),
-                                     0,
-                                     RTTHREADTYPE_MAIN_WORKER,
-                                     RTTHREADFLAGS_WAITABLE,
-                                     "EventHandler");
-            ComAssertRCThrow(vrc, E_FAIL);
-
-            /* wait until the thread sets m->pAsyncEventQ */
-            RTThreadUserWait(m->threadAsyncEvent, RT_INDEFINITE_WAIT);
-            ComAssertThrow(m->pAsyncEventQ, E_FAIL);
-        }
-        catch (HRESULT aRC)
-        {
-            rc = aRC;
-        }
-    }
-
-    /* Confirm a successful initialization when it's the case */
-    if (SUCCEEDED(rc))
-        autoInitSpan.setSucceeded();
-
-#ifdef VBOX_WITH_EXTPACK
-    /* Let the extension packs have a go at things. */
-    if (SUCCEEDED(rc))
-    {
-        lock.release();
-        m->ptrExtPackManager->callAllVirtualBoxReadyHooks();
-    }
-#endif
-
-    LogFlowThisFunc(("rc=%08X\n", rc));
-    LogFlowThisFuncLeave();
-    LogFlow(("===========================================================\n"));
-    return rc;
-}
-
-HRESULT VirtualBox::initMachines()
-{
-    for (settings::MachinesRegistry::const_iterator it = m->pMainConfigFile->llMachines.begin();
-         it != m->pMainConfigFile->llMachines.end();
-         ++it)
-    {
-        HRESULT rc = S_OK;
-        const settings::MachineRegistryEntry &xmlMachine = *it;
-        Guid uuid = xmlMachine.uuid;
-
-        ComObjPtr<Machine> pMachine;
-        if (SUCCEEDED(rc = pMachine.createObject()))
-        {
-            rc = pMachine->initFromSettings(this,
-                                            xmlMachine.strSettingsFile,
-                                            &uuid);
-            if (SUCCEEDED(rc))
-                rc = registerMachine(pMachine);
-            if (FAILED(rc))
-                return rc;
-        }
-    }
-
-    return S_OK;
-}
-
-/**
- * Loads a media registry from XML and adds the media contained therein to
- * the global lists of known media.
- *
- * This now (4.0) gets called from two locations:
- *
- *  --  VirtualBox::init(), to load the global media registry from VirtualBox.xml;
- *
- *  --  Machine::loadMachineDataFromSettings(), to load the per-machine registry
- *      from machine XML, for machines created with VirtualBox 4.0 or later.
- *
- * In both cases, the media found are added to the global lists so the
- * global arrays of media (including the GUI's virtual media manager)
- * continue to work as before.
- *
- * @param uuidMachineRegistry The UUID of the media registry. This is either the
- *       transient UUID created at VirtualBox startup for the global registry or
- *       a machine ID.
- * @param mediaRegistry The XML settings structure to load, either from VirtualBox.xml
- *       or a machine XML.
- * @return
- */
-HRESULT VirtualBox::initMedia(const Guid &uuidRegistry,
-                              const settings::MediaRegistry mediaRegistry,
-                              const Utf8Str &strMachineFolder)
-{
-    LogFlow(("VirtualBox::initMedia ENTERING, uuidRegistry=%s, strMachineFolder=%s\n",
-             uuidRegistry.toString().c_str(),
-             strMachineFolder.c_str()));
-
-    AutoWriteLock treeLock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-    settings::MediaList::const_iterator it;
-    for (it = mediaRegistry.llHardDisks.begin();
-         it != mediaRegistry.llHardDisks.end();
-         ++it)
-    {
-        const settings::Medium &xmlHD = *it;
-
-        ComObjPtr<Medium> pHardDisk;
-        if (SUCCEEDED(rc = pHardDisk.createObject()))
-            rc = pHardDisk->init(this,
-                                 NULL,          // parent
-                                 DeviceType_HardDisk,
-                                 uuidRegistry,
-                                 xmlHD,         // XML data; this recurses to processes the children
-                                 strMachineFolder);
-        if (FAILED(rc)) return rc;
-
-        rc = registerMedium(pHardDisk, &pHardDisk, DeviceType_HardDisk);
-        if (FAILED(rc)) return rc;
-    }
-
-    for (it = mediaRegistry.llDvdImages.begin();
-         it != mediaRegistry.llDvdImages.end();
-         ++it)
-    {
-        const settings::Medium &xmlDvd = *it;
-
-        ComObjPtr<Medium> pImage;
-        if (SUCCEEDED(pImage.createObject()))
-            rc = pImage->init(this,
-                              NULL,
-                              DeviceType_DVD,
-                              uuidRegistry,
-                              xmlDvd,
-                              strMachineFolder);
-        if (FAILED(rc)) return rc;
-
-        rc = registerMedium(pImage, &pImage, DeviceType_DVD);
-        if (FAILED(rc)) return rc;
-    }
-
-    for (it = mediaRegistry.llFloppyImages.begin();
-         it != mediaRegistry.llFloppyImages.end();
-         ++it)
-    {
-        const settings::Medium &xmlFloppy = *it;
-
-        ComObjPtr<Medium> pImage;
-        if (SUCCEEDED(pImage.createObject()))
-            rc = pImage->init(this,
-                              NULL,
-                              DeviceType_Floppy,
-                              uuidRegistry,
-                              xmlFloppy,
-                              strMachineFolder);
-        if (FAILED(rc)) return rc;
-
-        rc = registerMedium(pImage, &pImage, DeviceType_Floppy);
-        if (FAILED(rc)) return rc;
-    }
-
-    LogFlow(("VirtualBox::initMedia LEAVING\n"));
-
-    return S_OK;
-}
-
-void VirtualBox::uninit()
-{
-    Assert(!m->uRegistryNeedsSaving);
-    if (m->uRegistryNeedsSaving)
-        saveSettings();
-
-    /* Enclose the state transition Ready->InUninit->NotReady */
-    AutoUninitSpan autoUninitSpan(this);
-    if (autoUninitSpan.uninitDone())
-        return;
-
-    LogFlow(("===========================================================\n"));
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("initFailed()=%d\n", autoUninitSpan.initFailed()));
-
-    /* tell all our child objects we've been uninitialized */
-
-    LogFlowThisFunc(("Uninitializing machines (%d)...\n", m->allMachines.size()));
-    if (m->pHost)
-    {
-        /* It is necessary to hold the VirtualBox and Host locks here because
-           we may have to uninitialize SessionMachines. */
-        AutoMultiWriteLock2 multilock(this, m->pHost COMMA_LOCKVAL_SRC_POS);
-        m->allMachines.uninitAll();
-    }
-    else
-        m->allMachines.uninitAll();
-    m->allFloppyImages.uninitAll();
-    m->allDVDImages.uninitAll();
-    m->allHardDisks.uninitAll();
-    m->allDHCPServers.uninitAll();
-
-    m->mapProgressOperations.clear();
-
-    m->allGuestOSTypes.uninitAll();
-
-    /* Note that we release singleton children after we've all other children.
-     * In some cases this is important because these other children may use
-     * some resources of the singletons which would prevent them from
-     * uninitializing (as for example, mSystemProperties which owns
-     * MediumFormat objects which Medium objects refer to) */
-    if (m->pSystemProperties)
-    {
-        m->pSystemProperties->uninit();
-        unconst(m->pSystemProperties).setNull();
-    }
-
-    if (m->pHost)
-    {
-        m->pHost->uninit();
-        unconst(m->pHost).setNull();
-    }
-
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-    if (m->pPerformanceCollector)
-    {
-        m->pPerformanceCollector->uninit();
-        unconst(m->pPerformanceCollector).setNull();
-    }
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-    LogFlowThisFunc(("Terminating the async event handler...\n"));
-    if (m->threadAsyncEvent != NIL_RTTHREAD)
-    {
-        /* signal to exit the event loop */
-        if (RT_SUCCESS(m->pAsyncEventQ->interruptEventQueueProcessing()))
-        {
-            /*
-             *  Wait for thread termination (only after we've successfully
-             *  interrupted the event queue processing!)
-             */
-            int vrc = RTThreadWait(m->threadAsyncEvent, 60000, NULL);
-            if (RT_FAILURE(vrc))
-                LogWarningFunc(("RTThreadWait(%RTthrd) -> %Rrc\n",
-                                m->threadAsyncEvent, vrc));
-        }
-        else
-        {
-            AssertMsgFailed(("interruptEventQueueProcessing() failed\n"));
-            RTThreadWait(m->threadAsyncEvent, 0, NULL);
-        }
-
-        unconst(m->threadAsyncEvent) = NIL_RTTHREAD;
-        unconst(m->pAsyncEventQ) = NULL;
-    }
-
-    LogFlowThisFunc(("Releasing event source...\n"));
-    if (m->pEventSource)
-    {
-        // we don't perform uninit() as it's possible that some pending event refers to this source
-        unconst(m->pEventSource).setNull();
-    }
-
-    LogFlowThisFunc(("Terminating the client watcher...\n"));
-    if (m->threadClientWatcher != NIL_RTTHREAD)
-    {
-        /* signal the client watcher thread */
-        updateClientWatcher();
-        /* wait for the termination */
-        RTThreadWait(m->threadClientWatcher, RT_INDEFINITE_WAIT, NULL);
-        unconst(m->threadClientWatcher) = NIL_RTTHREAD;
-    }
-    m->llProcesses.clear();
-#if defined(RT_OS_WINDOWS)
-    if (m->updateReq != NULL)
-    {
-        ::CloseHandle(m->updateReq);
-        unconst(m->updateReq) = NULL;
-    }
-#elif defined(RT_OS_OS2)
-    if (m->updateReq != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy(m->updateReq);
-        unconst(m->updateReq) = NIL_RTSEMEVENT;
-    }
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    if (m->updateReq != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy(m->updateReq);
-        unconst(m->updateReq) = NIL_RTSEMEVENT;
+        RTSemEventDestroy(mUpdateReq);
+        mUpdateReq = NIL_RTSEMEVENT;
     }
 #else
 # error "Port me!"
 #endif
-
-    delete m->pAutostartDb;
-
-    // clean up our instance data
-    delete m;
-
-    /* Unload hard disk plugin backends. */
-    VDShutdown();
-
-    LogFlowThisFuncLeave();
-    LogFlow(("===========================================================\n"));
 }
 
-// IVirtualBox properties
-/////////////////////////////////////////////////////////////////////////////
-
-STDMETHODIMP VirtualBox::COMGETTER(Version)(BSTR *aVersion)
+VirtualBox::ClientWatcher::ClientWatcher(const ComObjPtr<VirtualBox> &pVirtualBox) :
+    mVirtualBox(pVirtualBox),
+    mThread(NIL_RTTHREAD),
+    mUpdateReq(CWUPDATEREQARG),
+    mLock(LOCKCLASS_OBJECTSTATE)
 {
-    CheckComArgNotNull(aVersion);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    sVersion.cloneTo(aVersion);
-    return S_OK;
+#if defined(RT_OS_WINDOWS)
+    mUpdateReq = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+#elif defined(RT_OS_OS2)
+    RTSemEventCreate(&mUpdateReq);
+#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+    RTSemEventCreate(&mUpdateReq);
+    /* start with high timeouts, nothing to do */
+    ASMAtomicUoWriteU8(&mUpdateAdaptCtr, 0);
+#else
+# error "Port me!"
+#endif
+
+    int vrc = RTThreadCreate(&mThread,
+                             worker,
+                             (void *)this,
+                             0,
+                             RTTHREADTYPE_MAIN_WORKER,
+                             RTTHREADFLAGS_WAITABLE,
+                             "Watcher");
+    AssertRC(vrc);
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(VersionNormalized)(BSTR *aVersionNormalized)
+bool VirtualBox::ClientWatcher::isReady()
 {
-    CheckComArgNotNull(aVersionNormalized);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    sVersionNormalized.cloneTo(aVersionNormalized);
-    return S_OK;
+    return mThread != NIL_RTTHREAD;
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(Revision)(ULONG *aRevision)
+/**
+ * Sends a signal to the thread to rescan the clients/VMs having open sessions.
+ */
+void VirtualBox::ClientWatcher::update()
 {
-    CheckComArgNotNull(aRevision);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    *aRevision = sRevision;
-    return S_OK;
+    AssertReturnVoid(mThread != NIL_RTTHREAD);
+
+    /* sent an update request */
+#if defined(RT_OS_WINDOWS)
+    ::SetEvent(mUpdateReq);
+#elif defined(RT_OS_OS2)
+    RTSemEventSignal(mUpdateReq);
+#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+    /* use short timeouts, as we expect changes */
+    ASMAtomicUoWriteU8(&mUpdateAdaptCtr, RT_ELEMENTS(s_aUpdateTimeoutSteps) - 1);
+    RTSemEventSignal(mUpdateReq);
+#else
+# error "Port me!"
+#endif
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(PackageType)(BSTR *aPackageType)
+/**
+ * Adds a process to the list of processes to be reaped. This call should be
+ * followed by a call to update() to cause the necessary actions immediately,
+ * in case the process crashes straight away.
+ */
+void VirtualBox::ClientWatcher::addProcess(RTPROCESS pid)
 {
-    CheckComArgNotNull(aPackageType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    sPackageType.cloneTo(aPackageType);
-    return S_OK;
+    AssertReturnVoid(mThread != NIL_RTTHREAD);
+    /* @todo r=klaus, do the reaping on all platforms! */
+#ifndef RT_OS_WINDOWS
+    AutoWriteLock alock(mLock COMMA_LOCKVAL_SRC_POS);
+    mProcesses.push_back(pid);
+#endif
 }
 
-STDMETHODIMP VirtualBox::COMGETTER(APIVersion)(BSTR *aAPIVersion)
-{
-    CheckComArgNotNull(aAPIVersion);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    sAPIVersion.cloneTo(aAPIVersion);
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(HomeFolder)(BSTR *aHomeFolder)
-{
-    CheckComArgNotNull(aHomeFolder);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mHomeDir is const and doesn't need a lock */
-    m->strHomeDir.cloneTo(aHomeFolder);
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(SettingsFilePath)(BSTR *aSettingsFilePath)
-{
-    CheckComArgNotNull(aSettingsFilePath);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mCfgFile.mName is const and doesn't need a lock */
-    m->strSettingsFilePath.cloneTo(aSettingsFilePath);
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(Host)(IHost **aHost)
-{
-    CheckComArgOutPointerValid(aHost);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mHost is const, no need to lock */
-    m->pHost.queryInterfaceTo(aHost);
-    return S_OK;
-}
-
-STDMETHODIMP
-VirtualBox::COMGETTER(SystemProperties)(ISystemProperties **aSystemProperties)
-{
-    CheckComArgOutPointerValid(aSystemProperties);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mSystemProperties is const, no need to lock */
-    m->pSystemProperties.queryInterfaceTo(aSystemProperties);
-    return S_OK;
-}
-
-STDMETHODIMP
-VirtualBox::COMGETTER(Machines)(ComSafeArrayOut(IMachine *, aMachines))
-{
-    CheckComArgOutSafeArrayPointerValid(aMachines);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IMachine> machines(m->allMachines.getList());
-    machines.detachTo(ComSafeArrayOutArg(aMachines));
-
-    return S_OK;
-}
-
-STDMETHODIMP
-VirtualBox::COMGETTER(MachineGroups)(ComSafeArrayOut(BSTR, aMachineGroups))
-{
-    CheckComArgOutSafeArrayPointerValid(aMachineGroups);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    std::list<Bstr> allGroups;
-
-    /* get copy of all machine references, to avoid holding the list lock */
-    MachinesOList::MyList allMachines;
-    {
-        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        allMachines = m->allMachines.getList();
-    }
-    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
-         it != allMachines.end();
-         ++it)
-    {
-        const ComObjPtr<Machine> &pMachine = *it;
-        AutoCaller autoMachineCaller(pMachine);
-        if (FAILED(autoMachineCaller.rc()))
-            continue;
-        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
-
-        if (pMachine->isAccessible())
-        {
-            const StringsList &thisGroups = pMachine->getGroups();
-            for (StringsList::const_iterator it2 = thisGroups.begin();
-                 it2 != thisGroups.end();
-                 ++it2)
-                allGroups.push_back(*it2);
-        }
-    }
-
-    /* throw out any duplicates */
-    allGroups.sort();
-    allGroups.unique();
-    com::SafeArray<BSTR> machineGroups(allGroups.size());
-    size_t i = 0;
-    for (std::list<Bstr>::const_iterator it = allGroups.begin();
-         it != allGroups.end();
-         ++it, i++)
-    {
-        const Bstr &tmp = *it;
-        tmp.cloneTo(&machineGroups[i]);
-    }
-    machineGroups.detachTo(ComSafeArrayOutArg(aMachineGroups));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(HardDisks)(ComSafeArrayOut(IMedium *, aHardDisks))
-{
-    CheckComArgOutSafeArrayPointerValid(aHardDisks);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IMedium> hardDisks(m->allHardDisks.getList());
-    hardDisks.detachTo(ComSafeArrayOutArg(aHardDisks));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(DVDImages)(ComSafeArrayOut(IMedium *, aDVDImages))
-{
-    CheckComArgOutSafeArrayPointerValid(aDVDImages);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allDVDImages.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IMedium> images(m->allDVDImages.getList());
-    images.detachTo(ComSafeArrayOutArg(aDVDImages));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(FloppyImages)(ComSafeArrayOut(IMedium *, aFloppyImages))
-{
-    CheckComArgOutSafeArrayPointerValid(aFloppyImages);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allFloppyImages.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IMedium> images(m->allFloppyImages.getList());
-    images.detachTo(ComSafeArrayOutArg(aFloppyImages));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(ProgressOperations)(ComSafeArrayOut(IProgress *, aOperations))
-{
-    CheckComArgOutPointerValid(aOperations);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* protect mProgressOperations */
-    AutoReadLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IProgress> progress(m->mapProgressOperations);
-    progress.detachTo(ComSafeArrayOutArg(aOperations));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(GuestOSTypes)(ComSafeArrayOut(IGuestOSType *, aGuestOSTypes))
-{
-    CheckComArgOutSafeArrayPointerValid(aGuestOSTypes);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IGuestOSType> ostypes(m->allGuestOSTypes.getList());
-    ostypes.detachTo(ComSafeArrayOutArg(aGuestOSTypes));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(SharedFolders)(ComSafeArrayOut(ISharedFolder *, aSharedFolders))
-{
-#ifndef RT_OS_WINDOWS
-    NOREF(aSharedFoldersSize);
-#endif /* RT_OS_WINDOWS */
-
-    CheckComArgOutSafeArrayPointerValid(aSharedFolders);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    return setError(E_NOTIMPL, "Not yet implemented");
-}
-
-STDMETHODIMP
-VirtualBox::COMGETTER(PerformanceCollector)(IPerformanceCollector **aPerformanceCollector)
-{
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-    CheckComArgOutPointerValid(aPerformanceCollector);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* mPerformanceCollector is const, no need to lock */
-    m->pPerformanceCollector.queryInterfaceTo(aPerformanceCollector);
-
-    return S_OK;
-#else /* !VBOX_WITH_RESOURCE_USAGE_API */
-    ReturnComNotImplemented();
-#endif /* !VBOX_WITH_RESOURCE_USAGE_API */
-}
-
-STDMETHODIMP
-VirtualBox::COMGETTER(DHCPServers)(ComSafeArrayOut(IDHCPServer *, aDHCPServers))
-{
-    CheckComArgOutSafeArrayPointerValid(aDHCPServers);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<IDHCPServer> svrs(m->allDHCPServers.getList());
-    svrs.detachTo(ComSafeArrayOutArg(aDHCPServers));
-
-    return S_OK;
-}
-
-
-STDMETHODIMP
-VirtualBox::COMGETTER(NATNetworks)(ComSafeArrayOut(INATNetwork *, aNATNetworks))
-{
-#ifdef VBOX_WITH_NAT_SERVICE
-    CheckComArgOutSafeArrayPointerValid(aNATNetworks);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock al(m->allNATNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    SafeIfaceArray<INATNetwork> nets(m->allNATNetworks.getList());
-    nets.detachTo(ComSafeArrayOutArg(aNATNetworks));
-
-    return S_OK;
-#else
-    NOREF(aNATNetworks);
-# ifndef RT_OS_WINDOWS
-    NOREF(aNATNetworksSize);
-# endif
-    return E_NOTIMPL;
-#endif
-}
-
-
-STDMETHODIMP
-VirtualBox::COMGETTER(EventSource)(IEventSource ** aEventSource)
-{
-    CheckComArgOutPointerValid(aEventSource);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* event source is const, no need to lock */
-    m->pEventSource.queryInterfaceTo(aEventSource);
-
-    return S_OK;
-}
-
-STDMETHODIMP
-VirtualBox::COMGETTER(ExtensionPackManager)(IExtPackManager **aExtPackManager)
-{
-    CheckComArgOutPointerValid(aExtPackManager);
-
-    AutoCaller autoCaller(this);
-    HRESULT hrc = autoCaller.rc();
-    if (SUCCEEDED(hrc))
-    {
-#ifdef VBOX_WITH_EXTPACK
-        /* The extension pack manager is const, no need to lock. */
-        hrc = m->ptrExtPackManager.queryInterfaceTo(aExtPackManager);
-#else
-        hrc = E_NOTIMPL;
-#endif
-    }
-
-    return hrc;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(InternalNetworks)(ComSafeArrayOut(BSTR, aInternalNetworks))
-{
-    CheckComArgOutSafeArrayPointerValid(aInternalNetworks);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    std::list<Bstr> allInternalNetworks;
-
-    /* get copy of all machine references, to avoid holding the list lock */
-    MachinesOList::MyList allMachines;
-    {
-        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        allMachines = m->allMachines.getList();
-    }
-    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
-         it != allMachines.end();
-         ++it)
-    {
-        const ComObjPtr<Machine> &pMachine = *it;
-        AutoCaller autoMachineCaller(pMachine);
-        if (FAILED(autoMachineCaller.rc()))
-            continue;
-        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
-
-        if (pMachine->isAccessible())
-        {
-            uint32_t cNetworkAdapters = Global::getMaxNetworkAdapters(pMachine->getChipsetType());
-            for (ULONG i = 0; i < cNetworkAdapters; i++)
-            {
-                ComPtr<INetworkAdapter> pNet;
-                HRESULT rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
-                if (FAILED(rc) || pNet.isNull())
-                    continue;
-                Bstr strInternalNetwork;
-                rc = pNet->COMGETTER(InternalNetwork)(strInternalNetwork.asOutParam());
-                if (FAILED(rc) || strInternalNetwork.isEmpty())
-                    continue;
-
-                allInternalNetworks.push_back(strInternalNetwork);
-            }
-        }
-    }
-
-    /* throw out any duplicates */
-    allInternalNetworks.sort();
-    allInternalNetworks.unique();
-    com::SafeArray<BSTR> internalNetworks(allInternalNetworks.size());
-    size_t i = 0;
-    for (std::list<Bstr>::const_iterator it = allInternalNetworks.begin();
-         it != allInternalNetworks.end();
-         ++it, i++)
-    {
-        const Bstr &tmp = *it;
-        tmp.cloneTo(&internalNetworks[i]);
-    }
-    internalNetworks.detachTo(ComSafeArrayOutArg(aInternalNetworks));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::COMGETTER(GenericNetworkDrivers)(ComSafeArrayOut(BSTR, aGenericNetworkDrivers))
-{
-    CheckComArgOutSafeArrayPointerValid(aGenericNetworkDrivers);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    std::list<Bstr> allGenericNetworkDrivers;
-
-    /* get copy of all machine references, to avoid holding the list lock */
-    MachinesOList::MyList allMachines;
-    {
-        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        allMachines = m->allMachines.getList();
-    }
-    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
-         it != allMachines.end();
-         ++it)
-    {
-        const ComObjPtr<Machine> &pMachine = *it;
-        AutoCaller autoMachineCaller(pMachine);
-        if (FAILED(autoMachineCaller.rc()))
-            continue;
-        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
-
-        if (pMachine->isAccessible())
-        {
-            uint32_t cNetworkAdapters = Global::getMaxNetworkAdapters(pMachine->getChipsetType());
-            for (ULONG i = 0; i < cNetworkAdapters; i++)
-            {
-                ComPtr<INetworkAdapter> pNet;
-                HRESULT rc = pMachine->GetNetworkAdapter(i, pNet.asOutParam());
-                if (FAILED(rc) || pNet.isNull())
-                    continue;
-                Bstr strGenericNetworkDriver;
-                rc = pNet->COMGETTER(GenericDriver)(strGenericNetworkDriver.asOutParam());
-                if (FAILED(rc) || strGenericNetworkDriver.isEmpty())
-                    continue;
-
-                allGenericNetworkDrivers.push_back(strGenericNetworkDriver);
-            }
-        }
-    }
-
-    /* throw out any duplicates */
-    allGenericNetworkDrivers.sort();
-    allGenericNetworkDrivers.unique();
-    com::SafeArray<BSTR> genericNetworks(allGenericNetworkDrivers.size());
-    size_t i = 0;
-    for (std::list<Bstr>::const_iterator it = allGenericNetworkDrivers.begin();
-         it != allGenericNetworkDrivers.end();
-         ++it, i++)
-    {
-        const Bstr &tmp = *it;
-        tmp.cloneTo(&genericNetworks[i]);
-    }
-    genericNetworks.detachTo(ComSafeArrayOutArg(aGenericNetworkDrivers));
-
-    return S_OK;
-}
-
-STDMETHODIMP
-VirtualBox::CheckFirmwarePresent(FirmwareType_T aFirmwareType,
-                                 IN_BSTR        aVersion,
-                                 BSTR           *aUrl,
-                                 BSTR           *aFile,
-                                 BOOL           *aResult)
-{
-    CheckComArgNotNull(aResult);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    NOREF(aVersion);
-
-    static const struct
-    {
-        FirmwareType_T type;
-        const char*    fileName;
-        const char*    url;
-    }
-    firmwareDesc[] =
-    {
-        {
-            /* compiled-in firmware */
-            FirmwareType_BIOS,    NULL,             NULL
-        },
-        {
-            FirmwareType_EFI32,   "VBoxEFI32.fd",   "http://virtualbox.org/firmware/VBoxEFI32.fd"
-        },
-        {
-            FirmwareType_EFI64,   "VBoxEFI64.fd",   "http://virtualbox.org/firmware/VBoxEFI64.fd"
-        },
-        {
-            FirmwareType_EFIDUAL, "VBoxEFIDual.fd", "http://virtualbox.org/firmware/VBoxEFIDual.fd"
-        }
-    };
-
-    for (size_t i = 0; i < sizeof(firmwareDesc) / sizeof(firmwareDesc[0]); i++)
-    {
-        if (aFirmwareType != firmwareDesc[i].type)
-            continue;
-
-        /* compiled-in firmware */
-        if (firmwareDesc[i].fileName == NULL)
-        {
-            *aResult = TRUE;
-            break;
-        }
-
-        Utf8Str shortName, fullName;
-
-        shortName = Utf8StrFmt("Firmware%c%s",
-                               RTPATH_DELIMITER,
-                               firmwareDesc[i].fileName);
-        int rc = calculateFullPath(shortName, fullName);
-        AssertRCReturn(rc, rc);
-        if (RTFileExists(fullName.c_str()))
-        {
-            *aResult = TRUE;
-            if (aFile)
-                Utf8Str(fullName).cloneTo(aFile);
-            break;
-        }
-
-        char pszVBoxPath[RTPATH_MAX];
-        rc = RTPathExecDir(pszVBoxPath, RTPATH_MAX);
-        AssertRCReturn(rc, rc);
-        fullName = Utf8StrFmt("%s%c%s",
-                              pszVBoxPath,
-                              RTPATH_DELIMITER,
-                              firmwareDesc[i].fileName);
-        if (RTFileExists(fullName.c_str()))
-        {
-            *aResult = TRUE;
-            if (aFile)
-                Utf8Str(fullName).cloneTo(aFile);
-            break;
-        }
-
-        /** @todo: account for version in the URL */
-        if (aUrl != NULL)
-        {
-            Utf8Str strUrl(firmwareDesc[i].url);
-            strUrl.cloneTo(aUrl);
-        }
-        *aResult = FALSE;
-
-        /* Assume single record per firmware type */
-        break;
-    }
-
-    return S_OK;
-}
-// IVirtualBox methods
-/////////////////////////////////////////////////////////////////////////////
-
-/* Helper for VirtualBox::ComposeMachineFilename */
-static void sanitiseMachineFilename(Utf8Str &aName);
-
-STDMETHODIMP VirtualBox::ComposeMachineFilename(IN_BSTR aName,
-                                                IN_BSTR aGroup,
-                                                IN_BSTR aCreateFlags,
-                                                IN_BSTR aBaseFolder,
-                                                BSTR *aFilename)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aName=\"%ls\",aBaseFolder=\"%ls\"\n", aName, aBaseFolder));
-
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgOutPointerValid(aFilename);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    Utf8Str strCreateFlags(aCreateFlags);
-    Guid id;
-    bool fDirectoryIncludesUUID = false;
-    if (!strCreateFlags.isEmpty())
-    {
-        const char *pcszNext = strCreateFlags.c_str();
-        while (*pcszNext != '\0')
-        {
-            Utf8Str strFlag;
-            const char *pcszComma = RTStrStr(pcszNext, ",");
-            if (!pcszComma)
-                strFlag = pcszNext;
-            else
-                strFlag = Utf8Str(pcszNext, pcszComma - pcszNext);
-
-            const char *pcszEqual = RTStrStr(strFlag.c_str(), "=");
-            /* skip over everything which doesn't contain '=' */
-            if (pcszEqual && pcszEqual != strFlag.c_str())
-            {
-                Utf8Str strKey(strFlag.c_str(), pcszEqual - strFlag.c_str());
-                Utf8Str strValue(strFlag.c_str() + (pcszEqual - strFlag.c_str() + 1));
-
-                if (strKey == "UUID")
-                    id = strValue.c_str();
-                else if (strKey == "directoryIncludesUUID")
-                    fDirectoryIncludesUUID = (strValue == "1");
-            }
-
-            if (!pcszComma)
-                pcszNext += strFlag.length();
-            else
-                pcszNext += strFlag.length() + 1;
-        }
-    }
-
-    if (id.isZero())
-        fDirectoryIncludesUUID = false;
-    else if (!id.isValid())
-    {
-        /* do something else */
-        return setError(E_INVALIDARG,
-                 tr("'%ls' is not a valid Guid"),
-                 id.toStringCurly().c_str());
-    }
-
-    Utf8Str strGroup(aGroup);
-    if (strGroup.isEmpty())
-        strGroup = "/";
-    HRESULT rc = validateMachineGroup(strGroup, true);
-    if (FAILED(rc))
-        return rc;
-
-    /* Compose the settings file name using the following scheme:
-     *
-     *     <base_folder><group>/<machine_name>/<machine_name>.xml
-     *
-     * If a non-null and non-empty base folder is specified, the default
-     * machine folder will be used as a base folder.
-     * We sanitise the machine name to a safe white list of characters before
-     * using it.
-     */
-    Utf8Str strBase = aBaseFolder;
-    Utf8Str strName = aName;
-    Utf8Str strDirName(strName);
-    if (fDirectoryIncludesUUID)
-        strDirName += Utf8StrFmt(" (%RTuuid)", id.raw());
-    sanitiseMachineFilename(strName);
-    sanitiseMachineFilename(strDirName);
-
-    if (strBase.isEmpty())
-        /* we use the non-full folder value below to keep the path relative */
-        getDefaultMachineFolder(strBase);
-
-    calculateFullPath(strBase, strBase);
-
-    /* eliminate toplevel group to avoid // in the result */
-    if (strGroup == "/")
-        strGroup.setNull();
-    Bstr bstrSettingsFile = BstrFmt("%s%s%c%s%c%s.vbox",
-                                    strBase.c_str(),
-                                    strGroup.c_str(),
-                                    RTPATH_DELIMITER,
-                                    strDirName.c_str(),
-                                    RTPATH_DELIMITER,
-                                    strName.c_str());
-
-    bstrSettingsFile.detachTo(aFilename);
-
-    return S_OK;
-}
-
 /**
- * Remove characters from a machine file name which can be problematic on
- * particular systems.
- * @param  strName  The file name to sanitise.
+ * Thread worker function that watches the termination of all client processes
+ * that have open sessions using IMachine::LockMachine()
  */
-void sanitiseMachineFilename(Utf8Str &strName)
-{
-    /** Set of characters which should be safe for use in filenames: some basic
-     * ASCII, Unicode from Latin-1 alphabetic to the end of Hangul.  We try to
-     * skip anything that could count as a control character in Windows or
-     * *nix, or be otherwise difficult for shells to handle (I would have
-     * preferred to remove the space and brackets too).  We also remove all
-     * characters which need UTF-16 surrogate pairs for Windows's benefit. */
-    RTUNICP aCpSet[] =
-        { ' ', ' ', '(', ')', '-', '.', '0', '9', 'A', 'Z', 'a', 'z', '_', '_',
-          0xa0, 0xd7af, '\0' };
-    char *pszName = strName.mutableRaw();
-    int cReplacements = RTStrPurgeComplementSet(pszName, aCpSet, '_');
-    Assert(cReplacements >= 0);
-    NOREF(cReplacements);
-    /* No leading dot or dash. */
-    if (pszName[0] == '.' || pszName[0] == '-')
-        pszName[0] = '_';
-    /* No trailing dot. */
-    if (pszName[strName.length() - 1] == '.')
-        pszName[strName.length() - 1] = '_';
-    /* Mangle leading and trailing spaces. */
-    for (size_t i = 0; pszName[i] == ' '; ++i)
-       pszName[i] = '_';
-    for (size_t i = strName.length() - 1; i && pszName[i] == ' '; --i)
-       pszName[i] = '_';
-}
-
-#ifdef DEBUG
-/** Simple unit test/operation examples for sanitiseMachineFilename(). */
-static unsigned testSanitiseMachineFilename(void (*pfnPrintf)(const char *, ...))
-{
-    unsigned cErrors = 0;
-
-    /** Expected results of sanitising given file names. */
-    static struct
-    {
-        /** The test file name to be sanitised (Utf-8). */
-        const char *pcszIn;
-        /** The expected sanitised output (Utf-8). */
-        const char *pcszOutExpected;
-    } aTest[] =
-    {
-        { "OS/2 2.1", "OS_2 2.1" },
-        { "-!My VM!-", "__My VM_-" },
-        { "\xF0\x90\x8C\xB0", "____" },
-        { "  My VM  ", "__My VM__" },
-        { ".My VM.", "_My VM_" },
-        { "My VM", "My VM" }
-    };
-    for (unsigned i = 0; i < RT_ELEMENTS(aTest); ++i)
-    {
-        Utf8Str str(aTest[i].pcszIn);
-        sanitiseMachineFilename(str);
-        if (str.compare(aTest[i].pcszOutExpected))
-        {
-            ++cErrors;
-            pfnPrintf("%s: line %d, expected %s, actual %s\n",
-                      __PRETTY_FUNCTION__, i, aTest[i].pcszOutExpected,
-                      str.c_str());
-        }
-    }
-    return cErrors;
-}
-
-/** @todo Proper testcase. */
-/** @todo Do we have a better method of doing init functions? */
-namespace
-{
-    class TestSanitiseMachineFilename
-    {
-    public:
-        TestSanitiseMachineFilename(void)
-        {
-            Assert(!testSanitiseMachineFilename(RTAssertMsg2));
-        }
-    };
-    TestSanitiseMachineFilename s_TestSanitiseMachineFilename;
-}
-#endif
-
-/** @note Locks mSystemProperties object for reading. */
-STDMETHODIMP VirtualBox::CreateMachine(IN_BSTR aSettingsFile,
-                                       IN_BSTR aName,
-                                       ComSafeArrayIn(IN_BSTR, aGroups),
-                                       IN_BSTR aOsTypeId,
-                                       IN_BSTR aCreateFlags,
-                                       IMachine **aMachine)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aSettingsFile=\"%ls\", aName=\"%ls\", aOsTypeId =\"%ls\", aCreateFlags=\"%ls\"\n", aSettingsFile, aName, aOsTypeId, aCreateFlags));
-
-    CheckComArgStrNotEmptyOrNull(aName);
-    /** @todo tighten checks on aId? */
-    CheckComArgOutPointerValid(aMachine);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    StringsList llGroups;
-    HRESULT rc = convertMachineGroups(ComSafeArrayInArg(aGroups), &llGroups);
-    if (FAILED(rc))
-        return rc;
-
-    Utf8Str strCreateFlags(aCreateFlags);
-    Guid id;
-    bool fForceOverwrite = false;
-    bool fDirectoryIncludesUUID = false;
-    if (!strCreateFlags.isEmpty())
-    {
-        const char *pcszNext = strCreateFlags.c_str();
-        while (*pcszNext != '\0')
-        {
-            Utf8Str strFlag;
-            const char *pcszComma = RTStrStr(pcszNext, ",");
-            if (!pcszComma)
-                strFlag = pcszNext;
-            else
-                strFlag = Utf8Str(pcszNext, pcszComma - pcszNext);
-
-            const char *pcszEqual = RTStrStr(strFlag.c_str(), "=");
-            /* skip over everything which doesn't contain '=' */
-            if (pcszEqual && pcszEqual != strFlag.c_str())
-            {
-                Utf8Str strKey(strFlag.c_str(), pcszEqual - strFlag.c_str());
-                Utf8Str strValue(strFlag.c_str() + (pcszEqual - strFlag.c_str() + 1));
-
-                if (strKey == "UUID")
-                    id = strValue.c_str();
-                else if (strKey == "forceOverwrite")
-                    fForceOverwrite = (strValue == "1");
-                else if (strKey == "directoryIncludesUUID")
-                    fDirectoryIncludesUUID = (strValue == "1");
-            }
-
-            if (!pcszComma)
-                pcszNext += strFlag.length();
-            else
-                pcszNext += strFlag.length() + 1;
-        }
-    }
-    /* Create UUID if none was specified. */
-    if (id.isZero())
-        id.create();
-    else if (!id.isValid())
-    {
-        /* do something else */
-        return setError(E_INVALIDARG,
-                 tr("'%ls' is not a valid Guid"),
-                 id.toStringCurly().c_str());
-    }
-
-    /* NULL settings file means compose automatically */
-    Bstr bstrSettingsFile(aSettingsFile);
-    if (bstrSettingsFile.isEmpty())
-    {
-        Utf8Str strNewCreateFlags(Utf8StrFmt("UUID=%RTuuid", id.raw()));
-        if (fDirectoryIncludesUUID)
-            strNewCreateFlags += ",directoryIncludesUUID=1";
-
-        rc = ComposeMachineFilename(aName,
-                                    Bstr(llGroups.front()).raw(),
-                                    Bstr(strNewCreateFlags).raw(),
-                                    NULL /* aBaseFolder */,
-                                    bstrSettingsFile.asOutParam());
-        if (FAILED(rc)) return rc;
-    }
-
-    /* create a new object */
-    ComObjPtr<Machine> machine;
-    rc = machine.createObject();
-    if (FAILED(rc)) return rc;
-
-    GuestOSType *osType = NULL;
-    rc = findGuestOSType(Bstr(aOsTypeId), osType);
-    if (FAILED(rc)) return rc;
-
-    /* initialize the machine object */
-    rc = machine->init(this,
-                       Utf8Str(bstrSettingsFile),
-                       Utf8Str(aName),
-                       llGroups,
-                       osType,
-                       id,
-                       fForceOverwrite,
-                       fDirectoryIncludesUUID);
-    if (SUCCEEDED(rc))
-    {
-        /* set the return value */
-        rc = machine.queryInterfaceTo(aMachine);
-        AssertComRC(rc);
-
-#ifdef VBOX_WITH_EXTPACK
-        /* call the extension pack hooks */
-        m->ptrExtPackManager->callAllVmCreatedHooks(machine);
-#endif
-    }
-
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-STDMETHODIMP VirtualBox::OpenMachine(IN_BSTR aSettingsFile,
-                                     IMachine **aMachine)
-{
-    CheckComArgStrNotEmptyOrNull(aSettingsFile);
-    CheckComArgOutPointerValid(aMachine);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc = E_FAIL;
-
-    /* create a new object */
-    ComObjPtr<Machine> machine;
-    rc = machine.createObject();
-    if (SUCCEEDED(rc))
-    {
-        /* initialize the machine object */
-        rc = machine->initFromSettings(this,
-                                       aSettingsFile,
-                                       NULL);       /* const Guid *aId */
-        if (SUCCEEDED(rc))
-        {
-            /* set the return value */
-            rc = machine.queryInterfaceTo(aMachine);
-            ComAssertComRC(rc);
-        }
-    }
-
-    return rc;
-}
-
-/** @note Locks objects! */
-STDMETHODIMP VirtualBox::RegisterMachine(IMachine *aMachine)
-{
-    CheckComArgNotNull(aMachine);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc;
-
-    Bstr name;
-    rc = aMachine->COMGETTER(Name)(name.asOutParam());
-    if (FAILED(rc)) return rc;
-
-    /* We can safely cast child to Machine * here because only Machine
-     * implementations of IMachine can be among our children. */
-    Machine *pMachine = static_cast<Machine*>(aMachine);
-
-    AutoCaller machCaller(pMachine);
-    ComAssertComRCRetRC(machCaller.rc());
-
-    rc = registerMachine(pMachine);
-    /* fire an event */
-    if (SUCCEEDED(rc))
-        onMachineRegistered(pMachine->getId(), TRUE);
-
-    return rc;
-}
-
-/** @note Locks this object for reading, then some machine objects for reading. */
-STDMETHODIMP VirtualBox::FindMachine(IN_BSTR aNameOrId, IMachine **aMachine)
-{
-    LogFlowThisFuncEnter();
-    LogFlowThisFunc(("aName=\"%ls\", aMachine={%p}\n", aNameOrId, aMachine));
-
-    CheckComArgStrNotEmptyOrNull(aNameOrId);
-    CheckComArgOutPointerValid(aMachine);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* start with not found */
-    HRESULT rc = S_OK;
-    ComObjPtr<Machine> pMachineFound;
-
-    Guid id(aNameOrId);
-    if (id.isValid() && !id.isZero())
-
-        rc = findMachine(id,
-                         true /* fPermitInaccessible */,
-                         true /* setError */,
-                         &pMachineFound);
-                // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
-    else
-    {
-        Utf8Str strName(aNameOrId);
-        rc = findMachineByName(aNameOrId,
-                               true /* setError */,
-                               &pMachineFound);
-                // returns VBOX_E_OBJECT_NOT_FOUND if not found and sets error
-    }
-
-    /* this will set (*machine) to NULL if machineObj is null */
-    pMachineFound.queryInterfaceTo(aMachine);
-
-    LogFlowThisFunc(("aName=\"%ls\", aMachine=%p, rc=%08X\n", aNameOrId, *aMachine, rc));
-    LogFlowThisFuncLeave();
-
-    return rc;
-}
-
-STDMETHODIMP VirtualBox::GetMachinesByGroups(ComSafeArrayIn(IN_BSTR, aGroups), ComSafeArrayOut(IMachine *, aMachines))
-{
-    CheckComArgSafeArrayNotNull(aGroups);
-    CheckComArgOutSafeArrayPointerValid(aMachines);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    StringsList llGroups;
-    HRESULT rc = convertMachineGroups(ComSafeArrayInArg(aGroups), &llGroups);
-    if (FAILED(rc))
-        return rc;
-    /* we want to rely on sorted groups during compare, to save time */
-    llGroups.sort();
-
-    /* get copy of all machine references, to avoid holding the list lock */
-    MachinesOList::MyList allMachines;
-    {
-        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        allMachines = m->allMachines.getList();
-    }
-
-    com::SafeIfaceArray<IMachine> saMachines;
-    for (MachinesOList::MyList::const_iterator it = allMachines.begin();
-         it != allMachines.end();
-         ++it)
-    {
-        const ComObjPtr<Machine> &pMachine = *it;
-        AutoCaller autoMachineCaller(pMachine);
-        if (FAILED(autoMachineCaller.rc()))
-            continue;
-        AutoReadLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
-
-        if (pMachine->isAccessible())
-        {
-            const StringsList &thisGroups = pMachine->getGroups();
-            for (StringsList::const_iterator it2 = thisGroups.begin();
-                 it2 != thisGroups.end();
-                 ++it2)
-            {
-                const Utf8Str &group = *it2;
-                bool fAppended = false;
-                for (StringsList::const_iterator it3 = llGroups.begin();
-                     it3 != llGroups.end();
-                     ++it3)
-                {
-                    int order = it3->compare(group);
-                    if (order == 0)
-                    {
-                        saMachines.push_back(pMachine);
-                        fAppended = true;
-                        break;
-                    }
-                    else if (order > 0)
-                        break;
-                    else
-                        continue;
-                }
-                /* avoid duplicates and save time */
-                if (fAppended)
-                    break;
-            }
-        }
-    }
-
-    saMachines.detachTo(ComSafeArrayOutArg(aMachines));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::GetMachineStates(ComSafeArrayIn(IMachine *, aMachines), ComSafeArrayOut(MachineState_T, aStates))
-{
-    CheckComArgSafeArrayNotNull(aMachines);
-    CheckComArgOutSafeArrayPointerValid(aStates);
-
-    com::SafeIfaceArray<IMachine> saMachines(ComSafeArrayInArg(aMachines));
-    com::SafeArray<MachineState_T> saStates(saMachines.size());
-    for (size_t i = 0; i < saMachines.size(); i++)
-    {
-        ComPtr<IMachine> pMachine = saMachines[i];
-        MachineState_T state = MachineState_Null;
-        if (!pMachine.isNull())
-        {
-            HRESULT rc = pMachine->COMGETTER(State)(&state);
-            if (rc == E_ACCESSDENIED)
-                rc = S_OK;
-            AssertComRC(rc);
-        }
-        saStates[i] = state;
-    }
-    saStates.detachTo(ComSafeArrayOutArg(aStates));
-
-    return S_OK;
-}
-
-STDMETHODIMP VirtualBox::CreateHardDisk(IN_BSTR aFormat,
-                                        IN_BSTR aLocation,
-                                        IMedium **aHardDisk)
-{
-    CheckComArgOutPointerValid(aHardDisk);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* we don't access non-const data members so no need to lock */
-
-    Utf8Str format(aFormat);
-    if (format.isEmpty())
-        getDefaultHardDiskFormat(format);
-
-    ComObjPtr<Medium> hardDisk;
-    hardDisk.createObject();
-    HRESULT rc = hardDisk->init(this,
-                                format,
-                                aLocation,
-                                Guid::Empty /* media registry: none yet */);
-
-    if (SUCCEEDED(rc))
-        hardDisk.queryInterfaceTo(aHardDisk);
-
-    return rc;
-}
-
-STDMETHODIMP VirtualBox::OpenMedium(IN_BSTR aLocation,
-                                    DeviceType_T deviceType,
-                                    AccessMode_T accessMode,
-                                    BOOL fForceNewUuid,
-                                    IMedium **aMedium)
-{
-    HRESULT rc = S_OK;
-    CheckComArgStrNotEmptyOrNull(aLocation);
-    CheckComArgOutPointerValid(aMedium);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    Guid id(aLocation);
-    ComObjPtr<Medium> pMedium;
-
-    // have to get write lock as the whole find/update sequence must be done
-    // in one critical section, otherwise there are races which can lead to
-    // multiple Medium objects with the same content
-    AutoWriteLock treeLock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    // check if the device type is correct, and see if a medium for the
-    // given path has already initialized; if so, return that
-    switch (deviceType)
-    {
-        case DeviceType_HardDisk:
-            if (id.isValid() && !id.isZero())
-                rc = findHardDiskById(id, false /* setError */, &pMedium);
-            else
-                rc = findHardDiskByLocation(aLocation,
-                                            false, /* aSetError */
-                                            &pMedium);
-        break;
-
-        case DeviceType_Floppy:
-        case DeviceType_DVD:
-            if (id.isValid() && !id.isZero())
-                rc = findDVDOrFloppyImage(deviceType, &id, Utf8Str::Empty,
-                                          false /* setError */, &pMedium);
-            else
-                rc = findDVDOrFloppyImage(deviceType, NULL, aLocation,
-                                          false /* setError */, &pMedium);
-
-            // enforce read-only for DVDs even if caller specified ReadWrite
-            if (deviceType == DeviceType_DVD)
-                accessMode = AccessMode_ReadOnly;
-        break;
-
-        default:
-            return setError(E_INVALIDARG, "Device type must be HardDisk, DVD or Floppy %d", deviceType);
-    }
-
-    if (pMedium.isNull())
-    {
-        pMedium.createObject();
-        treeLock.release();
-        rc = pMedium->init(this,
-                           aLocation,
-                           (accessMode == AccessMode_ReadWrite) ? Medium::OpenReadWrite : Medium::OpenReadOnly,
-                           !!fForceNewUuid,
-                           deviceType);
-        treeLock.acquire();
-
-        if (SUCCEEDED(rc))
-        {
-            rc = registerMedium(pMedium, &pMedium, deviceType);
-
-            treeLock.release();
-
-            /* Note that it's important to call uninit() on failure to register
-             * because the differencing hard disk would have been already associated
-             * with the parent and this association needs to be broken. */
-
-            if (FAILED(rc))
-            {
-                pMedium->uninit();
-                rc = VBOX_E_OBJECT_NOT_FOUND;
-            }
-        }
-        else
-            rc = VBOX_E_OBJECT_NOT_FOUND;
-    }
-
-    if (SUCCEEDED(rc))
-        pMedium.queryInterfaceTo(aMedium);
-
-    return rc;
-}
-
-
-/** @note Locks this object for reading. */
-STDMETHODIMP VirtualBox::GetGuestOSType(IN_BSTR aId, IGuestOSType **aType)
-{
-    CheckComArgNotNull(aType);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    *aType = NULL;
-
-    AutoReadLock alock(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    for (GuestOSTypesOList::iterator it = m->allGuestOSTypes.begin();
-         it != m->allGuestOSTypes.end();
-         ++it)
-    {
-        const Bstr &typeId = (*it)->id();
-        AssertMsg(!typeId.isEmpty(), ("ID must not be NULL"));
-        if (typeId.compare(aId, Bstr::CaseInsensitive) == 0)
-        {
-            (*it).queryInterfaceTo(aType);
-            break;
-        }
-    }
-
-    return (*aType) ? S_OK :
-        setError(E_INVALIDARG,
-                 tr("'%ls' is not a valid Guest OS type"),
-                 aId);
-}
-
-STDMETHODIMP VirtualBox::CreateSharedFolder(IN_BSTR aName,        IN_BSTR aHostPath,
-                                            BOOL /* aWritable */, BOOL /* aAutoMount */)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgStrNotEmptyOrNull(aHostPath);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    return setError(E_NOTIMPL, "Not yet implemented");
-}
-
-STDMETHODIMP VirtualBox::RemoveSharedFolder(IN_BSTR aName)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    return setError(E_NOTIMPL, "Not yet implemented");
-}
-
-/**
- *  @note Locks this object for reading.
- */
-STDMETHODIMP VirtualBox::GetExtraDataKeys(ComSafeArrayOut(BSTR, aKeys))
-{
-    using namespace settings;
-
-    CheckComArgOutSafeArrayPointerValid(aKeys);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    com::SafeArray<BSTR> saKeys(m->pMainConfigFile->mapExtraDataItems.size());
-    int i = 0;
-    for (StringsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.begin();
-         it != m->pMainConfigFile->mapExtraDataItems.end();
-         ++it, ++i)
-    {
-        const Utf8Str &strName = it->first;     // the key
-        strName.cloneTo(&saKeys[i]);
-    }
-    saKeys.detachTo(ComSafeArrayOutArg(aKeys));
-
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for reading.
- */
-STDMETHODIMP VirtualBox::GetExtraData(IN_BSTR aKey,
-                                      BSTR *aValue)
-{
-    CheckComArgStrNotEmptyOrNull(aKey);
-    CheckComArgNotNull(aValue);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* start with nothing found */
-    Utf8Str strKey(aKey);
-    Bstr bstrResult;
-
-    settings::StringsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.find(strKey);
-    if (it != m->pMainConfigFile->mapExtraDataItems.end())
-        // found:
-        bstrResult = it->second; // source is a Utf8Str
-
-    /* return the result to caller (may be empty) */
-    bstrResult.cloneTo(aValue);
-
-    return S_OK;
-}
-
-/**
- *  @note Locks this object for writing.
- */
-STDMETHODIMP VirtualBox::SetExtraData(IN_BSTR aKey,
-                                      IN_BSTR aValue)
-{
-    CheckComArgStrNotEmptyOrNull(aKey);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    Utf8Str strKey(aKey);
-    Utf8Str strValue(aValue);
-    Utf8Str strOldValue;            // empty
-
-    // locking note: we only hold the read lock briefly to look up the old value,
-    // then release it and call the onExtraCanChange callbacks. There is a small
-    // chance of a race insofar as the callback might be called twice if two callers
-    // change the same key at the same time, but that's a much better solution
-    // than the deadlock we had here before. The actual changing of the extradata
-    // is then performed under the write lock and race-free.
-
-    // look up the old value first; if nothing has changed then we need not do anything
-    {
-        AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS); // hold read lock only while looking up
-        settings::StringsMap::const_iterator it = m->pMainConfigFile->mapExtraDataItems.find(strKey);
-        if (it != m->pMainConfigFile->mapExtraDataItems.end())
-            strOldValue = it->second;
-    }
-
-    bool fChanged;
-    if ((fChanged = (strOldValue != strValue)))
-    {
-        // ask for permission from all listeners outside the locks;
-        // onExtraDataCanChange() only briefly requests the VirtualBox
-        // lock to copy the list of callbacks to invoke
-        Bstr error;
-        Bstr bstrValue(aValue);
-
-        if (!onExtraDataCanChange(Guid::Empty, aKey, bstrValue.raw(), error))
-        {
-            const char *sep = error.isEmpty() ? "" : ": ";
-            CBSTR err = error.raw();
-            LogWarningFunc(("Someone vetoed! Change refused%s%ls\n",
-                            sep, err));
-            return setError(E_ACCESSDENIED,
-                            tr("Could not set extra data because someone refused the requested change of '%ls' to '%ls'%s%ls"),
-                            aKey,
-                            bstrValue.raw(),
-                            sep,
-                            err);
-        }
-
-        // data is changing and change not vetoed: then write it out under the lock
-
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-        if (strValue.isEmpty())
-            m->pMainConfigFile->mapExtraDataItems.erase(strKey);
-        else
-            m->pMainConfigFile->mapExtraDataItems[strKey] = strValue;
-                // creates a new key if needed
-
-        /* save settings on success */
-        HRESULT rc = saveSettings();
-        if (FAILED(rc)) return rc;
-    }
-
-    // fire notification outside the lock
-    if (fChanged)
-        onExtraDataChange(Guid::Empty, aKey, aValue);
-
-    return S_OK;
-}
-
-/**
- *
- */
-STDMETHODIMP VirtualBox::SetSettingsSecret(IN_BSTR aValue)
-{
-    storeSettingsKey(aValue);
-    decryptSettings();
-    return S_OK;
-}
-
-int VirtualBox::decryptMediumSettings(Medium *pMedium)
-{
-    Bstr bstrCipher;
-    HRESULT hrc = pMedium->GetProperty(Bstr("InitiatorSecretEncrypted").raw(),
-                                       bstrCipher.asOutParam());
-    if (SUCCEEDED(hrc))
-    {
-        Utf8Str strPlaintext;
-        int rc = decryptSetting(&strPlaintext, bstrCipher);
-        if (RT_SUCCESS(rc))
-            pMedium->setPropertyDirect("InitiatorSecret", strPlaintext);
-        else
-            return rc;
-    }
-    return VINF_SUCCESS;
-}
-
-/**
- * Decrypt all encrypted settings.
- *
- * So far we only have encrypted iSCSI initiator secrets so we just go through
- * all hard disk mediums and determine the plain 'InitiatorSecret' from
- * 'InitiatorSecretEncrypted. The latter is stored as Base64 because medium
- * properties need to be null-terminated strings.
- */
-int VirtualBox::decryptSettings()
-{
-    bool fFailure = false;
-    AutoReadLock al(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    for (MediaList::const_iterator mt = m->allHardDisks.begin();
-         mt != m->allHardDisks.end();
-         ++mt)
-    {
-        ComObjPtr<Medium> pMedium = *mt;
-        AutoCaller medCaller(pMedium);
-        if (FAILED(medCaller.rc()))
-            continue;
-        AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
-        int vrc = decryptMediumSettings(pMedium);
-        if (RT_FAILURE(vrc))
-            fFailure = true;
-    }
-    return fFailure ? VERR_INVALID_PARAMETER : VINF_SUCCESS;
-}
-
-/**
- * Encode.
- *
- * @param aPlaintext      plaintext to be encrypted
- * @param aCiphertext     resulting ciphertext (base64-encoded)
- */
-int VirtualBox::encryptSetting(const Utf8Str &aPlaintext, Utf8Str *aCiphertext)
-{
-    uint8_t abCiphertext[32];
-    char    szCipherBase64[128];
-    size_t  cchCipherBase64;
-    int rc = encryptSettingBytes((uint8_t*)aPlaintext.c_str(), abCiphertext,
-                                 aPlaintext.length()+1, sizeof(abCiphertext));
-    if (RT_SUCCESS(rc))
-    {
-        rc = RTBase64Encode(abCiphertext, sizeof(abCiphertext),
-                            szCipherBase64, sizeof(szCipherBase64),
-                            &cchCipherBase64);
-        if (RT_SUCCESS(rc))
-            *aCiphertext = szCipherBase64;
-    }
-    return rc;
-}
-
-/**
- * Decode.
- *
- * @param aPlaintext      resulting plaintext
- * @param aCiphertext     ciphertext (base64-encoded) to decrypt
- */
-int VirtualBox::decryptSetting(Utf8Str *aPlaintext, const Utf8Str &aCiphertext)
-{
-    uint8_t abPlaintext[64];
-    uint8_t abCiphertext[64];
-    size_t  cbCiphertext;
-    int rc = RTBase64Decode(aCiphertext.c_str(),
-                            abCiphertext, sizeof(abCiphertext),
-                            &cbCiphertext, NULL);
-    if (RT_SUCCESS(rc))
-    {
-        rc = decryptSettingBytes(abPlaintext, abCiphertext, cbCiphertext);
-        if (RT_SUCCESS(rc))
-        {
-            for (unsigned i = 0; i < cbCiphertext; i++)
-            {
-                /* sanity check: null-terminated string? */
-                if (abPlaintext[i] == '\0')
-                {
-                    /* sanity check: valid UTF8 string? */
-                    if (RTStrIsValidEncoding((const char*)abPlaintext))
-                    {
-                        *aPlaintext = Utf8Str((const char*)abPlaintext);
-                        return VINF_SUCCESS;
-                    }
-                }
-            }
-            rc = VERR_INVALID_MAGIC;
-        }
-    }
-    return rc;
-}
-
-/**
- * Encrypt secret bytes. Use the m->SettingsCipherKey as key.
- *
- * @param aPlaintext      clear text to be encrypted
- * @param aCiphertext     resulting encrypted text
- * @param aPlaintextSize  size of the plaintext
- * @param aCiphertextSize size of the ciphertext
- */
-int VirtualBox::encryptSettingBytes(const uint8_t *aPlaintext, uint8_t *aCiphertext,
-                                    size_t aPlaintextSize, size_t aCiphertextSize) const
-{
-    unsigned i, j;
-    uint8_t aBytes[64];
-
-    if (!m->fSettingsCipherKeySet)
-        return VERR_INVALID_STATE;
-
-    if (aCiphertextSize > sizeof(aBytes))
-        return VERR_BUFFER_OVERFLOW;
-
-    if (aCiphertextSize < 32)
-        return VERR_INVALID_PARAMETER;
-
-    AssertCompile(sizeof(m->SettingsCipherKey) >= 32);
-
-    /* store the first 8 bytes of the cipherkey for verification */
-    for (i = 0, j = 0; i < 8; i++, j++)
-        aCiphertext[i] = m->SettingsCipherKey[j];
-
-    for (unsigned k = 0; k < aPlaintextSize && i < aCiphertextSize; i++, k++)
-    {
-        aCiphertext[i] = (aPlaintext[k] ^ m->SettingsCipherKey[j]);
-        if (++j >= sizeof(m->SettingsCipherKey))
-            j = 0;
-    }
-
-    /* fill with random data to have a minimal length (salt) */
-    if (i < aCiphertextSize)
-    {
-        RTRandBytes(aBytes, aCiphertextSize - i);
-        for (int k = 0; i < aCiphertextSize; i++, k++)
-        {
-            aCiphertext[i] = aBytes[k] ^ m->SettingsCipherKey[j];
-            if (++j >= sizeof(m->SettingsCipherKey))
-                j = 0;
-        }
-    }
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Decrypt secret bytes. Use the m->SettingsCipherKey as key.
- *
- * @param aPlaintext      resulting plaintext
- * @param aCiphertext     ciphertext to be decrypted
- * @param aCiphertextSize size of the ciphertext == size of the plaintext
- */
-int VirtualBox::decryptSettingBytes(uint8_t *aPlaintext,
-                                    const uint8_t *aCiphertext, size_t aCiphertextSize) const
-{
-    unsigned i, j;
-
-    if (!m->fSettingsCipherKeySet)
-        return VERR_INVALID_STATE;
-
-    if (aCiphertextSize < 32)
-        return VERR_INVALID_PARAMETER;
-
-    /* key verification */
-    for (i = 0, j = 0; i < 8; i++, j++)
-        if (aCiphertext[i] != m->SettingsCipherKey[j])
-            return VERR_INVALID_MAGIC;
-
-    /* poison */
-    memset(aPlaintext, 0xff, aCiphertextSize);
-    for (int k = 0; i < aCiphertextSize; i++, k++)
-    {
-        aPlaintext[k] = aCiphertext[i] ^ m->SettingsCipherKey[j];
-        if (++j >= sizeof(m->SettingsCipherKey))
-            j = 0;
-    }
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Store a settings key.
- *
- * @param aKey          the key to store
- */
-void VirtualBox::storeSettingsKey(const Utf8Str &aKey)
-{
-    RTSha512(aKey.c_str(), aKey.length(), m->SettingsCipherKey);
-    m->fSettingsCipherKeySet = true;
-}
-
-// public methods only for internal purposes
-/////////////////////////////////////////////////////////////////////////////
-
-#ifdef DEBUG
-void VirtualBox::dumpAllBackRefs()
-{
-    {
-        AutoReadLock al(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        for (MediaList::const_iterator mt = m->allHardDisks.begin();
-             mt != m->allHardDisks.end();
-             ++mt)
-        {
-            ComObjPtr<Medium> pMedium = *mt;
-            pMedium->dumpBackRefs();
-        }
-    }
-    {
-        AutoReadLock al(m->allDVDImages.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        for (MediaList::const_iterator mt = m->allDVDImages.begin();
-             mt != m->allDVDImages.end();
-             ++mt)
-        {
-            ComObjPtr<Medium> pMedium = *mt;
-            pMedium->dumpBackRefs();
-        }
-    }
-}
-#endif
-
-/**
- *  Posts an event to the event queue that is processed asynchronously
- *  on a dedicated thread.
- *
- *  Posting events to the dedicated event queue is useful to perform secondary
- *  actions outside any object locks -- for example, to iterate over a list
- *  of callbacks and inform them about some change caused by some object's
- *  method call.
- *
- *  @param event    event to post; must have been allocated using |new|, will
- *                  be deleted automatically by the event thread after processing
- *
- *  @note Doesn't lock any object.
- */
-HRESULT VirtualBox::postEvent(Event *event)
-{
-    AssertReturn(event, E_FAIL);
-
-    HRESULT rc;
-    AutoCaller autoCaller(this);
-    if (SUCCEEDED((rc = autoCaller.rc())))
-    {
-        if (autoCaller.state() != Ready)
-            LogWarningFunc(("VirtualBox has been uninitialized (state=%d), the event is discarded!\n",
-                            autoCaller.state()));
-            // return S_OK
-        else if (    (m->pAsyncEventQ)
-                  && (m->pAsyncEventQ->postEvent(event))
-                )
-            return S_OK;
-        else
-            rc = E_FAIL;
-    }
-
-    // in any event of failure, we must clean up here, or we'll leak;
-    // the caller has allocated the object using new()
-    delete event;
-    return rc;
-}
-
-/**
- * Adds a progress to the global collection of pending operations.
- * Usually gets called upon progress object initialization.
- *
- * @param aProgress Operation to add to the collection.
- *
- * @note Doesn't lock objects.
- */
-HRESULT VirtualBox::addProgress(IProgress *aProgress)
-{
-    CheckComArgNotNull(aProgress);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    Bstr id;
-    HRESULT rc = aProgress->COMGETTER(Id)(id.asOutParam());
-    AssertComRCReturnRC(rc);
-
-    /* protect mProgressOperations */
-    AutoWriteLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
-
-    m->mapProgressOperations.insert(ProgressMap::value_type(Guid(id), aProgress));
-    return S_OK;
-}
-
-/**
- * Removes the progress from the global collection of pending operations.
- * Usually gets called upon progress completion.
- *
- * @param aId   UUID of the progress operation to remove
- *
- * @note Doesn't lock objects.
- */
-HRESULT VirtualBox::removeProgress(IN_GUID aId)
-{
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComPtr<IProgress> progress;
-
-    /* protect mProgressOperations */
-    AutoWriteLock safeLock(m->mtxProgressOperations COMMA_LOCKVAL_SRC_POS);
-
-    size_t cnt = m->mapProgressOperations.erase(aId);
-    Assert(cnt == 1);
-    NOREF(cnt);
-
-    return S_OK;
-}
-
-#ifdef RT_OS_WINDOWS
-
-struct StartSVCHelperClientData
-{
-    ComObjPtr<VirtualBox> that;
-    ComObjPtr<Progress> progress;
-    bool privileged;
-    VirtualBox::SVCHelperClientFunc func;
-    void *user;
-};
-
-/**
- *  Helper method that starts a worker thread that:
- *  - creates a pipe communication channel using SVCHlpClient;
- *  - starts an SVC Helper process that will inherit this channel;
- *  - executes the supplied function by passing it the created SVCHlpClient
- *    and opened instance to communicate to the Helper process and the given
- *    Progress object.
- *
- *  The user function is supposed to communicate to the helper process
- *  using the \a aClient argument to do the requested job and optionally expose
- *  the progress through the \a aProgress object. The user function should never
- *  call notifyComplete() on it: this will be done automatically using the
- *  result code returned by the function.
- *
- *  Before the user function is started, the communication channel passed to
- *  the \a aClient argument is fully set up, the function should start using
- *  its write() and read() methods directly.
- *
- *  The \a aVrc parameter of the user function may be used to return an error
- *  code if it is related to communication errors (for example, returned by
- *  the SVCHlpClient members when they fail). In this case, the correct error
- *  message using this value will be reported to the caller. Note that the
- *  value of \a aVrc is inspected only if the user function itself returns
- *  success.
- *
- *  If a failure happens anywhere before the user function would be normally
- *  called, it will be called anyway in special "cleanup only" mode indicated
- *  by \a aClient, \a aProgress and \aVrc arguments set to NULL. In this mode,
- *  all the function is supposed to do is to cleanup its aUser argument if
- *  necessary (it's assumed that the ownership of this argument is passed to
- *  the user function once #startSVCHelperClient() returns a success, thus
- *  making it responsible for the cleanup).
- *
- *  After the user function returns, the thread will send the SVCHlpMsg::Null
- *  message to indicate a process termination.
- *
- *  @param  aPrivileged |true| to start the SVC Helper process as a privileged
- *                      user that can perform administrative tasks
- *  @param  aFunc       user function to run
- *  @param  aUser       argument to the user function
- *  @param  aProgress   progress object that will track operation completion
- *
- *  @note aPrivileged is currently ignored (due to some unsolved problems in
- *        Vista) and the process will be started as a normal (unprivileged)
- *        process.
- *
- *  @note Doesn't lock anything.
- */
-HRESULT VirtualBox::startSVCHelperClient(bool aPrivileged,
-                                         SVCHelperClientFunc aFunc,
-                                         void *aUser, Progress *aProgress)
-{
-    AssertReturn(aFunc, E_POINTER);
-    AssertReturn(aProgress, E_POINTER);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    /* create the SVCHelperClientThread() argument */
-    std::auto_ptr <StartSVCHelperClientData>
-        d(new StartSVCHelperClientData());
-    AssertReturn(d.get(), E_OUTOFMEMORY);
-
-    d->that = this;
-    d->progress = aProgress;
-    d->privileged = aPrivileged;
-    d->func = aFunc;
-    d->user = aUser;
-
-    RTTHREAD tid = NIL_RTTHREAD;
-    int vrc = RTThreadCreate(&tid, SVCHelperClientThread,
-                             static_cast <void *>(d.get()),
-                             0, RTTHREADTYPE_MAIN_WORKER,
-                             RTTHREADFLAGS_WAITABLE, "SVCHelper");
-    if (RT_FAILURE(vrc))
-        return setError(E_FAIL, "Could not create SVCHelper thread (%Rrc)", vrc);
-
-    /* d is now owned by SVCHelperClientThread(), so release it */
-    d.release();
-
-    return S_OK;
-}
-
-/**
- *  Worker thread for startSVCHelperClient().
- */
-/* static */
-DECLCALLBACK(int)
-VirtualBox::SVCHelperClientThread(RTTHREAD aThread, void *aUser)
+/*static*/
+DECLCALLBACK(int) VirtualBox::ClientWatcher::worker(RTTHREAD /* thread */, void *pvUser)
 {
     LogFlowFuncEnter();
 
-    std::auto_ptr<StartSVCHelperClientData>
-        d(static_cast<StartSVCHelperClientData*>(aUser));
-
-    HRESULT rc = S_OK;
-    bool userFuncCalled = false;
+    VirtualBox::ClientWatcher *that = (VirtualBox::ClientWatcher *)pvUser;
+    Assert(that);
+
+    typedef std::vector<ComObjPtr<Machine> > MachineVector;
+    typedef std::vector<ComObjPtr<SessionMachine> > SessionMachineVector;
+
+    SessionMachineVector machines;
+    MachineVector spawnedMachines;
+
+    size_t cnt = 0;
+    size_t cntSpawned = 0;
+
+    VirtualBoxBase::initializeComForThread();
+
+#if defined(RT_OS_WINDOWS)
+
+    /// @todo (dmik) processes reaping!
+
+    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+    handles[0] = that->mUpdateReq;
 
     do
     {
-        AssertBreakStmt(d.get(), rc = E_POINTER);
-        AssertReturn(!d->progress.isNull(), E_POINTER);
-
-        /* protect VirtualBox from uninitialization */
-        AutoCaller autoCaller(d->that);
-        if (!autoCaller.isOk())
-        {
-            /* it's too late */
-            rc = autoCaller.rc();
-            break;
-        }
-
-        int vrc = VINF_SUCCESS;
-
-        Guid id;
-        id.create();
-        SVCHlpClient client;
-        vrc = client.create(Utf8StrFmt("VirtualBox\\SVCHelper\\{%RTuuid}",
-                                       id.raw()).c_str());
-        if (RT_FAILURE(vrc))
-        {
-            rc = d->that->setError(E_FAIL,
-                                   tr("Could not create the communication channel (%Rrc)"), vrc);
-            break;
-        }
-
-        /* get the path to the executable */
-        char exePathBuf[RTPATH_MAX];
-        char *exePath = RTProcGetExecutablePath(exePathBuf, RTPATH_MAX);
-        if (!exePath)
-        {
-            rc = d->that->setError(E_FAIL, tr("Cannot get executable name"));
-            break;
-        }
-
-        Utf8Str argsStr = Utf8StrFmt("/Helper %s", client.name().c_str());
-
-        LogFlowFunc(("Starting '\"%s\" %s'...\n", exePath, argsStr.c_str()));
-
-        RTPROCESS pid = NIL_RTPROCESS;
-
-        if (d->privileged)
-        {
-            /* Attempt to start a privileged process using the Run As dialog */
-
-            Bstr file = exePath;
-            Bstr parameters = argsStr;
-
-            SHELLEXECUTEINFO shExecInfo;
-
-            shExecInfo.cbSize = sizeof(SHELLEXECUTEINFO);
-
-            shExecInfo.fMask = NULL;
-            shExecInfo.hwnd = NULL;
-            shExecInfo.lpVerb = L"runas";
-            shExecInfo.lpFile = file.raw();
-            shExecInfo.lpParameters = parameters.raw();
-            shExecInfo.lpDirectory = NULL;
-            shExecInfo.nShow = SW_NORMAL;
-            shExecInfo.hInstApp = NULL;
-
-            if (!ShellExecuteEx(&shExecInfo))
-            {
-                int vrc2 = RTErrConvertFromWin32(GetLastError());
-                /* hide excessive details in case of a frequent error
-                 * (pressing the Cancel button to close the Run As dialog) */
-                if (vrc2 == VERR_CANCELLED)
-                    rc = d->that->setError(E_FAIL,
-                                           tr("Operation canceled by the user"));
-                else
-                    rc = d->that->setError(E_FAIL,
-                                           tr("Could not launch a privileged process '%s' (%Rrc)"),
-                                           exePath, vrc2);
-                break;
-            }
-        }
-        else
-        {
-            const char *args[] = { exePath, "/Helper", client.name().c_str(), 0 };
-            vrc = RTProcCreate(exePath, args, RTENV_DEFAULT, 0, &pid);
-            if (RT_FAILURE(vrc))
-            {
-                rc = d->that->setError(E_FAIL,
-                                       tr("Could not launch a process '%s' (%Rrc)"), exePath, vrc);
-                break;
-            }
-        }
-
-        /* wait for the client to connect */
-        vrc = client.connect();
-        if (RT_SUCCESS(vrc))
-        {
-            /* start the user supplied function */
-            rc = d->func(&client, d->progress, d->user, &vrc);
-            userFuncCalled = true;
-        }
-
-        /* send the termination signal to the process anyway */
-        {
-            int vrc2 = client.write(SVCHlpMsg::Null);
-            if (RT_SUCCESS(vrc))
-                vrc = vrc2;
-        }
-
-        if (SUCCEEDED(rc) && RT_FAILURE(vrc))
-        {
-            rc = d->that->setError(E_FAIL,
-                                   tr("Could not operate the communication channel (%Rrc)"), vrc);
-            break;
-        }
-    }
-    while (0);
-
-    if (FAILED(rc) && !userFuncCalled)
-    {
-        /* call the user function in the "cleanup only" mode
-         * to let it free resources passed to in aUser */
-        d->func(NULL, NULL, d->user, NULL);
-    }
-
-    d->progress->notifyComplete(rc);
-
-    LogFlowFuncLeave();
-    return 0;
-}
-
-#endif /* RT_OS_WINDOWS */
-
-/**
- *  Sends a signal to the client watcher thread to rescan the set of machines
- *  that have open sessions.
- *
- *  @note Doesn't lock anything.
- */
-void VirtualBox::updateClientWatcher()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    AssertReturnVoid(m->threadClientWatcher != NIL_RTTHREAD);
-
-    /* sent an update request */
-#if defined(RT_OS_WINDOWS)
-    ::SetEvent(m->updateReq);
-#elif defined(RT_OS_OS2)
-    RTSemEventSignal(m->updateReq);
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    ASMAtomicUoWriteU8(&m->updateAdaptCtr, RT_ELEMENTS(s_updateAdaptTimeouts) - 1);
-    RTSemEventSignal(m->updateReq);
-#else
-# error "Port me!"
-#endif
-}
-
-/**
- *  Adds the given child process ID to the list of processes to be reaped.
- *  This call should be followed by #updateClientWatcher() to take the effect.
- */
-void VirtualBox::addProcessToReap(RTPROCESS pid)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    /// @todo (dmik) Win32?
-#ifndef RT_OS_WINDOWS
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    m->llProcesses.push_back(pid);
-#endif
-}
-
-/** Event for onMachineStateChange(), onMachineDataChange(), onMachineRegistered() */
-struct MachineEvent : public VirtualBox::CallbackEvent
-{
-    MachineEvent(VirtualBox *aVB, VBoxEventType_T aWhat, const Guid &aId, BOOL aBool)
-        : CallbackEvent(aVB, aWhat), id(aId.toUtf16())
-        , mBool(aBool)
-        { }
-
-    MachineEvent(VirtualBox *aVB, VBoxEventType_T aWhat, const Guid &aId, MachineState_T aState)
-        : CallbackEvent(aVB, aWhat), id(aId.toUtf16())
-        , mState(aState)
-        {}
-
-    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc)
-    {
-        switch (mWhat)
-        {
-            case VBoxEventType_OnMachineDataChanged:
-                aEvDesc.init(aSource, mWhat, id.raw(), mBool);
-                break;
-
-            case VBoxEventType_OnMachineStateChanged:
-                aEvDesc.init(aSource, mWhat, id.raw(), mState);
-                break;
-
-            case VBoxEventType_OnMachineRegistered:
-                aEvDesc.init(aSource, mWhat, id.raw(), mBool);
-                break;
-
-            default:
-                AssertFailedReturn(S_OK);
-         }
-         return S_OK;
-    }
-
-    Bstr id;
-    MachineState_T mState;
-    BOOL mBool;
-};
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onMachineStateChange(const Guid &aId, MachineState_T aState)
-{
-    postEvent(new MachineEvent(this, VBoxEventType_OnMachineStateChanged, aId, aState));
-}
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onMachineDataChange(const Guid &aId, BOOL aTemporary)
-{
-    postEvent(new MachineEvent(this, VBoxEventType_OnMachineDataChanged, aId, aTemporary));
-}
-
-/**
- *  @note Locks this object for reading.
- */
-BOOL VirtualBox::onExtraDataCanChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue,
-                                       Bstr &aError)
-{
-    LogFlowThisFunc(("machine={%s} aKey={%ls} aValue={%ls}\n",
-                      aId.toString().c_str(), aKey, aValue));
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    BOOL allowChange = TRUE;
-    Bstr id = aId.toUtf16();
-
-    VBoxEventDesc evDesc;
-    evDesc.init(m->pEventSource, VBoxEventType_OnExtraDataCanChange, id.raw(), aKey, aValue);
-    BOOL fDelivered = evDesc.fire(3000); /* Wait up to 3 secs for delivery */
-    //Assert(fDelivered);
-    if (fDelivered)
-    {
-        ComPtr<IEvent> aEvent;
-        evDesc.getEvent(aEvent.asOutParam());
-        ComPtr<IExtraDataCanChangeEvent> aCanChangeEvent = aEvent;
-        Assert(aCanChangeEvent);
-        BOOL fVetoed = FALSE;
-        aCanChangeEvent->IsVetoed(&fVetoed);
-        allowChange = !fVetoed;
-
-        if (!allowChange)
-        {
-            SafeArray<BSTR> aVetos;
-            aCanChangeEvent->GetVetos(ComSafeArrayAsOutParam(aVetos));
-            if (aVetos.size() > 0)
-                aError = aVetos[0];
-        }
-    }
-    else
-        allowChange = TRUE;
-
-    LogFlowThisFunc(("allowChange=%RTbool\n", allowChange));
-    return allowChange;
-}
-
-/** Event for onExtraDataChange() */
-struct ExtraDataEvent : public VirtualBox::CallbackEvent
-{
-    ExtraDataEvent(VirtualBox *aVB, const Guid &aMachineId,
-                   IN_BSTR aKey, IN_BSTR aVal)
-        : CallbackEvent(aVB, VBoxEventType_OnExtraDataChanged)
-        , machineId(aMachineId.toUtf16()), key(aKey), val(aVal)
-    {}
-
-    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc)
-    {
-        return aEvDesc.init(aSource, VBoxEventType_OnExtraDataChanged, machineId.raw(), key.raw(), val.raw());
-    }
-
-    Bstr machineId, key, val;
-};
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onExtraDataChange(const Guid &aId, IN_BSTR aKey, IN_BSTR aValue)
-{
-    postEvent(new ExtraDataEvent(this, aId, aKey, aValue));
-}
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onMachineRegistered(const Guid &aId, BOOL aRegistered)
-{
-    postEvent(new MachineEvent(this, VBoxEventType_OnMachineRegistered, aId, aRegistered));
-}
-
-/** Event for onSessionStateChange() */
-struct SessionEvent : public VirtualBox::CallbackEvent
-{
-    SessionEvent(VirtualBox *aVB, const Guid &aMachineId, SessionState_T aState)
-        : CallbackEvent(aVB, VBoxEventType_OnSessionStateChanged)
-        , machineId(aMachineId.toUtf16()), sessionState(aState)
-    {}
-
-    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc)
-    {
-        return aEvDesc.init(aSource, VBoxEventType_OnSessionStateChanged, machineId.raw(), sessionState);
-    }
-    Bstr machineId;
-    SessionState_T sessionState;
-};
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onSessionStateChange(const Guid &aId, SessionState_T aState)
-{
-    postEvent(new SessionEvent(this, aId, aState));
-}
-
-/** Event for onSnapshotTaken(), onSnapshotDeleted() and onSnapshotChange() */
-struct SnapshotEvent : public VirtualBox::CallbackEvent
-{
-    SnapshotEvent(VirtualBox *aVB, const Guid &aMachineId, const Guid &aSnapshotId,
-                  VBoxEventType_T aWhat)
-        : CallbackEvent(aVB, aWhat)
-        , machineId(aMachineId), snapshotId(aSnapshotId)
-        {}
-
-    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc)
-    {
-        return aEvDesc.init(aSource, mWhat, machineId.toUtf16().raw(),
-                            snapshotId.toUtf16().raw());
-    }
-
-    Guid machineId;
-    Guid snapshotId;
-};
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onSnapshotTaken(const Guid &aMachineId, const Guid &aSnapshotId)
-{
-    postEvent(new SnapshotEvent(this, aMachineId, aSnapshotId,
-                                VBoxEventType_OnSnapshotTaken));
-}
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onSnapshotDeleted(const Guid &aMachineId, const Guid &aSnapshotId)
-{
-    postEvent(new SnapshotEvent(this, aMachineId, aSnapshotId,
-                                VBoxEventType_OnSnapshotDeleted));
-}
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onSnapshotChange(const Guid &aMachineId, const Guid &aSnapshotId)
-{
-    postEvent(new SnapshotEvent(this, aMachineId, aSnapshotId,
-                                VBoxEventType_OnSnapshotChanged));
-}
-
-/** Event for onGuestPropertyChange() */
-struct GuestPropertyEvent : public VirtualBox::CallbackEvent
-{
-    GuestPropertyEvent(VirtualBox *aVBox, const Guid &aMachineId,
-                       IN_BSTR aName, IN_BSTR aValue, IN_BSTR aFlags)
-        : CallbackEvent(aVBox, VBoxEventType_OnGuestPropertyChanged),
-          machineId(aMachineId),
-          name(aName),
-          value(aValue),
-          flags(aFlags)
-    {}
-
-    virtual HRESULT prepareEventDesc(IEventSource* aSource, VBoxEventDesc& aEvDesc)
-    {
-        return aEvDesc.init(aSource, VBoxEventType_OnGuestPropertyChanged,
-                            machineId.toUtf16().raw(), name.raw(), value.raw(), flags.raw());
-    }
-
-    Guid machineId;
-    Bstr name, value, flags;
-};
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onGuestPropertyChange(const Guid &aMachineId, IN_BSTR aName,
-                                       IN_BSTR aValue, IN_BSTR aFlags)
-{
-    postEvent(new GuestPropertyEvent(this, aMachineId, aName, aValue, aFlags));
-}
-
-/** Event for onMachineUninit(), this is not a CallbackEvent */
-class MachineUninitEvent : public Event
-{
-public:
-
-    MachineUninitEvent(VirtualBox *aVirtualBox, Machine *aMachine)
-        : mVirtualBox(aVirtualBox), mMachine(aMachine)
-    {
-        Assert(aVirtualBox);
-        Assert(aMachine);
-    }
-
-    void *handler()
-    {
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-        /* Handle unregistering metrics here, as it is not vital to get
-         * it done immediately. It reduces the number of locks needed and
-         * the lock contention in SessionMachine::uninit. */
-        {
-            AutoWriteLock mLock(mMachine COMMA_LOCKVAL_SRC_POS);
-            mMachine->unregisterMetrics(mVirtualBox->performanceCollector(), mMachine);
-        }
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-        return NULL;
-    }
-
-private:
-
-    /**
-     *  Note that this is a weak ref -- the CallbackEvent handler thread
-     *  is bound to the lifetime of the VirtualBox instance, so it's safe.
-     */
-    VirtualBox        *mVirtualBox;
-
-    /** Reference to the machine object. */
-    ComObjPtr<Machine> mMachine;
-};
-
-/**
- *  Trigger internal event. This isn't meant to be signalled to clients.
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onMachineUninit(Machine *aMachine)
-{
-    postEvent(new MachineUninitEvent(this, aMachine));
-}
-
-/**
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onNatRedirectChange(const Guid &aMachineId, ULONG ulSlot, bool fRemove, IN_BSTR aName,
-                               NATProtocol_T aProto, IN_BSTR aHostIp, uint16_t aHostPort,
-                               IN_BSTR aGuestIp, uint16_t aGuestPort)
-{
-    fireNATRedirectEvent(m->pEventSource, aMachineId.toUtf16().raw(), ulSlot, fRemove, aName, aProto, aHostIp,
-                         aHostPort, aGuestIp, aGuestPort);
-}
-
-void VirtualBox::onNATNetworkChange(IN_BSTR aName)
-{
-    fireNATNetworkChangedEvent(m->pEventSource, aName);
-}
-
-void VirtualBox::onNATNetworkStartStop(IN_BSTR aName, BOOL fStart)
-{
-    fireNATNetworkStartStopEvent(m->pEventSource, aName, fStart);
-}
-void VirtualBox::onNATNetworkSetting(IN_BSTR aNetworkName, BOOL aEnabled, 
-                                     IN_BSTR aNetwork, IN_BSTR aGateway, 
-                                     BOOL aAdvertiseDefaultIpv6RouteEnabled, 
-                                     BOOL fNeedDhcpServer)
-{
-    fireNATNetworkSettingEvent(m->pEventSource, aNetworkName, aEnabled, 
-                               aNetwork, aGateway,
-                               aAdvertiseDefaultIpv6RouteEnabled, fNeedDhcpServer);
-}
-
-void VirtualBox::onNATNetworkPortForward(IN_BSTR aNetworkName, BOOL create, BOOL fIpv6, 
-                                         IN_BSTR aRuleName, NATProtocol_T proto, 
-                                         IN_BSTR aHostIp, LONG aHostPort, 
-                                         IN_BSTR aGuestIp, LONG aGuestPort)
-{
-    fireNATNetworkPortForwardEvent(m->pEventSource, aNetworkName, create, 
-                                   fIpv6, aRuleName, proto,
-                                   aHostIp, aHostPort,
-                                   aGuestIp, aGuestPort);
-}
-
-/**
- *  @note Locks this object for reading.
- */
-ComObjPtr<GuestOSType> VirtualBox::getUnknownOSType()
-{
-    ComObjPtr<GuestOSType> type;
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), type);
-
-    /* unknown type must always be the first */
-    ComAssertRet(m->allGuestOSTypes.size() > 0, type);
-
-    return m->allGuestOSTypes.front();
-}
-
-/**
- * Returns the list of opened machines (machines having direct sessions opened
- * by client processes) and optionally the list of direct session controls.
- *
- * @param aMachines     Where to put opened machines (will be empty if none).
- * @param aControls     Where to put direct session controls (optional).
- *
- * @note The returned lists contain smart pointers. So, clear it as soon as
- * it becomes no more necessary to release instances.
- *
- * @note It can be possible that a session machine from the list has been
- * already uninitialized, so do a usual AutoCaller/AutoReadLock sequence
- * when accessing unprotected data directly.
- *
- * @note Locks objects for reading.
- */
-void VirtualBox::getOpenedMachines(SessionMachinesList &aMachines,
-                                   InternalControlList *aControls /*= NULL*/)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    aMachines.clear();
-    if (aControls)
-        aControls->clear();
-
-    AutoReadLock alock(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    for (MachinesOList::iterator it = m->allMachines.begin();
-         it != m->allMachines.end();
-         ++it)
-    {
-        ComObjPtr<SessionMachine> sm;
-        ComPtr<IInternalSessionControl> ctl;
-        if ((*it)->isSessionOpen(sm, &ctl))
-        {
-            aMachines.push_back(sm);
-            if (aControls)
-                aControls->push_back(ctl);
-        }
-    }
-}
-
-/**
- *  Searches for a machine object with the given ID in the collection
- *  of registered machines.
- *
- * @param aId Machine UUID to look for.
- * @param aPermitInaccessible If true, inaccessible machines will be found;
- *                  if false, this will fail if the given machine is inaccessible.
- * @param aSetError If true, set errorinfo if the machine is not found.
- * @param aMachine Returned machine, if found.
- * @return
- */
-HRESULT VirtualBox::findMachine(const Guid &aId,
-                                bool fPermitInaccessible,
-                                bool aSetError,
-                                ComObjPtr<Machine> *aMachine /* = NULL */)
-{
-    HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    {
-        AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-        for (MachinesOList::iterator it = m->allMachines.begin();
-             it != m->allMachines.end();
-             ++it)
-        {
-            ComObjPtr<Machine> pMachine = *it;
-
-            if (!fPermitInaccessible)
-            {
-                // skip inaccessible machines
-                AutoCaller machCaller(pMachine);
-                if (FAILED(machCaller.rc()))
-                    continue;
-            }
-
-            if (pMachine->getId() == aId)
-            {
-                rc = S_OK;
-                if (aMachine)
-                    *aMachine = pMachine;
-                break;
-            }
-        }
-    }
-
-    if (aSetError && FAILED(rc))
-        rc = setError(rc,
-                      tr("Could not find a registered machine with UUID {%RTuuid}"),
-                      aId.raw());
-
-    return rc;
-}
-
-/**
- * Searches for a machine object with the given name or location in the
- * collection of registered machines.
- *
- * @param aName Machine name or location to look for.
- * @param aSetError If true, set errorinfo if the machine is not found.
- * @param aMachine Returned machine, if found.
- * @return
- */
-HRESULT VirtualBox::findMachineByName(const Utf8Str &aName, bool aSetError,
-                                      ComObjPtr<Machine> *aMachine /* = NULL */)
-{
-    HRESULT rc = VBOX_E_OBJECT_NOT_FOUND;
-
-    AutoReadLock al(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    for (MachinesOList::iterator it = m->allMachines.begin();
-         it != m->allMachines.end();
-         ++it)
-    {
-        ComObjPtr<Machine> &pMachine = *it;
-        AutoCaller machCaller(pMachine);
-        if (machCaller.rc())
-            continue;       // we can't ask inaccessible machines for their names
-
-        AutoReadLock machLock(pMachine COMMA_LOCKVAL_SRC_POS);
-        if (pMachine->getName() == aName)
-        {
-            rc = S_OK;
-            if (aMachine)
-                *aMachine = pMachine;
-            break;
-        }
-        if (!RTPathCompare(pMachine->getSettingsFileFull().c_str(), aName.c_str()))
-        {
-            rc = S_OK;
-            if (aMachine)
-                *aMachine = pMachine;
-            break;
-        }
-    }
-
-    if (aSetError && FAILED(rc))
-        rc = setError(rc,
-                      tr("Could not find a registered machine named '%s'"), aName.c_str());
-
-    return rc;
-}
-
-static HRESULT validateMachineGroupHelper(const Utf8Str &aGroup, bool fPrimary, VirtualBox *pVirtualBox)
-{
-    /* empty strings are invalid */
-    if (aGroup.isEmpty())
-        return E_INVALIDARG;
-    /* the toplevel group is valid */
-    if (aGroup == "/")
-        return S_OK;
-    /* any other strings of length 1 are invalid */
-    if (aGroup.length() == 1)
-        return E_INVALIDARG;
-    /* must start with a slash */
-    if (aGroup.c_str()[0] != '/')
-        return E_INVALIDARG;
-    /* must not end with a slash */
-    if (aGroup.c_str()[aGroup.length() - 1] == '/')
-        return E_INVALIDARG;
-    /* check the group components */
-    const char *pStr = aGroup.c_str() + 1;  /* first char is /, skip it */
-    while (pStr)
-    {
-        char *pSlash = RTStrStr(pStr, "/");
-        if (pSlash)
-        {
-            /* no empty components (or // sequences in other words) */
-            if (pSlash == pStr)
-                return E_INVALIDARG;
-            /* check if the machine name rules are violated, because that means
-             * the group components are too close to the limits. */
-            Utf8Str tmp((const char *)pStr, (size_t)(pSlash - pStr));
-            Utf8Str tmp2(tmp);
-            sanitiseMachineFilename(tmp);
-            if (tmp != tmp2)
-                return E_INVALIDARG;
-            if (fPrimary)
-            {
-                HRESULT rc = pVirtualBox->findMachineByName(tmp,
-                                                            false /* aSetError */);
-                if (SUCCEEDED(rc))
-                    return VBOX_E_VM_ERROR;
-            }
-            pStr = pSlash + 1;
-        }
-        else
-        {
-            /* check if the machine name rules are violated, because that means
-             * the group components is too close to the limits. */
-            Utf8Str tmp(pStr);
-            Utf8Str tmp2(tmp);
-            sanitiseMachineFilename(tmp);
-            if (tmp != tmp2)
-                return E_INVALIDARG;
-            pStr = NULL;
-        }
-    }
-    return S_OK;
-}
-
-/**
- * Validates a machine group.
- *
- * @param aMachineGroup     Machine group.
- * @param fPrimary          Set if this is the primary group.
- *
- * @return S_OK or E_INVALIDARG
- */
-HRESULT VirtualBox::validateMachineGroup(const Utf8Str &aGroup, bool fPrimary)
-{
-    HRESULT rc = validateMachineGroupHelper(aGroup, fPrimary, this);
-    if (FAILED(rc))
-    {
-        if (rc == VBOX_E_VM_ERROR)
-            rc = setError(E_INVALIDARG,
-                          tr("Machine group '%s' conflicts with a virtual machine name"),
-                          aGroup.c_str());
-        else
-            rc = setError(rc,
-                          tr("Invalid machine group '%s'"),
-                          aGroup.c_str());
-    }
-    return rc;
-}
-
-/**
- * Takes a list of machine groups, and sanitizes/validates it.
- *
- * @param aMachineGroups    Safearray with the machine groups.
- * @param pllMachineGroups  Pointer to list of strings for the result.
- *
- * @return S_OK or E_INVALIDARG
- */
-HRESULT VirtualBox::convertMachineGroups(ComSafeArrayIn(IN_BSTR, aMachineGroups), StringsList *pllMachineGroups)
-{
-    pllMachineGroups->clear();
-    if (aMachineGroups)
-    {
-        com::SafeArray<IN_BSTR> machineGroups(ComSafeArrayInArg(aMachineGroups));
-        for (size_t i = 0; i < machineGroups.size(); i++)
-        {
-            Utf8Str group(machineGroups[i]);
-            if (group.length() == 0)
-                group = "/";
-
-            HRESULT rc = validateMachineGroup(group, i == 0);
-            if (FAILED(rc))
-                return rc;
-
-            /* no duplicates please */
-            if (   find(pllMachineGroups->begin(), pllMachineGroups->end(), group)
-                == pllMachineGroups->end())
-                pllMachineGroups->push_back(group);
-        }
-        if (pllMachineGroups->size() == 0)
-            pllMachineGroups->push_back("/");
-    }
-    else
-        pllMachineGroups->push_back("/");
-
-    return S_OK;
-}
-
-/**
- * Searches for a Medium object with the given ID in the list of registered
- * hard disks.
- *
- * @param aId           ID of the hard disk. Must not be empty.
- * @param aSetError     If @c true , the appropriate error info is set in case
- *                      when the hard disk is not found.
- * @param aHardDisk     Where to store the found hard disk object (can be NULL).
- *
- * @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
- *
- * @note Locks the media tree for reading.
- */
-HRESULT VirtualBox::findHardDiskById(const Guid &id,
-                                     bool aSetError,
-                                     ComObjPtr<Medium> *aHardDisk /*= NULL*/)
-{
-    AssertReturn(!id.isZero(), E_INVALIDARG);
-
-    // we use the hard disks map, but it is protected by the
-    // hard disk _list_ lock handle
-    AutoReadLock alock(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    HardDiskMap::const_iterator it = m->mapHardDisks.find(id);
-    if (it != m->mapHardDisks.end())
-    {
-        if (aHardDisk)
-            *aHardDisk = (*it).second;
-        return S_OK;
-    }
-
-    if (aSetError)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("Could not find an open hard disk with UUID {%RTuuid}"),
-                        id.raw());
-
-    return VBOX_E_OBJECT_NOT_FOUND;
-}
-
-/**
- * Searches for a Medium object with the given ID or location in the list of
- * registered hard disks. If both ID and location are specified, the first
- * object that matches either of them (not necessarily both) is returned.
- *
- * @param aLocation     Full location specification. Must not be empty.
- * @param aSetError     If @c true , the appropriate error info is set in case
- *                      when the hard disk is not found.
- * @param aHardDisk     Where to store the found hard disk object (can be NULL).
- *
- * @return S_OK, E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
- *
- * @note Locks the media tree for reading.
- */
-HRESULT VirtualBox::findHardDiskByLocation(const Utf8Str &strLocation,
-                                           bool aSetError,
-                                           ComObjPtr<Medium> *aHardDisk /*= NULL*/)
-{
-    AssertReturn(!strLocation.isEmpty(), E_INVALIDARG);
-
-    // we use the hard disks map, but it is protected by the
-    // hard disk _list_ lock handle
-    AutoReadLock alock(m->allHardDisks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    for (HardDiskMap::const_iterator it = m->mapHardDisks.begin();
-         it != m->mapHardDisks.end();
-         ++it)
-    {
-        const ComObjPtr<Medium> &pHD = (*it).second;
-
-        AutoCaller autoCaller(pHD);
-        if (FAILED(autoCaller.rc())) return autoCaller.rc();
-        AutoWriteLock mlock(pHD COMMA_LOCKVAL_SRC_POS);
-
-        Utf8Str strLocationFull = pHD->getLocationFull();
-
-        if (0 == RTPathCompare(strLocationFull.c_str(), strLocation.c_str()))
-        {
-            if (aHardDisk)
-                *aHardDisk = pHD;
-            return S_OK;
-        }
-    }
-
-    if (aSetError)
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                        tr("Could not find an open hard disk with location '%s'"),
-                        strLocation.c_str());
-
-    return VBOX_E_OBJECT_NOT_FOUND;
-}
-
-/**
- * Searches for a Medium object with the given ID or location in the list of
- * registered DVD or floppy images, depending on the @a mediumType argument.
- * If both ID and file path are specified, the first object that matches either
- * of them (not necessarily both) is returned.
- *
- * @param mediumType Must be either DeviceType_DVD or DeviceType_Floppy.
- * @param aId       ID of the image file (unused when NULL).
- * @param aLocation Full path to the image file (unused when NULL).
- * @param aSetError If @c true, the appropriate error info is set in case when
- *                  the image is not found.
- * @param aImage    Where to store the found image object (can be NULL).
- *
- * @return S_OK when found or E_INVALIDARG or VBOX_E_OBJECT_NOT_FOUND when not found.
- *
- * @note Locks the media tree for reading.
- */
-HRESULT VirtualBox::findDVDOrFloppyImage(DeviceType_T mediumType,
-                                         const Guid *aId,
-                                         const Utf8Str &aLocation,
-                                         bool aSetError,
-                                         ComObjPtr<Medium> *aImage /* = NULL */)
-{
-    AssertReturn(aId || !aLocation.isEmpty(), E_INVALIDARG);
-
-    Utf8Str location;
-    if (!aLocation.isEmpty())
-    {
-        int vrc = calculateFullPath(aLocation, location);
-        if (RT_FAILURE(vrc))
-            return setError(VBOX_E_FILE_ERROR,
-                            tr("Invalid image file location '%s' (%Rrc)"),
-                            aLocation.c_str(),
-                            vrc);
-    }
-
-    MediaOList *pMediaList;
-
-    switch (mediumType)
-    {
-        case DeviceType_DVD:
-            pMediaList = &m->allDVDImages;
-        break;
-
-        case DeviceType_Floppy:
-            pMediaList = &m->allFloppyImages;
-        break;
-
-        default:
-            return E_INVALIDARG;
-    }
-
-    AutoReadLock alock(pMediaList->getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    bool found = false;
-
-    for (MediaList::const_iterator it = pMediaList->begin();
-         it != pMediaList->end();
-         ++it)
-    {
-        // no AutoCaller, registered image life time is bound to this
-        Medium *pMedium = *it;
-        AutoReadLock imageLock(pMedium COMMA_LOCKVAL_SRC_POS);
-        const Utf8Str &strLocationFull = pMedium->getLocationFull();
-
-        found =     (    aId
-                      && pMedium->getId() == *aId)
-                 || (    !aLocation.isEmpty()
-                      && RTPathCompare(location.c_str(),
-                                       strLocationFull.c_str()) == 0);
-        if (found)
-        {
-            if (pMedium->getDeviceType() != mediumType)
-            {
-                if (mediumType == DeviceType_DVD)
-                    return setError(E_INVALIDARG,
-                                    "Cannot mount DVD medium '%s' as floppy", strLocationFull.c_str());
-                else
-                    return setError(E_INVALIDARG,
-                                    "Cannot mount floppy medium '%s' as DVD", strLocationFull.c_str());
-            }
-
-            if (aImage)
-                *aImage = pMedium;
-            break;
-        }
-    }
-
-    HRESULT rc = found ? S_OK : VBOX_E_OBJECT_NOT_FOUND;
-
-    if (aSetError && !found)
-    {
-        if (aId)
-            setError(rc,
-                     tr("Could not find an image file with UUID {%RTuuid} in the media registry ('%s')"),
-                     aId->raw(),
-                     m->strSettingsFilePath.c_str());
-        else
-            setError(rc,
-                     tr("Could not find an image file with location '%s' in the media registry ('%s')"),
-                     aLocation.c_str(),
-                     m->strSettingsFilePath.c_str());
-    }
-
-    return rc;
-}
-
-/**
- * Searches for an IMedium object that represents the given UUID.
- *
- * If the UUID is empty (indicating an empty drive), this sets pMedium
- * to NULL and returns S_OK.
- *
- * If the UUID refers to a host drive of the given device type, this
- * sets pMedium to the object from the list in IHost and returns S_OK.
- *
- * If the UUID is an image file, this sets pMedium to the object that
- * findDVDOrFloppyImage() returned.
- *
- * If none of the above apply, this returns VBOX_E_OBJECT_NOT_FOUND.
- *
- * @param mediumType Must be DeviceType_DVD or DeviceType_Floppy.
- * @param uuid UUID to search for; must refer to a host drive or an image file or be null.
- * @param fRefresh Whether to refresh the list of host drives in IHost (see Host::getDrives())
- * @param pMedium out: IMedium object found.
- * @return
- */
-HRESULT VirtualBox::findRemoveableMedium(DeviceType_T mediumType,
-                                         const Guid &uuid,
-                                         bool fRefresh,
-                                         bool aSetError,
-                                         ComObjPtr<Medium> &pMedium)
-{
-    if (uuid.isZero())
-    {
-        // that's easy
-        pMedium.setNull();
-        return S_OK;
-    }
-    else if (!uuid.isValid())
-    {
-        /* handling of case invalid GUID */
-        return setError(VBOX_E_OBJECT_NOT_FOUND,
-                            tr("Guid '%ls' is invalid"),
-                            uuid.toString().c_str());
-    }
-
-    // first search for host drive with that UUID
-    HRESULT rc = m->pHost->findHostDriveById(mediumType,
-                                             uuid,
-                                             fRefresh,
-                                             pMedium);
-    if (rc == VBOX_E_OBJECT_NOT_FOUND)
-                // then search for an image with that UUID
-        rc = findDVDOrFloppyImage(mediumType, &uuid, Utf8Str::Empty, aSetError, &pMedium);
-
-    return rc;
-}
-
-HRESULT VirtualBox::findGuestOSType(const Bstr &bstrOSType,
-                                    GuestOSType*& pGuestOSType)
-{
-    /* Look for a GuestOSType object */
-    AssertMsg(m->allGuestOSTypes.size() != 0,
-              ("Guest OS types array must be filled"));
-
-    if (bstrOSType.isEmpty())
-    {
-        pGuestOSType = NULL;
-        return S_OK;
-    }
-
-    AutoReadLock alock(m->allGuestOSTypes.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-    for (GuestOSTypesOList::const_iterator it = m->allGuestOSTypes.begin();
-         it != m->allGuestOSTypes.end();
-         ++it)
-    {
-        if ((*it)->id() == bstrOSType)
-        {
-            pGuestOSType = *it;
-            return S_OK;
-        }
-    }
-
-    return setError(VBOX_E_OBJECT_NOT_FOUND,
-                    tr("Guest OS type '%ls' is invalid"),
-                    bstrOSType.raw());
-}
-
-/**
- * Returns the constant pseudo-machine UUID that is used to identify the
- * global media registry.
- *
- * Starting with VirtualBox 4.0 each medium remembers in its instance data
- * in which media registry it is saved (if any): this can either be a machine
- * UUID, if it's in a per-machine media registry, or this global ID.
- *
- * This UUID is only used to identify the VirtualBox object while VirtualBox
- * is running. It is a compile-time constant and not saved anywhere.
- *
- * @return
- */
-const Guid& VirtualBox::getGlobalRegistryId() const
-{
-    return m->uuidMediaRegistry;
-}
-
-const ComObjPtr<Host>& VirtualBox::host() const
-{
-    return m->pHost;
-}
-
-SystemProperties* VirtualBox::getSystemProperties() const
-{
-    return m->pSystemProperties;
-}
-
-#ifdef VBOX_WITH_EXTPACK
-/**
- * Getter that SystemProperties and others can use to talk to the extension
- * pack manager.
- */
-ExtPackManager* VirtualBox::getExtPackManager() const
-{
-    return m->ptrExtPackManager;
-}
-#endif
-
-/**
- * Getter that machines can talk to the autostart database.
- */
-AutostartDb* VirtualBox::getAutostartDb() const
-{
-    return m->pAutostartDb;
-}
-
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-const ComObjPtr<PerformanceCollector>& VirtualBox::performanceCollector() const
-{
-    return m->pPerformanceCollector;
-}
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-/**
- * Returns the default machine folder from the system properties
- * with proper locking.
- * @return
- */
-void VirtualBox::getDefaultMachineFolder(Utf8Str &str) const
-{
-    AutoReadLock propsLock(m->pSystemProperties COMMA_LOCKVAL_SRC_POS);
-    str = m->pSystemProperties->m->strDefaultMachineFolder;
-}
-
-/**
- * Returns the default hard disk format from the system properties
- * with proper locking.
- * @return
- */
-void VirtualBox::getDefaultHardDiskFormat(Utf8Str &str) const
-{
-    AutoReadLock propsLock(m->pSystemProperties COMMA_LOCKVAL_SRC_POS);
-    str = m->pSystemProperties->m->strDefaultHardDiskFormat;
-}
-
-const Utf8Str& VirtualBox::homeDir() const
-{
-    return m->strHomeDir;
-}
-
-/**
- * Calculates the absolute path of the given path taking the VirtualBox home
- * directory as the current directory.
- *
- * @param  aPath    Path to calculate the absolute path for.
- * @param  aResult  Where to put the result (used only on success, can be the
- *                  same Utf8Str instance as passed in @a aPath).
- * @return IPRT result.
- *
- * @note Doesn't lock any object.
- */
-int VirtualBox::calculateFullPath(const Utf8Str &strPath, Utf8Str &aResult)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), VERR_GENERAL_FAILURE);
-
-    /* no need to lock since mHomeDir is const */
-
-    char folder[RTPATH_MAX];
-    int vrc = RTPathAbsEx(m->strHomeDir.c_str(),
-                          strPath.c_str(),
-                          folder,
-                          sizeof(folder));
-    if (RT_SUCCESS(vrc))
-        aResult = folder;
-
-    return vrc;
-}
-
-/**
- * Copies strSource to strTarget, making it relative to the VirtualBox config folder
- * if it is a subdirectory thereof, or simply copying it otherwise.
- *
- * @param strSource Path to evalue and copy.
- * @param strTarget Buffer to receive target path.
- */
-void VirtualBox::copyPathRelativeToConfig(const Utf8Str &strSource,
-                                          Utf8Str &strTarget)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturnVoid(autoCaller.rc());
-
-    // no need to lock since mHomeDir is const
-
-    // use strTarget as a temporary buffer to hold the machine settings dir
-    strTarget = m->strHomeDir;
-    if (RTPathStartsWith(strSource.c_str(), strTarget.c_str()))
-        // is relative: then append what's left
-        strTarget.append(strSource.c_str() + strTarget.length());     // include '/'
-    else
-        // is not relative: then overwrite
-        strTarget = strSource;
-}
-
-// private methods
-/////////////////////////////////////////////////////////////////////////////
-
-/**
- * Checks if there is a hard disk, DVD or floppy image with the given ID or
- * location already registered.
- *
- * On return, sets @a aConflict to the string describing the conflicting medium,
- * or sets it to @c Null if no conflicting media is found. Returns S_OK in
- * either case. A failure is unexpected.
- *
- * @param aId           UUID to check.
- * @param aLocation     Location to check.
- * @param aConflict     Where to return parameters of the conflicting medium.
- * @param ppMedium      Medium reference in case this is simply a duplicate.
- *
- * @note Locks the media tree and media objects for reading.
- */
-HRESULT VirtualBox::checkMediaForConflicts(const Guid &aId,
-                                           const Utf8Str &aLocation,
-                                           Utf8Str &aConflict,
-                                           ComObjPtr<Medium> *ppMedium)
-{
-    AssertReturn(!aId.isZero() && !aLocation.isEmpty(), E_FAIL);
-    AssertReturn(ppMedium, E_INVALIDARG);
-
-    aConflict.setNull();
-    ppMedium->setNull();
-
-    AutoReadLock alock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-
-    ComObjPtr<Medium> pMediumFound;
-    const char *pcszType = NULL;
-
-    if (aId.isValid() && !aId.isZero())
-        rc = findHardDiskById(aId, false /* aSetError */, &pMediumFound);
-    if (FAILED(rc) && !aLocation.isEmpty())
-        rc = findHardDiskByLocation(aLocation, false /* aSetError */, &pMediumFound);
-    if (SUCCEEDED(rc))
-        pcszType = tr("hard disk");
-
-    if (!pcszType)
-    {
-        rc = findDVDOrFloppyImage(DeviceType_DVD, &aId, aLocation, false /* aSetError */, &pMediumFound);
-        if (SUCCEEDED(rc))
-            pcszType = tr("CD/DVD image");
-    }
-
-    if (!pcszType)
-    {
-        rc = findDVDOrFloppyImage(DeviceType_Floppy, &aId, aLocation, false /* aSetError */, &pMediumFound);
-        if (SUCCEEDED(rc))
-            pcszType = tr("floppy image");
-    }
-
-    if (pcszType && pMediumFound)
-    {
-        /* Note: no AutoCaller since bound to this */
-        AutoReadLock mlock(pMediumFound COMMA_LOCKVAL_SRC_POS);
-
-        Utf8Str strLocFound = pMediumFound->getLocationFull();
-        Guid idFound = pMediumFound->getId();
-
-        if (    (RTPathCompare(strLocFound.c_str(), aLocation.c_str()) == 0)
-             && (idFound == aId)
-           )
-            *ppMedium = pMediumFound;
-
-        aConflict = Utf8StrFmt(tr("%s '%s' with UUID {%RTuuid}"),
-                               pcszType,
-                               strLocFound.c_str(),
-                               idFound.raw());
-    }
-
-    return S_OK;
-}
-
-/**
- * Checks whether the given UUID is already in use by one medium for the
- * given device type.
- *
- * @returns true if the UUID is already in use
- *          fale otherwise
- * @param   aId           The UUID to check.
- * @param   deviceType    The device type the UUID is going to be checked for
- *                        conflicts.
- */
-bool VirtualBox::isMediaUuidInUse(const Guid &aId, DeviceType_T deviceType)
-{
-    /* A zero UUID is invalid here, always claim that it is already used. */
-    AssertReturn(!aId.isZero(), true);
-
-    AutoReadLock alock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    HRESULT rc = S_OK;
-    bool fInUse = false;
-
-    ComObjPtr<Medium> pMediumFound;
-
-    switch (deviceType)
-    {
-        case DeviceType_HardDisk:
-            rc = findHardDiskById(aId, false /* aSetError */, &pMediumFound);
-            break;
-        case DeviceType_DVD:
-            rc = findDVDOrFloppyImage(DeviceType_DVD, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
-            break;
-        case DeviceType_Floppy:
-            rc = findDVDOrFloppyImage(DeviceType_Floppy, &aId, Utf8Str::Empty, false /* aSetError */, &pMediumFound);
-            break;
-        default:
-            AssertMsgFailed(("Invalid device type %d\n", deviceType));
-    }
-
-    if (SUCCEEDED(rc) && pMediumFound)
-        fInUse = true;
-
-    return fInUse;
-}
-
-/**
- * Called from Machine::prepareSaveSettings() when it has detected
- * that a machine has been renamed. Such renames will require
- * updating the global media registry during the
- * VirtualBox::saveSettings() that follows later.
-*
- * When a machine is renamed, there may well be media (in particular,
- * diff images for snapshots) in the global registry that will need
- * to have their paths updated. Before 3.2, Machine::saveSettings
- * used to call VirtualBox::saveSettings implicitly, which was both
- * unintuitive and caused locking order problems. Now, we remember
- * such pending name changes with this method so that
- * VirtualBox::saveSettings() can process them properly.
- */
-void VirtualBox::rememberMachineNameChangeForMedia(const Utf8Str &strOldConfigDir,
-                                                   const Utf8Str &strNewConfigDir)
-{
-    AutoWriteLock mediaLock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    Data::PendingMachineRename pmr;
-    pmr.strConfigDirOld = strOldConfigDir;
-    pmr.strConfigDirNew = strNewConfigDir;
-    m->llPendingMachineRenames.push_back(pmr);
-}
-
-struct SaveMediaRegistriesDesc
-{
-    MediaList llMedia;
-    ComObjPtr<VirtualBox> pVirtualBox;
-};
-
-static int fntSaveMediaRegistries(RTTHREAD ThreadSelf, void *pvUser)
-{
-    NOREF(ThreadSelf);
-    SaveMediaRegistriesDesc *pDesc = (SaveMediaRegistriesDesc *)pvUser;
-    if (!pDesc)
-    {
-        LogRelFunc(("Thread for saving media registries lacks parameters\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    for (MediaList::const_iterator it = pDesc->llMedia.begin();
-         it != pDesc->llMedia.end();
-         ++it)
-    {
-        Medium *pMedium = *it;
-        pMedium->markRegistriesModified();
-    }
-
-    pDesc->pVirtualBox->saveModifiedRegistries();
-
-    pDesc->llMedia.clear();
-    pDesc->pVirtualBox.setNull();
-    delete pDesc;
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Goes through all known media (hard disks, floppies and DVDs) and saves
- * those into the given settings::MediaRegistry structures whose registry
- * ID match the given UUID.
- *
- * Before actually writing to the structures, all media paths (not just the
- * ones for the given registry) are updated if machines have been renamed
- * since the last call.
- *
- * This gets called from two contexts:
- *
- *  -- VirtualBox::saveSettings() with the UUID of the global registry
- *     (VirtualBox::Data.uuidRegistry); this will save those media
- *     which had been loaded from the global registry or have been
- *     attached to a "legacy" machine which can't save its own registry;
- *
- *  -- Machine::saveSettings() with the UUID of a machine, if a medium
- *     has been attached to a machine created with VirtualBox 4.0 or later.
- *
- * Media which have only been temporarily opened without having been
- * attached to a machine have a NULL registry UUID and therefore don't
- * get saved.
- *
- * This locks the media tree. Throws HRESULT on errors!
- *
- * @param mediaRegistry Settings structure to fill.
- * @param uuidRegistry The UUID of the media registry; either a machine UUID (if machine registry) or the UUID of the global registry.
- * @param strMachineFolder The machine folder for relative paths, if machine registry, or an empty string otherwise.
- */
-void VirtualBox::saveMediaRegistry(settings::MediaRegistry &mediaRegistry,
-                                   const Guid &uuidRegistry,
-                                   const Utf8Str &strMachineFolder)
-{
-    // lock all media for the following; use a write lock because we're
-    // modifying the PendingMachineRenamesList, which is protected by this
-    AutoWriteLock mediaLock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    // if a machine was renamed, then we'll need to refresh media paths
-    if (m->llPendingMachineRenames.size())
-    {
-        // make a single list from the three media lists so we don't need three loops
-        MediaList llAllMedia;
-        // with hard disks, we must use the map, not the list, because the list only has base images
-        for (HardDiskMap::iterator it = m->mapHardDisks.begin(); it != m->mapHardDisks.end(); ++it)
-            llAllMedia.push_back(it->second);
-        for (MediaList::iterator it = m->allDVDImages.begin(); it != m->allDVDImages.end(); ++it)
-            llAllMedia.push_back(*it);
-        for (MediaList::iterator it = m->allFloppyImages.begin(); it != m->allFloppyImages.end(); ++it)
-            llAllMedia.push_back(*it);
-
-        SaveMediaRegistriesDesc *pDesc = new SaveMediaRegistriesDesc();
-        for (MediaList::iterator it = llAllMedia.begin();
-             it != llAllMedia.end();
-             ++it)
-        {
-            Medium *pMedium = *it;
-            for (Data::PendingMachineRenamesList::iterator it2 = m->llPendingMachineRenames.begin();
-                 it2 != m->llPendingMachineRenames.end();
-                 ++it2)
-            {
-                const Data::PendingMachineRename &pmr = *it2;
-                HRESULT rc = pMedium->updatePath(pmr.strConfigDirOld,
-                                                 pmr.strConfigDirNew);
-                if (SUCCEEDED(rc))
-                {
-                    // Remember which medium objects has been changed,
-                    // to trigger saving their registries later.
-                    pDesc->llMedia.push_back(pMedium);
-                } else if (rc == VBOX_E_FILE_ERROR)
-                    /* nothing */;
-                else
-                    AssertComRC(rc);
-            }
-        }
-        // done, don't do it again until we have more machine renames
-        m->llPendingMachineRenames.clear();
-
-        if (pDesc->llMedia.size())
-        {
-            // Handle the media registry saving in a separate thread, to
-            // avoid giant locking problems and passing up the list many
-            // levels up to whoever triggered saveSettings, as there are
-            // lots of places which would need to handle saving more settings.
-            pDesc->pVirtualBox = this;
-            int vrc = RTThreadCreate(NULL,
-                                     fntSaveMediaRegistries,
-                                     (void *)pDesc,
-                                     0,     // cbStack (default)
-                                     RTTHREADTYPE_MAIN_WORKER,
-                                     0,     // flags
-                                     "SaveMediaReg");
-            ComAssertRC(vrc);
-            // failure means that settings aren't saved, but there isn't
-            // much we can do besides avoiding memory leaks
-            if (RT_FAILURE(vrc))
-            {
-                LogRelFunc(("Failed to create thread for saving media registries (%Rrc)\n", vrc));
-                delete pDesc;
-            }
-        }
-        else
-            delete pDesc;
-    }
-
-    struct {
-        MediaOList &llSource;
-        settings::MediaList &llTarget;
-    } s[] =
-    {
-        // hard disks
-        { m->allHardDisks, mediaRegistry.llHardDisks },
-        // CD/DVD images
-        { m->allDVDImages, mediaRegistry.llDvdImages },
-        // floppy images
-        { m->allFloppyImages, mediaRegistry.llFloppyImages }
-    };
-
-    HRESULT rc;
-
-    for (size_t i = 0; i < RT_ELEMENTS(s); ++i)
-    {
-        MediaOList &llSource = s[i].llSource;
-        settings::MediaList &llTarget = s[i].llTarget;
-        llTarget.clear();
-        for (MediaList::const_iterator it = llSource.begin();
-             it != llSource.end();
-             ++it)
-        {
-            Medium *pMedium = *it;
-            AutoCaller autoCaller(pMedium);
-            if (FAILED(autoCaller.rc())) throw autoCaller.rc();
-            AutoReadLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
-
-            if (pMedium->isInRegistry(uuidRegistry))
-            {
-                settings::Medium med;
-                rc = pMedium->saveSettings(med, strMachineFolder);     // this recurses into child hard disks
-                if (FAILED(rc)) throw rc;
-                llTarget.push_back(med);
-            }
-        }
-    }
-}
-
-/**
- *  Helper function which actually writes out VirtualBox.xml, the main configuration file.
- *  Gets called from the public VirtualBox::SaveSettings() as well as from various other
- *  places internally when settings need saving.
- *
- *  @note Caller must have locked the VirtualBox object for writing and must not hold any
- *    other locks since this locks all kinds of member objects and trees temporarily,
- *    which could cause conflicts.
- */
-HRESULT VirtualBox::saveSettings()
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AssertReturn(isWriteLockOnCurrentThread(), E_FAIL);
-    AssertReturn(!m->strSettingsFilePath.isEmpty(), E_FAIL);
-
-    HRESULT rc = S_OK;
-
-    try
-    {
-        // machines
-        m->pMainConfigFile->llMachines.clear();
-        {
-            AutoReadLock machinesLock(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-            for (MachinesOList::iterator it = m->allMachines.begin();
-                 it != m->allMachines.end();
-                 ++it)
-            {
-                Machine *pMachine = *it;
-                // save actual machine registry entry
-                settings::MachineRegistryEntry mre;
-                rc = pMachine->saveRegistryEntry(mre);
-                m->pMainConfigFile->llMachines.push_back(mre);
-            }
-        }
-
-        saveMediaRegistry(m->pMainConfigFile->mediaRegistry,
-                          m->uuidMediaRegistry,         // global media registry ID
-                          Utf8Str::Empty);              // strMachineFolder
-
-        m->pMainConfigFile->llDhcpServers.clear();
-        {
-            AutoReadLock dhcpLock(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-            for (DHCPServersOList::const_iterator it = m->allDHCPServers.begin();
-                 it != m->allDHCPServers.end();
-                 ++it)
-            {
-                settings::DHCPServer d;
-                rc = (*it)->saveSettings(d);
-                if (FAILED(rc)) throw rc;
-                m->pMainConfigFile->llDhcpServers.push_back(d);
-            }
-        }
-
-#ifdef VBOX_WITH_NAT_SERVICE
-        /* Saving NAT Network configuration */
-        m->pMainConfigFile->llNATNetworks.clear();
-        {
-            AutoReadLock natNetworkLock(m->allNATNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-            for (NATNetworksOList::const_iterator it = m->allNATNetworks.begin();
-                 it != m->allNATNetworks.end();
-                 ++it)
-            {
-                settings::NATNetwork n;
-                rc = (*it)->saveSettings(n);
-                if (FAILED(rc)) throw rc;
-                m->pMainConfigFile->llNATNetworks.push_back(n);
-            }
-        }
-#endif
-
-        // leave extra data alone, it's still in the config file
-
-        // host data (USB filters)
-        rc = m->pHost->saveSettings(m->pMainConfigFile->host);
-        if (FAILED(rc)) throw rc;
-
-        rc = m->pSystemProperties->saveSettings(m->pMainConfigFile->systemProperties);
-        if (FAILED(rc)) throw rc;
-
-        // and write out the XML, still under the lock
-        m->pMainConfigFile->write(m->strSettingsFilePath);
-    }
-    catch (HRESULT err)
-    {
-        /* we assume that error info is set by the thrower */
-        rc = err;
-    }
-    catch (...)
-    {
-        rc = VirtualBoxBase::handleUnexpectedExceptions(this, RT_SRC_POS);
-    }
-
-    return rc;
-}
-
-/**
- *  Helper to register the machine.
- *
- *  When called during VirtualBox startup, adds the given machine to the
- *  collection of registered machines. Otherwise tries to mark the machine
- *  as registered, and, if succeeded, adds it to the collection and
- *  saves global settings.
- *
- *  @note The caller must have added itself as a caller of the @a aMachine
- *  object if calls this method not on VirtualBox startup.
- *
- *  @param aMachine     machine to register
- *
- *  @note Locks objects!
- */
-HRESULT VirtualBox::registerMachine(Machine *aMachine)
-{
-    ComAssertRet(aMachine, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc = S_OK;
-
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-    {
-        ComObjPtr<Machine> pMachine;
-        rc = findMachine(aMachine->getId(),
-                         true /* fPermitInaccessible */,
-                         false /* aDoSetError */,
-                         &pMachine);
-        if (SUCCEEDED(rc))
-        {
-            /* sanity */
-            AutoLimitedCaller machCaller(pMachine);
-            AssertComRC(machCaller.rc());
-
-            return setError(E_INVALIDARG,
-                            tr("Registered machine with UUID {%RTuuid} ('%s') already exists"),
-                            aMachine->getId().raw(),
-                            pMachine->getSettingsFileFull().c_str());
-        }
-
-        ComAssertRet(rc == VBOX_E_OBJECT_NOT_FOUND, rc);
-        rc = S_OK;
-    }
-
-    if (autoCaller.state() != InInit)
-    {
-        rc = aMachine->prepareRegister();
-        if (FAILED(rc)) return rc;
-    }
-
-    /* add to the collection of registered machines */
-    m->allMachines.addChild(aMachine);
-
-    if (autoCaller.state() != InInit)
-        rc = saveSettings();
-
-    return rc;
-}
-
-/**
- * Remembers the given medium object by storing it in either the global
- * medium registry or a machine one.
- *
- * @note Caller must hold the media tree lock for writing; in addition, this
- * locks @a pMedium for reading
- *
- * @param pMedium   Medium object to remember.
- * @param ppMedium  Actually stored medium object. Can be different if due
- *                  to an unavoidable race there was a duplicate Medium object
- *                  created.
- * @param argType   Either DeviceType_HardDisk, DeviceType_DVD or DeviceType_Floppy.
- * @return
- */
-HRESULT VirtualBox::registerMedium(const ComObjPtr<Medium> &pMedium,
-                                   ComObjPtr<Medium> *ppMedium,
-                                   DeviceType_T argType)
-{
-    AssertReturn(pMedium != NULL, E_INVALIDARG);
-    AssertReturn(ppMedium != NULL, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoCaller mediumCaller(pMedium);
-    AssertComRCReturn(mediumCaller.rc(), mediumCaller.rc());
-
-    const char *pszDevType = NULL;
-    ObjectsList<Medium> *pall = NULL;
-    switch (argType)
-    {
-        case DeviceType_HardDisk:
-            pall = &m->allHardDisks;
-            pszDevType = tr("hard disk");
-            break;
-        case DeviceType_DVD:
-            pszDevType = tr("DVD image");
-            pall = &m->allDVDImages;
-            break;
-        case DeviceType_Floppy:
-            pszDevType = tr("floppy image");
-            pall = &m->allFloppyImages;
-            break;
-        default:
-            AssertMsgFailedReturn(("invalid device type %d", argType), E_INVALIDARG);
-    }
-
-    // caller must hold the media tree write lock
-    Assert(getMediaTreeLockHandle().isWriteLockOnCurrentThread());
-
-    Guid id;
-    Utf8Str strLocationFull;
-    ComObjPtr<Medium> pParent;
-    {
-        AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-        id = pMedium->getId();
-        strLocationFull = pMedium->getLocationFull();
-        pParent = pMedium->getParent();
-    }
-
-    HRESULT rc;
-
-    Utf8Str strConflict;
-    ComObjPtr<Medium> pDupMedium;
-    rc = checkMediaForConflicts(id,
-                                strLocationFull,
-                                strConflict,
-                                &pDupMedium);
-    if (FAILED(rc)) return rc;
-
-    if (pDupMedium.isNull())
-    {
-        if (strConflict.length())
-            return setError(E_INVALIDARG,
-                            tr("Cannot register the %s '%s' {%RTuuid} because a %s already exists"),
-                            pszDevType,
-                            strLocationFull.c_str(),
-                            id.raw(),
-                            strConflict.c_str(),
-                            m->strSettingsFilePath.c_str());
-
-        // add to the collection if it is a base medium
-        if (pParent.isNull())
-            pall->getList().push_back(pMedium);
-
-        // store all hard disks (even differencing images) in the map
-        if (argType == DeviceType_HardDisk)
-            m->mapHardDisks[id] = pMedium;
-
-        *ppMedium = pMedium;
-    }
-    else
-    {
-        // pMedium may be the last reference to the Medium object, and the
-        // caller may have specified the same ComObjPtr as the output parameter.
-        // In this case the assignment will uninit the object, and we must not
-        // have a caller pending.
-        mediumCaller.release();
-        *ppMedium = pDupMedium;
-    }
-
-    return rc;
-}
-
-/**
- * Removes the given medium from the respective registry.
- *
- * @param pMedium    Hard disk object to remove.
- *
- * @note Caller must hold the media tree lock for writing; in addition, this locks @a pMedium for reading
- */
-HRESULT VirtualBox::unregisterMedium(Medium *pMedium)
-{
-    AssertReturn(pMedium != NULL, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoCaller mediumCaller(pMedium);
-    AssertComRCReturn(mediumCaller.rc(), mediumCaller.rc());
-
-    // caller must hold the media tree write lock
-    Assert(getMediaTreeLockHandle().isWriteLockOnCurrentThread());
-
-    Guid id;
-    ComObjPtr<Medium> pParent;
-    DeviceType_T devType;
-    {
-        AutoReadLock mediumLock(pMedium COMMA_LOCKVAL_SRC_POS);
-        id = pMedium->getId();
-        pParent = pMedium->getParent();
-        devType = pMedium->getDeviceType();
-    }
-
-    ObjectsList<Medium> *pall = NULL;
-    switch (devType)
-    {
-        case DeviceType_HardDisk:
-            pall = &m->allHardDisks;
-            break;
-        case DeviceType_DVD:
-            pall = &m->allDVDImages;
-            break;
-        case DeviceType_Floppy:
-            pall = &m->allFloppyImages;
-            break;
-        default:
-            AssertMsgFailedReturn(("invalid device type %d", devType), E_INVALIDARG);
-    }
-
-    // remove from the collection if it is a base medium
-    if (pParent.isNull())
-        pall->getList().remove(pMedium);
-
-    // remove all hard disks (even differencing images) from map
-    if (devType == DeviceType_HardDisk)
-    {
-        size_t cnt = m->mapHardDisks.erase(id);
-        Assert(cnt == 1);
-        NOREF(cnt);
-    }
-
-    return S_OK;
-}
-
-/**
- * Little helper called from unregisterMachineMedia() to recursively add media to the given list,
- * with children appearing before their parents.
- * @param llMedia
- * @param pMedium
- */
-void VirtualBox::pushMediumToListWithChildren(MediaList &llMedia, Medium *pMedium)
-{
-    // recurse first, then add ourselves; this way children end up on the
-    // list before their parents
-
-    const MediaList &llChildren = pMedium->getChildren();
-    for (MediaList::const_iterator it = llChildren.begin();
-         it != llChildren.end();
-         ++it)
-    {
-        Medium *pChild = *it;
-        pushMediumToListWithChildren(llMedia, pChild);
-    }
-
-    Log(("Pushing medium %RTuuid\n", pMedium->getId().raw()));
-    llMedia.push_back(pMedium);
-}
-
-/**
- * Unregisters all Medium objects which belong to the given machine registry.
- * Gets called from Machine::uninit() just before the machine object dies
- * and must only be called with a machine UUID as the registry ID.
- *
- * Locks the media tree.
- *
- * @param uuidMachine Medium registry ID (always a machine UUID)
- * @return
- */
-HRESULT VirtualBox::unregisterMachineMedia(const Guid &uuidMachine)
-{
-    Assert(!uuidMachine.isZero() && uuidMachine.isValid());
-
-    LogFlowFuncEnter();
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    MediaList llMedia2Close;
-
-    {
-        AutoWriteLock tlock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-        for (MediaOList::iterator it = m->allHardDisks.getList().begin();
-             it != m->allHardDisks.getList().end();
-             ++it)
-        {
-            ComObjPtr<Medium> pMedium = *it;
-            AutoCaller medCaller(pMedium);
-            if (FAILED(medCaller.rc())) return medCaller.rc();
-            AutoReadLock medlock(pMedium COMMA_LOCKVAL_SRC_POS);
-
-            if (pMedium->isInRegistry(uuidMachine))
-                // recursively with children first
-                pushMediumToListWithChildren(llMedia2Close, pMedium);
-        }
-    }
-
-    for (MediaList::iterator it = llMedia2Close.begin();
-         it != llMedia2Close.end();
-         ++it)
-    {
-        ComObjPtr<Medium> pMedium = *it;
-        Log(("Closing medium %RTuuid\n", pMedium->getId().raw()));
-        AutoCaller mac(pMedium);
-        pMedium->close(mac);
-    }
-
-    LogFlowFuncLeave();
-
-    return S_OK;
-}
-
-/**
- * Removes the given machine object from the internal list of registered machines.
- * Called from Machine::Unregister().
- * @param pMachine
- * @param id  UUID of the machine. Must be passed by caller because machine may be dead by this time.
- * @return
- */
-HRESULT VirtualBox::unregisterMachine(Machine *pMachine,
-                                      const Guid &id)
-{
-    // remove from the collection of registered machines
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    m->allMachines.removeChild(pMachine);
-    // save the global registry
-    HRESULT rc = saveSettings();
-    alock.release();
-
-    /*
-     * Now go over all known media and checks if they were registered in the
-     * media registry of the given machine. Each such medium is then moved to
-     * a different media registry to make sure it doesn't get lost since its
-     * media registry is about to go away.
-     *
-     * This fixes the following use case: Image A.vdi of machine A is also used
-     * by machine B, but registered in the media registry of machine A. If machine
-     * A is deleted, A.vdi must be moved to the registry of B, or else B will
-     * become inaccessible.
-     */
-    {
-        AutoReadLock tlock(getMediaTreeLockHandle() COMMA_LOCKVAL_SRC_POS);
-        // iterate over the list of *base* images
-        for (MediaOList::iterator it = m->allHardDisks.getList().begin();
-             it != m->allHardDisks.getList().end();
-             ++it)
-        {
-            ComObjPtr<Medium> &pMedium = *it;
-            AutoCaller medCaller(pMedium);
-            if (FAILED(medCaller.rc())) return medCaller.rc();
-            AutoWriteLock mlock(pMedium COMMA_LOCKVAL_SRC_POS);
-
-            if (pMedium->removeRegistry(id, true /* fRecurse */))
-            {
-                // machine ID was found in base medium's registry list:
-                // move this base image and all its children to another registry then
-                // 1) first, find a better registry to add things to
-                const Guid *puuidBetter = pMedium->getAnyMachineBackref();
-                if (puuidBetter)
-                {
-                    // 2) better registry found: then use that
-                    pMedium->addRegistry(*puuidBetter, true /* fRecurse */);
-                    // 3) and make sure the registry is saved below
-                    mlock.release();
-                    tlock.release();
-                    markRegistryModified(*puuidBetter);
-                    tlock.acquire();
-                    mlock.release();
-                }
-            }
-        }
-    }
-
-    saveModifiedRegistries();
-
-    /* fire an event */
-    onMachineRegistered(id, FALSE);
-
-    return rc;
-}
-
-/**
- * Marks the registry for @a uuid as modified, so that it's saved in a later
- * call to saveModifiedRegistries().
- *
- * @param uuid
- */
-void VirtualBox::markRegistryModified(const Guid &uuid)
-{
-    if (uuid == getGlobalRegistryId())
-        ASMAtomicIncU64(&m->uRegistryNeedsSaving);
-    else
-    {
-        ComObjPtr<Machine> pMachine;
-        HRESULT rc = findMachine(uuid,
-                                 false /* fPermitInaccessible */,
-                                 false /* aSetError */,
-                                 &pMachine);
-        if (SUCCEEDED(rc))
-        {
-            AutoCaller machineCaller(pMachine);
-            if (SUCCEEDED(machineCaller.rc()))
-                ASMAtomicIncU64(&pMachine->uRegistryNeedsSaving);
-        }
-    }
-}
-
-/**
- * Saves all settings files according to the modified flags in the Machine
- * objects and in the VirtualBox object.
- *
- * This locks machines and the VirtualBox object as necessary, so better not
- * hold any locks before calling this.
- *
- * @return
- */
-void VirtualBox::saveModifiedRegistries()
-{
-    HRESULT rc = S_OK;
-    bool fNeedsGlobalSettings = false;
-    uint64_t uOld;
-
-    {
-        AutoReadLock alock(m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-        for (MachinesOList::iterator it = m->allMachines.begin();
-             it != m->allMachines.end();
-             ++it)
-        {
-            const ComObjPtr<Machine> &pMachine = *it;
-
-            for (;;)
-            {
-                uOld = ASMAtomicReadU64(&pMachine->uRegistryNeedsSaving);
-                if (!uOld)
-                    break;
-                if (ASMAtomicCmpXchgU64(&pMachine->uRegistryNeedsSaving, 0, uOld))
-                    break;
-                ASMNopPause();
-            }
-            if (uOld)
-            {
-                AutoCaller autoCaller(pMachine);
-                if (FAILED(autoCaller.rc()))
-                    continue;
-                /* object is already dead, no point in saving settings */
-                if (autoCaller.state() != Ready)
-                    continue;
-                AutoWriteLock mlock(pMachine COMMA_LOCKVAL_SRC_POS);
-                rc = pMachine->saveSettings(&fNeedsGlobalSettings,
-                                            Machine::SaveS_Force);           // caller said save, so stop arguing
-            }
-        }
-    }
-
-    for (;;)
-    {
-        uOld = ASMAtomicReadU64(&m->uRegistryNeedsSaving);
-        if (!uOld)
-            break;
-        if (ASMAtomicCmpXchgU64(&m->uRegistryNeedsSaving, 0, uOld))
-            break;
-        ASMNopPause();
-    }
-    if (uOld || fNeedsGlobalSettings)
-    {
-        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-        rc = saveSettings();
-    }
-    NOREF(rc); /* XXX */
-}
-
-
-/* static */
-const Bstr &VirtualBox::getVersionNormalized()
-{
-    return sVersionNormalized;
-}
-
-/**
- * Checks if the path to the specified file exists, according to the path
- * information present in the file name. Optionally the path is created.
- *
- * Note that the given file name must contain the full path otherwise the
- * extracted relative path will be created based on the current working
- * directory which is normally unknown.
- *
- * @param aFileName     Full file name which path is checked/created.
- * @param aCreate       Flag if the path should be created if it doesn't exist.
- *
- * @return Extended error information on failure to check/create the path.
- */
-/* static */
-HRESULT VirtualBox::ensureFilePathExists(const Utf8Str &strFileName, bool fCreate)
-{
-    Utf8Str strDir(strFileName);
-    strDir.stripFilename();
-    if (!RTDirExists(strDir.c_str()))
-    {
-        if (fCreate)
-        {
-            int vrc = RTDirCreateFullPath(strDir.c_str(), 0700);
-            if (RT_FAILURE(vrc))
-                return setErrorStatic(VBOX_E_IPRT_ERROR,
-                                      Utf8StrFmt(tr("Could not create the directory '%s' (%Rrc)"),
-                                                 strDir.c_str(),
-                                                 vrc));
-        }
-        else
-            return setErrorStatic(VBOX_E_IPRT_ERROR,
-                                  Utf8StrFmt(tr("Directory '%s' does not exist"),
-                                             strDir.c_str()));
-    }
-
-    return S_OK;
-}
-
-const Utf8Str& VirtualBox::settingsFilePath()
-{
-    return m->strSettingsFilePath;
-}
-
-/**
- * Returns the lock handle which protects the media trees (hard disks,
- * DVDs, floppies). As opposed to version 3.1 and earlier, these lists
- * are no longer protected by the VirtualBox lock, but by this more
- * specialized lock. Mind the locking order: always request this lock
- * after the VirtualBox object lock but before the locks of the media
- * objects contained in these lists. See AutoLock.h.
- */
-RWLockHandle& VirtualBox::getMediaTreeLockHandle()
-{
-    return m->lockMedia;
-}
-
-/**
- *  Thread function that watches the termination of all client processes
- *  that have opened sessions using IMachine::LockMachine()
- */
-// static
-DECLCALLBACK(int) VirtualBox::ClientWatcher(RTTHREAD /* thread */, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    VirtualBox *that = (VirtualBox*)pvUser;
-    Assert(that);
-
-    typedef std::vector< ComObjPtr<Machine> > MachineVector;
-    typedef std::vector< ComObjPtr<SessionMachine> > SessionMachineVector;
-
-    SessionMachineVector machines;
-    MachineVector spawnedMachines;
-
-    size_t cnt = 0;
-    size_t cntSpawned = 0;
-
-    VirtualBoxBase::initializeComForThread();
-
-#if defined(RT_OS_WINDOWS)
-
-    /// @todo (dmik) processes reaping!
-
-    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
-    handles[0] = that->m->updateReq;
-
-    do
-    {
-        AutoCaller autoCaller(that);
+        AutoCaller autoCaller(that->mVirtualBox);
         /* VirtualBox has been early uninitialized, terminate */
         if (!autoCaller.isOk())
@@ -4934 +232 @@
                     CloseHandle(handles[i]);
 
+                // get reference to the machines list in VirtualBox
+                VirtualBox::MachinesOList &allMachines = that->mVirtualBox->getMachinesList();
+
                 // lock the machines list for reading
-                AutoReadLock thatLock(that->m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+                AutoReadLock thatLock(allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
 
                 /* obtain a new set of opened machines */
@@ -4941 +242 @@
                 machines.clear();
 
-                for (MachinesOList::iterator it = that->m->allMachines.begin();
-                     it != that->m->allMachines.end();
+                for (MachinesOList::iterator it = allMachines.begin();
+                     it != allMachines.end();
                      ++it)
                 {
@@ -4950 +251 @@
 
                     ComObjPtr<SessionMachine> sm;
-                    HANDLE ipcSem;
-                    if ((*it)->isSessionOpenOrClosing(sm, NULL, &ipcSem))
-                    {
-                        machines.push_back(sm);
-                        handles[1 + cnt] = ipcSem;
-                        ++cnt;
+                    if ((*it)->isSessionOpenOrClosing(sm))
+                    {
+                        AutoCaller smCaller(sm);
+                        if (smCaller.isOk())
+                        {
+                            AutoReadLock smLock(sm COMMA_LOCKVAL_SRC_POS);
+                            Machine::ClientToken *ct = sm->getClientToken();
+                            if (ct)
+                            {
+                                HANDLE ipcSem = ct->getToken();
+                                machines.push_back(sm);
+                                handles[1 + cnt] = ipcSem;
+                                ++cnt;
+                            }
+                        }
                     }
                 }
@@ -4965 +275 @@
                 spawnedMachines.clear();
 
-                for (MachinesOList::iterator it = that->m->allMachines.begin();
-                     it != that->m->allMachines.end();
+                for (MachinesOList::iterator it = allMachines.begin();
+                     it != allMachines.end();
                      ++it)
                 {
@@ -4973 +283 @@
                                    ("MAXIMUM_WAIT_OBJECTS reached"));
 
-                    RTPROCESS pid;
-                    if ((*it)->isSessionSpawning(&pid))
-                    {
-                        HANDLE ph = OpenProcess(SYNCHRONIZE, FALSE, pid);
-                        AssertMsg(ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
-                                               pid, GetLastError()));
-                        if (rc == 0)
+                    if ((*it)->isSessionSpawning())
+                    {
+                        ULONG pid;
+                        HRESULT hrc = (*it)->COMGETTER(SessionPID)(&pid);
+                        if (SUCCEEDED(hrc))
                         {
-                            spawnedMachines.push_back(*it);
-                            handles[1 + cnt + cntSpawned] = ph;
-                            ++cntSpawned;
+                            HANDLE ph = OpenProcess(SYNCHRONIZE, FALSE, pid);
+                            AssertMsg(ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
+                                                   pid, GetLastError()));
+                            if (ph != NULL)
+                            {
+                                spawnedMachines.push_back(*it);
+                                handles[1 + cnt + cntSpawned] = ph;
+                                ++cntSpawned;
+                            }
                         }
                     }
@@ -4998 +312 @@
 
     /* close old process handles */
-    for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++ i)
+    for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++i)
         CloseHandle(handles[i]);
 
@@ -5018 +332 @@
     do
     {
-        AutoCaller autoCaller(that);
+        AutoCaller autoCaller(that->mVirtualBox);
         /* VirtualBox has been early uninitialized, terminate */
         if (!autoCaller.isOk())
@@ -5028 +342 @@
             autoCaller.release();
 
-            int vrc = RTSemEventWait(that->m->updateReq, 500);
+            int vrc = RTSemEventWait(that->mUpdateReq, 500);
 
             /* Restore the caller before using VirtualBox. If it fails, this
@@ -5081 +395 @@
                          * termination; find which mutex is in the Owner Died
                          * state */
-                        for (size_t i = 0; i < cnt; ++ i)
+                        for (size_t i = 0; i < cnt; ++i)
                         {
                             PID pid; TID tid;
@@ -5115 +429 @@
                 if (cntSpawned > 0)
                 {
-                    for (size_t i = 0; i < cntSpawned; ++ i)
+                    for (size_t i = 0; i < cntSpawned; ++i)
                         updateSpawned |= (spawnedMachines[i])->
                             checkForSpawnFailure();
@@ -5123 +437 @@
             if (update || updateSpawned)
             {
-                AutoReadLock thatLock(that COMMA_LOCKVAL_SRC_POS);
+                // get reference to the machines list in VirtualBox
+                VirtualBox::MachinesOList &allMachines = that->mVirtualBox->getMachinesList();
+
+                // lock the machines list for reading
+                AutoReadLock thatLock(allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
 
                 if (update)
@@ -5135 +453 @@
                     machines.clear();
 
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end(); ++ it)
+                    for (MachinesOList::iterator it = allMachines.begin();
+                         it != allMachines.end(); ++it)
                     {
                         /// @todo handle situations with more than 64 objects
@@ -5144 +462 @@
 
                         ComObjPtr<SessionMachine> sm;
-                        HMTX ipcSem;
-                        if ((*it)->isSessionOpenOrClosing(sm, NULL, &ipcSem))
+                        if ((*it)->isSessionOpenOrClosing(sm))
                         {
-                            machines.push_back(sm);
-                            handles[cnt].hsemCur = (HSEM)ipcSem;
-                            handles[cnt].ulUser = cnt;
-                            ++ cnt;
+                            AutoCaller smCaller(sm);
+                            if (smCaller.isOk())
+                            {
+                                AutoReadLock smLock(sm COMMA_LOCKVAL_SRC_POS);
+                                ClientToken *ct = sm->getClientToken();
+                                if (ct)
+                                {
+                                    HMTX ipcSem = ct->getToken();
+                                    machines.push_back(sm);
+                                    handles[cnt].hsemCur = (HSEM)ipcSem;
+                                    handles[cnt].ulUser = cnt;
+                                    ++cnt;
+                                }
+                            }
                         }
                     }
@@ -5173 +500 @@
                     spawnedMachines.clear();
 
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end(); ++ it)
+                    for (MachinesOList::iterator it = allMachines.begin();
+                         it != allMachines.end(); ++it)
                     {
                         if ((*it)->isSessionSpawning())
@@ -5204 +531 @@
     do
     {
-        AutoCaller autoCaller(that);
+        AutoCaller autoCaller(that->mVirtualBox);
         if (!autoCaller.isOk())
             break;
@@ -5223 +550 @@
                 do
                 {
-                    uOld = ASMAtomicUoReadU8(&that->m->updateAdaptCtr);
+                    uOld = ASMAtomicUoReadU8(&that->mUpdateAdaptCtr);
                     uNew = uOld ? uOld - 1 : uOld;
-                } while (!ASMAtomicCmpXchgU8(&that->m->updateAdaptCtr, uNew, uOld));
-                Assert(uOld <= RT_ELEMENTS(s_updateAdaptTimeouts) - 1);
-                cMillies = s_updateAdaptTimeouts[uOld];
-            }
-
-            int rc = RTSemEventWait(that->m->updateReq, cMillies);
+                } while (!ASMAtomicCmpXchgU8(&that->mUpdateAdaptCtr, uNew, uOld));
+                Assert(uOld <= RT_ELEMENTS(s_aUpdateTimeoutSteps) - 1);
+                cMillies = s_aUpdateTimeoutSteps[uOld];
+            }
+
+            int rc = RTSemEventWait(that->mUpdateReq, cMillies);
 
             /*
@@ -5244 +571 @@
                 /* RT_SUCCESS(rc) means an update event is signaled */
 
+                // get reference to the machines list in VirtualBox
+                VirtualBox::MachinesOList &allMachines = that->mVirtualBox->getMachinesList();
+
                 // lock the machines list for reading
-                AutoReadLock thatLock(that->m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
+                AutoReadLock thatLock(allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
 
                 if (RT_SUCCESS(rc) || update)
@@ -5252 +582 @@
                     machines.clear();
 
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end();
+                    for (MachinesOList::iterator it = allMachines.begin();
+                         it != allMachines.end();
                          ++it)
                     {
@@ -5270 +600 @@
                     spawnedMachines.clear();
 
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end();
+                    for (MachinesOList::iterator it = allMachines.begin();
+                         it != allMachines.end();
                          ++it)
                     {
@@ -5286 +616 @@
 
             update = false;
-            for (size_t i = 0; i < cnt; ++ i)
+            for (size_t i = 0; i < cnt; ++i)
                 update |= (machines[i])->checkForDeath();
 
             updateSpawned = false;
-            for (size_t i = 0; i < cntSpawned; ++ i)
+            for (size_t i = 0; i < cntSpawned; ++i)
                 updateSpawned |= (spawnedMachines[i])->checkForSpawnFailure();
 
             /* reap child processes */
             {
-                AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
-                if (that->m->llProcesses.size())
+                AutoWriteLock alock(that->mLock COMMA_LOCKVAL_SRC_POS);
+                if (that->mProcesses.size())
                 {
                     LogFlowFunc(("UPDATE: child process count = %d\n",
-                                 that->m->llProcesses.size()));
-                    VirtualBox::Data::ProcessList::iterator it = that->m->llProcesses.begin();
-                    while (it != that->m->llProcesses.end())
+                                 that->mProcesses.size()));
+                    VirtualBox::ClientWatcher::ProcessList::iterator it = that->mProcesses.begin();
+                    while (it != that->mProcesses.end())
                     {
                         RTPROCESS pid = *it;
@@ -5311 +641 @@
                                          pid, pid, status.iStatus,
                                          status.enmReason));
-                            it = that->m->llProcesses.erase(it);
+                            it = that->mProcesses.erase(it);
                         }
                         else
@@ -5320 +650 @@
                             {
                                 /* remove the process if it is not already running */
-                                it = that->m->llProcesses.erase(it);
+                                it = that->mProcesses.erase(it);
                             }
                             else
-                                ++ it;
+                                ++it;
                         }
                     }
@@ -5342 +672 @@
 
     VirtualBoxBase::uninitializeComForThread();
+
     LogFlowFuncLeave();
     return 0;
 }
-
-/**
- *  Thread function that handles custom events posted using #postEvent().
- */
-// static
-DECLCALLBACK(int) VirtualBox::AsyncEventHandler(RTTHREAD thread, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    AssertReturn(pvUser, VERR_INVALID_POINTER);
-
-    HRESULT hr = com::Initialize();
-    if (FAILED(hr))
-        return VERR_COM_UNEXPECTED;
-
-    int rc = VINF_SUCCESS;
-
-    try
-    {
-        /* Create an event queue for the current thread. */
-        EventQueue *pEventQueue = new EventQueue();
-        AssertPtr(pEventQueue);
-
-        /* Return the queue to the one who created this thread. */
-        *(static_cast <EventQueue **>(pvUser)) = pEventQueue;
-
-        /* signal that we're ready. */
-        RTThreadUserSignal(thread);
-
-        /*
-         * In case of spurious wakeups causing VERR_TIMEOUTs and/or other return codes
-         * we must not stop processing events and delete the pEventQueue object. This must
-         * be done ONLY when we stop this loop via interruptEventQueueProcessing().
-         * See @bugref{5724}.
-         */
-        for (;;)
-        {
-            rc = pEventQueue->processEventQueue(RT_INDEFINITE_WAIT);
-            if (rc == VERR_INTERRUPTED)
-            {
-                LogFlow(("Event queue processing ended with rc=%Rrc\n", rc));
-                rc = VINF_SUCCESS; /* Set success when exiting. */
-                break;
-            }
-        }
-
-        delete pEventQueue;
-    }
-    catch (std::bad_alloc &ba)
-    {
-        rc = VERR_NO_MEMORY;
-        NOREF(ba);
-    }
-
-    com::Shutdown();
-
-    LogFlowFuncLeaveRC(rc);
-    return rc;
-}
-
-
-////////////////////////////////////////////////////////////////////////////////
-
-/**
- *  Takes the current list of registered callbacks of the managed VirtualBox
- *  instance, and calls #handleCallback() for every callback item from the
- *  list, passing the item as an argument.
- *
- *  @note Locks the managed VirtualBox object for reading but leaves the lock
- *        before iterating over callbacks and calling their methods.
- */
-void *VirtualBox::CallbackEvent::handler()
-{
-    if (!mVirtualBox)
-        return NULL;
-
-    AutoCaller autoCaller(mVirtualBox);
-    if (!autoCaller.isOk())
-    {
-        LogWarningFunc(("VirtualBox has been uninitialized (state=%d), the callback event is discarded!\n",
-                        autoCaller.state()));
-        /* We don't need mVirtualBox any more, so release it */
-        mVirtualBox = NULL;
-        return NULL;
-    }
-
-    {
-        VBoxEventDesc evDesc;
-        prepareEventDesc(mVirtualBox->m->pEventSource, evDesc);
-
-        evDesc.fire(/* don't wait for delivery */0);
-    }
-
-    mVirtualBox = NULL; /* Not needed any longer. Still make sense to do this? */
-    return NULL;
-}
-
-//STDMETHODIMP VirtualBox::CreateDHCPServerForInterface(/*IHostNetworkInterface * aIinterface,*/ IDHCPServer ** aServer)
-//{
-//    return E_NOTIMPL;
-//}
-
-STDMETHODIMP VirtualBox::CreateDHCPServer(IN_BSTR aName, IDHCPServer ** aServer)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgNotNull(aServer);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComObjPtr<DHCPServer> dhcpServer;
-    dhcpServer.createObject();
-    HRESULT rc = dhcpServer->init(this, aName);
-    if (FAILED(rc)) return rc;
-
-    rc = registerDHCPServer(dhcpServer, true);
-    if (FAILED(rc)) return rc;
-
-    dhcpServer.queryInterfaceTo(aServer);
-
-    return rc;
-}
-
-STDMETHODIMP VirtualBox::FindDHCPServerByNetworkName(IN_BSTR aName, IDHCPServer ** aServer)
-{
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgNotNull(aServer);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc;
-    Bstr bstr;
-    ComPtr<DHCPServer> found;
-
-    AutoReadLock alock(m->allDHCPServers.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    for (DHCPServersOList::const_iterator it = m->allDHCPServers.begin();
-         it != m->allDHCPServers.end();
-         ++it)
-    {
-        rc = (*it)->COMGETTER(NetworkName)(bstr.asOutParam());
-        if (FAILED(rc)) return rc;
-
-        if (bstr == aName)
-        {
-            found = *it;
-            break;
-        }
-    }
-
-    if (!found)
-        return E_INVALIDARG;
-
-    return found.queryInterfaceTo(aServer);
-}
-
-STDMETHODIMP VirtualBox::RemoveDHCPServer(IDHCPServer * aServer)
-{
-    CheckComArgNotNull(aServer);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc = unregisterDHCPServer(static_cast<DHCPServer *>(aServer), true);
-
-    return rc;
-}
-
-/**
- * Remembers the given DHCP server in the settings.
- *
- * @param aDHCPServer   DHCP server object to remember.
- * @param aSaveSettings @c true to save settings to disk (default).
- *
- * When @a aSaveSettings is @c true, this operation may fail because of the
- * failed #saveSettings() method it calls. In this case, the dhcp server object
- * will not be remembered. It is therefore the responsibility of the caller to
- * call this method as the last step of some action that requires registration
- * in order to make sure that only fully functional dhcp server objects get
- * registered.
- *
- * @note Locks this object for writing and @a aDHCPServer for reading.
- */
-HRESULT VirtualBox::registerDHCPServer(DHCPServer *aDHCPServer,
-                                       bool aSaveSettings /*= true*/)
-{
-    AssertReturn(aDHCPServer != NULL, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoCaller dhcpServerCaller(aDHCPServer);
-    AssertComRCReturn(dhcpServerCaller.rc(), dhcpServerCaller.rc());
-
-    Bstr name;
-    HRESULT rc;
-    rc = aDHCPServer->COMGETTER(NetworkName)(name.asOutParam());
-    if (FAILED(rc)) return rc;
-
-    ComPtr<IDHCPServer> existing;
-    rc = FindDHCPServerByNetworkName(name.raw(), existing.asOutParam());
-    if (SUCCEEDED(rc))
-        return E_INVALIDARG;
-
-    rc = S_OK;
-
-    m->allDHCPServers.addChild(aDHCPServer);
-
-    if (aSaveSettings)
-    {
-        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
-        rc = saveSettings();
-        vboxLock.release();
-
-        if (FAILED(rc))
-            unregisterDHCPServer(aDHCPServer, false /* aSaveSettings */);
-    }
-
-    return rc;
-}
-
-/**
- * Removes the given DHCP server from the settings.
- *
- * @param aDHCPServer   DHCP server object to remove.
- * @param aSaveSettings @c true to save settings to disk (default).
- *
- * When @a aSaveSettings is @c true, this operation may fail because of the
- * failed #saveSettings() method it calls. In this case, the DHCP server
- * will NOT be removed from the settingsi when this method returns.
- *
- * @note Locks this object for writing.
- */
-HRESULT VirtualBox::unregisterDHCPServer(DHCPServer *aDHCPServer,
-                                         bool aSaveSettings /*= true*/)
-{
-    AssertReturn(aDHCPServer != NULL, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoCaller dhcpServerCaller(aDHCPServer);
-    AssertComRCReturn(dhcpServerCaller.rc(), dhcpServerCaller.rc());
-
-    m->allDHCPServers.removeChild(aDHCPServer);
-
-    HRESULT rc = S_OK;
-
-    if (aSaveSettings)
-    {
-        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
-        rc = saveSettings();
-        vboxLock.release();
-
-        if (FAILED(rc))
-            registerDHCPServer(aDHCPServer, false /* aSaveSettings */);
-    }
-
-    return rc;
-}
-
-
-/**
- * NAT Network
- */
-
-STDMETHODIMP VirtualBox::CreateNATNetwork(IN_BSTR aName, INATNetwork ** aNatNetwork)
-{
-#ifdef VBOX_WITH_NAT_SERVICE
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgNotNull(aNatNetwork);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    ComObjPtr<NATNetwork> natNetwork;
-    natNetwork.createObject();
-    HRESULT rc = natNetwork->init(this, aName);
-    if (FAILED(rc)) return rc;
-
-    rc = registerNATNetwork(natNetwork, true);
-    if (FAILED(rc)) return rc;
-
-    natNetwork.queryInterfaceTo(aNatNetwork);
-
-    fireNATNetworkCreationDeletionEvent(m->pEventSource, aName, TRUE);
-    return rc;
-#else
-    NOREF(aName);
-    NOREF(aNatNetwork);
-    return E_NOTIMPL;
-#endif
-}
-
-STDMETHODIMP VirtualBox::FindNATNetworkByName(IN_BSTR aName, INATNetwork ** aNetwork)
-{
-#ifdef VBOX_WITH_NAT_SERVICE
-    CheckComArgStrNotEmptyOrNull(aName);
-    CheckComArgNotNull(aNetwork);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-
-    HRESULT rc;
-    Bstr bstr;
-    ComPtr<NATNetwork> found;
-
-    AutoReadLock alock(m->allNATNetworks.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-    for (NATNetworksOList::const_iterator it = m->allNATNetworks.begin();
-         it != m->allNATNetworks.end();
-         ++it)
-    {
-        rc = (*it)->COMGETTER(NetworkName)(bstr.asOutParam());
-        if (FAILED(rc)) return rc;
-
-        if (bstr == aName)
-        {
-            found = *it;
-            break;
-        }
-    }
-
-    if (!found)
-        return E_INVALIDARG;
-
-    return found.queryInterfaceTo(aNetwork);
-#else
-    NOREF(aName);
-    NOREF(aNetwork);
-    return E_NOTIMPL;
-#endif
-}
-
-STDMETHODIMP VirtualBox::RemoveNATNetwork(INATNetwork * aNetwork)
-{
-#ifdef VBOX_WITH_NAT_SERVICE
-    CheckComArgNotNull(aNetwork);
-
-    AutoCaller autoCaller(this);
-    if (FAILED(autoCaller.rc())) return autoCaller.rc();
-    Bstr name;
-    HRESULT rc;
-    NATNetwork *network = static_cast<NATNetwork *>(aNetwork);
-    rc = network->COMGETTER(NetworkName)(name.asOutParam());
-    rc = unregisterNATNetwork(network, true);
-    fireNATNetworkCreationDeletionEvent(m->pEventSource, name.raw(), FALSE);
-    return rc;
-#else
-    NOREF(aNetwork);
-    return E_NOTIMPL;
-#endif
-
-}
-/**
- * Remembers the given NAT network in the settings.
- *
- * @param aNATNetwork    NAT Network object to remember.
- * @param aSaveSettings @c true to save settings to disk (default).
- *
- *
- * @note Locks this object for writing and @a aNATNetwork for reading.
- */
-HRESULT VirtualBox::registerNATNetwork(NATNetwork *aNATNetwork,
-                                       bool aSaveSettings /*= true*/)
-{
-#ifdef VBOX_WITH_NAT_SERVICE
-    AssertReturn(aNATNetwork != NULL, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoCaller natNetworkCaller(aNATNetwork);
-    AssertComRCReturn(natNetworkCaller.rc(), natNetworkCaller.rc());
-
-    Bstr name;
-    HRESULT rc;
-    rc = aNATNetwork->COMGETTER(NetworkName)(name.asOutParam());
-    if (FAILED(rc)) return rc;
-
-    ComPtr<INATNetwork> existing;
-    rc = FindNATNetworkByName(name.raw(), existing.asOutParam());
-    if (SUCCEEDED(rc))
-        return E_INVALIDARG;
-
-    rc = S_OK;
-
-    m->allNATNetworks.addChild(aNATNetwork);
-
-    if (aSaveSettings)
-    {
-        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
-        rc = saveSettings();
-        vboxLock.release();
-
-        if (FAILED(rc))
-            unregisterNATNetwork(aNATNetwork, false /* aSaveSettings */);
-    }
-
-    return rc;
-#else
-    NOREF(aNATNetwork);
-    NOREF(aSaveSettings);
-    /* No panic please (silently ignore) */
-    return S_OK;
-#endif
-}
-
-/**
- * Removes the given NAT network from the settings.
- *
- * @param aNATNetwork   NAT network object to remove.
- * @param aSaveSettings @c true to save settings to disk (default).
- *
- * When @a aSaveSettings is @c true, this operation may fail because of the
- * failed #saveSettings() method it calls. In this case, the DHCP server
- * will NOT be removed from the settingsi when this method returns.
- *
- * @note Locks this object for writing.
- */
-HRESULT VirtualBox::unregisterNATNetwork(NATNetwork *aNATNetwork,
-                                         bool aSaveSettings /*= true*/)
-{
-#ifdef VBOX_WITH_NAT_SERVICE
-    AssertReturn(aNATNetwork != NULL, E_INVALIDARG);
-
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoCaller natNetworkCaller(aNATNetwork);
-    AssertComRCReturn(natNetworkCaller.rc(), natNetworkCaller.rc());
-
-    m->allNATNetworks.removeChild(aNATNetwork);
-
-    HRESULT rc = S_OK;
-
-    if (aSaveSettings)
-    {
-        AutoWriteLock vboxLock(this COMMA_LOCKVAL_SRC_POS);
-        rc = saveSettings();
-        vboxLock.release();
-
-        if (FAILED(rc))
-            registerNATNetwork(aNATNetwork, false /* aSaveSettings */);
-    }
-
-    return rc;
-#else
-    NOREF(aNATNetwork);
-    NOREF(aSaveSettings);
-    return E_NOTIMPL;
-#endif
-}
 /* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

@@ -24 +24 @@
 #endif
 
-#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-# include <errno.h>
-# include <sys/types.h>
-# include <sys/stat.h>
-# include <sys/ipc.h>
-# include <sys/sem.h>
-#endif
-
 #include "Logging.h"
 #include "VirtualBoxImpl.h"
 #include "MachineImpl.h"
+#include "ClientToken.h"
 #include "ProgressImpl.h"
 #include "ProgressProxyImpl.h"
@@ -3712 +3705 @@
             mData->mSession.mState = SessionState_Spawning;
 
+            /* Get the client token ID to be passed to the client process */
+            Utf8Str strTokenId;
+            sessionMachine->getTokenId(strTokenId);
+            Assert(!strTokenId.isEmpty());
+
             /*
              *  Release the lock before calling the client process -- it will call
@@ -3725 +3723 @@
 
             LogFlowThisFunc(("Calling AssignMachine()...\n"));
-            rc = pSessionControl->AssignMachine(sessionMachine, lockType);
+            rc = pSessionControl->AssignMachine(sessionMachine, lockType, Bstr(strTokenId).raw());
             LogFlowThisFunc(("AssignMachine() returned %08X\n", rc));
 
@@ -3792 +3790 @@
                 /* Close the remote session, remove the remote control from the list
                  * and reset session state to Closed (@note keep the code in sync
-                 * with the relevant part in openSession()). */
+                 * with the relevant part in checkForSpawnFailure()). */
 
                 Assert(mData->mSession.mRemoteControls.size() == 1);
@@ -8096 +8094 @@
      *  Releasing the lock here is dangerous because we didn't prepare the
      *  launch data yet, but the client we've just started may happen to be
-     *  too fast and call openSession() that will fail (because of PID, etc.),
+     *  too fast and call LockMachine() that will fail (because of PID, etc.),
      *  so that the Machine will never get out of the Spawning session state.
      */
@@ -8102 +8100 @@
     /* inform the session that it will be a remote one */
     LogFlowThisFunc(("Calling AssignMachine (NULL)...\n"));
-    HRESULT rc = aControl->AssignMachine(NULL, LockType_Write);
+    HRESULT rc = aControl->AssignMachine(NULL, LockType_Write, Bstr::Empty.raw());
     LogFlowThisFunc(("AssignMachine (NULL) returned %08X\n", rc));
 
@@ -8127 +8125 @@
 
 /**
- * Returns @c true if the given machine has an open direct session and returns
- * the session machine instance and additional session data (on some platforms)
- * if so.
+ * Returns @c true if the given session machine instance has an open direct
+ * session (and optionally also for direct sessions which are closing) and
+ * returns the session control machine instance if so.
  *
  * Note that when the method returns @c false, the arguments remain unchanged.
  *
- * @param aMachine  Session machine object.
- * @param aControl  Direct session control object (optional).
- * @param aIPCSem   Mutex IPC semaphore handle for this machine (optional).
+ * @param aMachine      Session machine object.
+ * @param aControl      Direct session control object (optional).
+ * @param aAllowClosing If true then additionally a session which is currently
+ *                      being closed will also be allowed.
  *
  * @note locks this object for reading.
  */
-#if defined(RT_OS_WINDOWS)
-bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                            ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
-                            HANDLE *aIPCSem /*= NULL*/,
-                            bool aAllowClosing /*= false*/)
-#elif defined(RT_OS_OS2)
-bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
-                            ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
-                            HMTX *aIPCSem /*= NULL*/,
-                            bool aAllowClosing /*= false*/)
-#else
 bool Machine::isSessionOpen(ComObjPtr<SessionMachine> &aMachine,
                             ComPtr<IInternalSessionControl> *aControl /*= NULL*/,
                             bool aAllowClosing /*= false*/)
-#endif
 {
     AutoLimitedCaller autoCaller(this);
@@ -8175 +8162 @@
             *aControl = mData->mSession.mDirectControl;
 
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-        /* Additional session data */
-        if (aIPCSem != NULL)
-            *aIPCSem = aMachine->mIPCSem;
-#endif
         return true;
     }
@@ -8187 +8169 @@
 
 /**
- * Returns @c true if the given machine has an spawning direct session and
- * returns and additional session data (on some platforms) if so.
- *
- * Note that when the method returns @c false, the arguments remain unchanged.
- *
- * @param aPID  PID of the spawned direct session process.
+ * Returns @c true if the given machine has an spawning direct session.
  *
  * @note locks this object for reading.
  */
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-bool Machine::isSessionSpawning(RTPROCESS *aPID /*= NULL*/)
-#else
 bool Machine::isSessionSpawning()
-#endif
 {
     AutoLimitedCaller autoCaller(this);
@@ -8212 +8185 @@
 
     if (mData->mSession.mState == SessionState_Spawning)
-    {
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-        /* Additional session data */
-        if (aPID != NULL)
-        {
-            AssertReturn(mData->mSession.mPID != NIL_RTPROCESS, false);
-            *aPID = mData->mSession.mPID;
-        }
-#endif
         return true;
-    }
 
     return false;
@@ -8251 +8214 @@
     }
 
-    /* VirtualBox::addProcessToReap() needs a write lock */
-    AutoMultiWriteLock2 alock(mParent, this COMMA_LOCKVAL_SRC_POS);
+    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
 
     if (mData->mSession.mState != SessionState_Spawning)
@@ -8263 +8225 @@
     HRESULT rc = S_OK;
 
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-
-    /* the process was already unexpectedly terminated, we just need to set an
-     * error and finalize session spawning */
-    rc = setError(E_FAIL,
-                  tr("The virtual machine '%s' has terminated unexpectedly during startup"),
-                  getName().c_str());
-#else
-
     /* PID not yet initialized, skip check. */
     if (mData->mSession.mPID == NIL_RTPROCESS)
@@ -8277 +8230 @@
 
     RTPROCSTATUS status;
-    int vrc = ::RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK,
-                           &status);
+    int vrc = RTProcWait(mData->mSession.mPID, RTPROCWAIT_FLAGS_NOBLOCK, &status);
 
     if (vrc != VERR_PROCESS_RUNNING)
@@ -8300 +8252 @@
     }
 
-#endif
-
     if (FAILED(rc))
     {
         /* Close the remote session, remove the remote control from the list
          * and reset session state to Closed (@note keep the code in sync with
-         * the relevant part in checkForSpawnFailure()). */
+         * the relevant part in LockMachine()). */
 
         Assert(mData->mSession.mRemoteControls.size() == 1);
@@ -8325 +8275 @@
         }
 
-        mParent->addProcessToReap(mData->mSession.mPID);
         mData->mSession.mPID = NIL_RTPROCESS;
 
@@ -12680 +12629 @@
     LogFlowThisFunc(("\n"));
 
-#if defined(RT_OS_WINDOWS)
-    mIPCSem = NULL;
-#elif defined(RT_OS_OS2)
-    mIPCSem = NULLHANDLE;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    mIPCSem = -1;
-#else
-# error "Port me!"
-#endif
+    mClientToken = NULL;
 
     return BaseFinalConstruct();
@@ -12697 +12638 @@
     LogFlowThisFunc(("\n"));
 
+    Assert(!mClientToken);
+    /* paranoia, should not hang around any more */
+    if (mClientToken)
+    {
+        delete mClientToken;
+        mClientToken = NULL;
+    }
+
     uninit(Uninit::Unexpected);
 
@@ -12703 +12652 @@
 
 /**
- *  @note Must be called only by Machine::openSession() from its own write lock.
+ *  @note Must be called only by Machine::LockMachine() from its own write lock.
  */
 HRESULT SessionMachine::init(Machine *aMachine)
@@ -12718 +12667 @@
     AssertReturn(autoInitSpan.isOk(), E_FAIL);
 
-    /* create the interprocess semaphore */
-#if defined(RT_OS_WINDOWS)
-    mIPCSemName = aMachine->mData->m_strConfigFileFull;
-    for (size_t i = 0; i < mIPCSemName.length(); i++)
-        if (mIPCSemName.raw()[i] == '\\')
-            mIPCSemName.raw()[i] = '/';
-    mIPCSem = ::CreateMutex(NULL, FALSE, mIPCSemName.raw());
-    ComAssertMsgRet(mIPCSem,
-                    ("Cannot create IPC mutex '%ls', err=%d",
-                     mIPCSemName.raw(), ::GetLastError()),
-                    E_FAIL);
-#elif defined(RT_OS_OS2)
-    Utf8Str ipcSem = Utf8StrFmt("\\SEM32\\VBOX\\VM\\{%RTuuid}",
-                                aMachine->mData->mUuid.raw());
-    mIPCSemName = ipcSem;
-    APIRET arc = ::DosCreateMutexSem((PSZ)ipcSem.c_str(), &mIPCSem, 0, FALSE);
-    ComAssertMsgRet(arc == NO_ERROR,
-                    ("Cannot create IPC mutex '%s', arc=%ld",
-                     ipcSem.c_str(), arc),
-                    E_FAIL);
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-#  if defined(RT_OS_FREEBSD) && (HC_ARCH_BITS == 64)
-    /** @todo Check that this still works correctly. */
-    AssertCompileSize(key_t, 8);
-#  else
-    AssertCompileSize(key_t, 4);
-#  endif
-    key_t key;
-    mIPCSem = -1;
-    mIPCKey = "0";
-    for (uint32_t i = 0; i < 1 << 24; i++)
-    {
-        key = ((uint32_t)'V' << 24) | i;
-        int sem = ::semget(key, 1, S_IRUSR | S_IWUSR | IPC_CREAT | IPC_EXCL);
-        if (sem >= 0 || (errno != EEXIST && errno != EACCES))
-        {
-            mIPCSem = sem;
-            if (sem >= 0)
-                mIPCKey = BstrFmt("%u", key);
-            break;
-        }
-    }
-# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    Utf8Str semName = aMachine->mData->m_strConfigFileFull;
-    char *pszSemName = NULL;
-    RTStrUtf8ToCurrentCP(&pszSemName, semName);
-    key_t key = ::ftok(pszSemName, 'V');
-    RTStrFree(pszSemName);
-
-    mIPCSem = ::semget(key, 1, S_IRWXU | S_IRWXG | S_IRWXO | IPC_CREAT);
-# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-
-    int errnoSave = errno;
-    if (mIPCSem < 0 && errnoSave == ENOSYS)
-    {
-        setError(E_FAIL,
-                 tr("Cannot create IPC semaphore. Most likely your host kernel lacks "
-                    "support for SysV IPC. Check the host kernel configuration for "
-                    "CONFIG_SYSVIPC=y"));
-        return E_FAIL;
-    }
-    /* ENOSPC can also be the result of VBoxSVC crashes without properly freeing
-     * the IPC semaphores */
-    if (mIPCSem < 0 && errnoSave == ENOSPC)
-    {
-#ifdef RT_OS_LINUX
-        setError(E_FAIL,
-                 tr("Cannot create IPC semaphore because the system limit for the "
-                    "maximum number of semaphore sets (SEMMNI), or the system wide "
-                    "maximum number of semaphores (SEMMNS) would be exceeded. The "
-                    "current set of SysV IPC semaphores can be determined from "
-                    "the file /proc/sysvipc/sem"));
-#else
-        setError(E_FAIL,
-                 tr("Cannot create IPC semaphore because the system-imposed limit "
-                    "on the maximum number of allowed  semaphores or semaphore "
-                    "identifiers system-wide would be exceeded"));
-#endif
-        return E_FAIL;
-    }
-    ComAssertMsgRet(mIPCSem >= 0, ("Cannot create IPC semaphore, errno=%d", errnoSave),
-                    E_FAIL);
-    /* set the initial value to 1 */
-    int rv = ::semctl(mIPCSem, 0, SETVAL, 1);
-    ComAssertMsgRet(rv == 0, ("Cannot init IPC semaphore, errno=%d", errno),
-                    E_FAIL);
-#else
-# error "Port me!"
-#endif
+    HRESULT rc = S_OK;
+
+    /* create the machine client token */
+    try
+    {
+        mClientToken = new ClientToken(aMachine);
+        if (!mClientToken->isReady())
+        {
+            delete mClientToken;
+            mClientToken = NULL;
+            rc = E_FAIL;
+        }
+    }
+    catch (std::bad_alloc &)
+    {
+        rc = E_OUTOFMEMORY;
+    }
+    if (FAILED(rc))
+        return rc;
 
     /* memorize the peer Machine */
@@ -12888 +12766 @@
 
     LogFlowThisFuncLeave();
-    return S_OK;
+    return rc;
 }
 
@@ -12929 +12807 @@
          */
         LogFlowThisFunc(("Initialization failed.\n"));
-#if defined(RT_OS_WINDOWS)
-        if (mIPCSem)
-            ::CloseHandle(mIPCSem);
-        mIPCSem = NULL;
-#elif defined(RT_OS_OS2)
-        if (mIPCSem != NULLHANDLE)
-            ::DosCloseMutexSem(mIPCSem);
-        mIPCSem = NULLHANDLE;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-        if (mIPCSem >= 0)
-            ::semctl(mIPCSem, 0, IPC_RMID);
-        mIPCSem = -1;
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-        mIPCKey = "0";
-# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
-#else
-# error "Port me!"
-#endif
+        /* destroy the machine client token */
+        if (mClientToken)
+        {
+            delete mClientToken;
+            mClientToken = NULL;
+        }
         uninitDataAndChildObjects();
         mData.free();
@@ -13134 +13000 @@
     mData->mSession.mType.setNull();
 
-    /* close the interprocess semaphore before leaving the exclusive lock */
-#if defined(RT_OS_WINDOWS)
-    if (mIPCSem)
-        ::CloseHandle(mIPCSem);
-    mIPCSem = NULL;
-#elif defined(RT_OS_OS2)
-    if (mIPCSem != NULLHANDLE)
-        ::DosCloseMutexSem(mIPCSem);
-    mIPCSem = NULLHANDLE;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    if (mIPCSem >= 0)
-        ::semctl(mIPCSem, 0, IPC_RMID);
-    mIPCSem = -1;
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    mIPCKey = "0";
-# endif /* VBOX_WITH_NEW_SYS_V_KEYGEN */
-#else
-# error "Port me!"
-#endif
+    /* destroy the machine client token before leaving the exclusive lock */
+    if (mClientToken)
+    {
+        delete mClientToken;
+        mClientToken = NULL;
+    }
 
     /* fire an event */
@@ -13165 +13018 @@
     multilock.release();
 
+    RTThreadSleep(500);
+    mParent->AddRef();
+    LONG c = mParent->Release();
+    LogFlowThisFunc(("vbox ref=%d\n", c));
     unconst(mParent) = NULL;
     unconst(mPeer) = NULL;
@@ -13252 +13109 @@
 
 /**
- *  @note Locks this object for reading.
- */
-STDMETHODIMP SessionMachine::GetIPCId(BSTR *aId)
-{
-    AutoCaller autoCaller(this);
-    AssertComRCReturn(autoCaller.rc(), autoCaller.rc());
-
-    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
-
-#if defined(RT_OS_WINDOWS) || defined(RT_OS_OS2)
-    mIPCSemName.cloneTo(aId);
-    return S_OK;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-# ifdef VBOX_WITH_NEW_SYS_V_KEYGEN
-    mIPCKey.cloneTo(aId);
-# else /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    mData->m_strConfigFileFull.cloneTo(aId);
-# endif /* !VBOX_WITH_NEW_SYS_V_KEYGEN */
-    return S_OK;
-#else
-# error "Port me!"
-#endif
-}
-
-/**
  *  @note Locks this object for writing.
  */
@@ -14078 +13910 @@
                  Uninit::Abnormal;
 
-#if defined(RT_OS_WINDOWS)
-
-        AssertMsg(mIPCSem, ("semaphore must be created"));
-
-        /* release the IPC mutex */
-        ::ReleaseMutex(mIPCSem);
-
-        terminated = true;
-
-#elif defined(RT_OS_OS2)
-
-        AssertMsg(mIPCSem, ("semaphore must be created"));
-
-        /* release the IPC mutex */
-        ::DosReleaseMutexSem(mIPCSem);
-
-        terminated = true;
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-        AssertMsg(mIPCSem >= 0, ("semaphore must be created"));
-
-        int val = ::semctl(mIPCSem, 0, GETVAL);
-        if (val > 0)
-        {
-            /* the semaphore is signaled, meaning the session is terminated */
-            terminated = true;
-        }
-
-#else
-# error "Port me!"
-#endif
-
+        if (mClientToken)
+            terminated = mClientToken->release();
     } /* AutoCaller block */
 
@@ -14118 +13919 @@
     return terminated;
 }
+
+void SessionMachine::getTokenId(Utf8Str &strTokenId)
+{
+    LogFlowThisFunc(("\n"));
+
+    strTokenId.setNull();
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturnVoid(autoCaller.rc());
+
+    Assert(mClientToken);
+    if (mClientToken)
+        mClientToken->getId(strTokenId);
+}
+
+Machine::ClientToken *SessionMachine::getClientToken()
+{
+    LogFlowThisFunc(("\n"));
+
+    AutoCaller autoCaller(this);
+    AssertComRCReturn(autoCaller.rc(), NULL);
+
+    return mClientToken;
+}
+
 
 /**

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

@@ -36 +36 @@
 #include <VBox/com/array.h>
 #include "VBox/com/EventQueue.h"
+#include "VBox/com/MultiResult.h"
 
 #include <VBox/err.h>
@@ -73 +74 @@
 #endif
 #include "AutostartDb.h"
+#include "ClientWatcher.h"
 
 #include "AutoCaller.h"
 #include "Logging.h"
-#include "objectslist.h"
 
 #ifdef RT_OS_WINDOWS
@@ -111 +112 @@
 // static
 Bstr VirtualBox::sAPIVersion;
-
-#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-/** Table for adaptive timeouts in the client watcher. The counter starts at
- * the maximum value and decreases to 0. */
-static const RTMSINTERVAL s_updateAdaptTimeouts[] = { 500, 200, 100, 50, 20, 10, 5 };
-#endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -165 +160 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-#if defined(RT_OS_WINDOWS)
-    #define UPDATEREQARG NULL
-    #define UPDATEREQTYPE HANDLE
-#elif defined(RT_OS_OS2)
-    #define UPDATEREQARG NIL_RTSEMEVENT
-    #define UPDATEREQTYPE RTSEMEVENT
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    #define UPDATEREQARG
-    #define UPDATEREQTYPE RTSEMEVENT
-#else
-# error "Port me!"
-#endif
-
-typedef ObjectsList<Machine> MachinesOList;
 typedef ObjectsList<Medium> MediaOList;
 typedef ObjectsList<GuestOSType> GuestOSTypesOList;
@@ -214 +195 @@
           allNATNetworks(lockNATNetworks),
           mtxProgressOperations(LOCKCLASS_PROGRESSLIST),
-          updateReq(UPDATEREQARG),
-          threadClientWatcher(NIL_RTTHREAD),
+          pClientWatcher(NULL),
           threadAsyncEvent(NIL_RTTHREAD),
           pAsyncEventQ(NULL),
@@ -290 +270 @@
     RWLockHandle                        lockDHCPServers;
     DHCPServersOList                    allDHCPServers;
-    
-    RWLockHandle                         lockNATNetworks;
-    NATNetworksOList                     allNATNetworks;
+
+    RWLockHandle                        lockNATNetworks;
+    NATNetworksOList                    allNATNetworks;
 
     RWLockHandle                        mtxProgressOperations;
     ProgressMap                         mapProgressOperations;
 
-    // the following are data for the client watcher thread
-    const UPDATEREQTYPE                 updateReq;
-#ifdef VBOX_WITH_SYS_V_IPC_SESSION_WATCHER
-    uint8_t                             updateAdaptCtr;
-#endif
-    const RTTHREAD                      threadClientWatcher;
-    typedef std::list<RTPROCESS> ProcessList;
-    ProcessList                         llProcesses;
+    ClientWatcher * const               pClientWatcher;
 
     // the following are data for the async event thread
@@ -551 +524 @@
     if (SUCCEEDED(rc))
     {
-        /* start the client watcher thread */
-#if defined(RT_OS_WINDOWS)
-        unconst(m->updateReq) = ::CreateEvent(NULL, FALSE, FALSE, NULL);
-#elif defined(RT_OS_OS2)
-        RTSemEventCreate(&unconst(m->updateReq));
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-        RTSemEventCreate(&unconst(m->updateReq));
-        ASMAtomicUoWriteU8(&m->updateAdaptCtr, 0);
-#else
-# error "Port me!"
-#endif
-        int vrc = RTThreadCreate(&unconst(m->threadClientWatcher),
-                                 ClientWatcher,
-                                 (void *)this,
-                                 0,
-                                 RTTHREADTYPE_MAIN_WORKER,
-                                 RTTHREADFLAGS_WAITABLE,
-                                 "Watcher");
-        ComAssertRC(vrc);
-        if (RT_FAILURE(vrc))
-            rc = E_FAIL;
+        /* set up client monitoring */
+        try
+        {
+            unconst(m->pClientWatcher) = new ClientWatcher(this);
+            if (!m->pClientWatcher->isReady())
+            {
+                delete m->pClientWatcher;
+                unconst(m->pClientWatcher) = NULL;
+                rc = E_FAIL;
+            }
+        }
+        catch (std::bad_alloc &)
+        {
+            rc = E_OUTOFMEMORY;
+        }
     }
 
@@ -836 +803 @@
 
     LogFlowThisFunc(("Terminating the client watcher...\n"));
-    if (m->threadClientWatcher != NIL_RTTHREAD)
-    {
-        /* signal the client watcher thread */
-        updateClientWatcher();
-        /* wait for the termination */
-        RTThreadWait(m->threadClientWatcher, RT_INDEFINITE_WAIT, NULL);
-        unconst(m->threadClientWatcher) = NIL_RTTHREAD;
-    }
-    m->llProcesses.clear();
-#if defined(RT_OS_WINDOWS)
-    if (m->updateReq != NULL)
-    {
-        ::CloseHandle(m->updateReq);
-        unconst(m->updateReq) = NULL;
-    }
-#elif defined(RT_OS_OS2)
-    if (m->updateReq != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy(m->updateReq);
-        unconst(m->updateReq) = NIL_RTSEMEVENT;
-    }
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    if (m->updateReq != NIL_RTSEMEVENT)
-    {
-        RTSemEventDestroy(m->updateReq);
-        unconst(m->updateReq) = NIL_RTSEMEVENT;
-    }
-#else
-# error "Port me!"
-#endif
+    if (m->pClientWatcher)
+    {
+        delete m->pClientWatcher;
+        unconst(m->pClientWatcher) = NULL;
+    }
 
     delete m->pAutostartDb;
@@ -888 +830 @@
     AutoCaller autoCaller(this);
     if (FAILED(autoCaller.rc())) return autoCaller.rc();
+
+    MultiResult mrc;
+    setError(E_INVALIDARG, "test error first");
+    setError(E_FAIL, "test error");
+    return 0x8000ffff;
 
     sVersion.cloneTo(aVersion);
@@ -1153 +1100 @@
     return S_OK;
 #else /* !VBOX_WITH_RESOURCE_USAGE_API */
+    NOREF(aPerformanceCollector);
     ReturnComNotImplemented();
 #endif /* !VBOX_WITH_RESOURCE_USAGE_API */
@@ -2837 +2785 @@
 
 /**
- *  Sends a signal to the client watcher thread to rescan the set of machines
+ *  Sends a signal to the client watcher to rescan the set of machines
  *  that have open sessions.
  *
@@ -2847 +2795 @@
     AssertComRCReturnVoid(autoCaller.rc());
 
-    AssertReturnVoid(m->threadClientWatcher != NIL_RTTHREAD);
-
-    /* sent an update request */
-#if defined(RT_OS_WINDOWS)
-    ::SetEvent(m->updateReq);
-#elif defined(RT_OS_OS2)
-    RTSemEventSignal(m->updateReq);
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-    ASMAtomicUoWriteU8(&m->updateAdaptCtr, RT_ELEMENTS(s_updateAdaptTimeouts) - 1);
-    RTSemEventSignal(m->updateReq);
-#else
-# error "Port me!"
-#endif
+    AssertPtrReturnVoid(m->pClientWatcher);
+    m->pClientWatcher->update();
 }
 
@@ -2865 +2802 @@
  *  Adds the given child process ID to the list of processes to be reaped.
  *  This call should be followed by #updateClientWatcher() to take the effect.
+ *
+ *  @note Doesn't lock anything.
  */
 void VirtualBox::addProcessToReap(RTPROCESS pid)
@@ -2871 +2810 @@
     AssertComRCReturnVoid(autoCaller.rc());
 
-    /// @todo (dmik) Win32?
-#ifndef RT_OS_WINDOWS
-    AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
-    m->llProcesses.push_back(pid);
-#endif
+    AssertPtrReturnVoid(m->pClientWatcher);
+    m->pClientWatcher->addProcess(pid);
 }
 
@@ -3112 +3048 @@
 }
 
-/** Event for onMachineUninit(), this is not a CallbackEvent */
-class MachineUninitEvent : public Event
-{
-public:
-
-    MachineUninitEvent(VirtualBox *aVirtualBox, Machine *aMachine)
-        : mVirtualBox(aVirtualBox), mMachine(aMachine)
-    {
-        Assert(aVirtualBox);
-        Assert(aMachine);
-    }
-
-    void *handler()
-    {
-#ifdef VBOX_WITH_RESOURCE_USAGE_API
-        /* Handle unregistering metrics here, as it is not vital to get
-         * it done immediately. It reduces the number of locks needed and
-         * the lock contention in SessionMachine::uninit. */
-        {
-            AutoWriteLock mLock(mMachine COMMA_LOCKVAL_SRC_POS);
-            mMachine->unregisterMetrics(mVirtualBox->performanceCollector(), mMachine);
-        }
-#endif /* VBOX_WITH_RESOURCE_USAGE_API */
-
-        return NULL;
-    }
-
-private:
-
-    /**
-     *  Note that this is a weak ref -- the CallbackEvent handler thread
-     *  is bound to the lifetime of the VirtualBox instance, so it's safe.
-     */
-    VirtualBox        *mVirtualBox;
-
-    /** Reference to the machine object. */
-    ComObjPtr<Machine> mMachine;
-};
-
-/**
- *  Trigger internal event. This isn't meant to be signalled to clients.
- *  @note Doesn't lock any object.
- */
-void VirtualBox::onMachineUninit(Machine *aMachine)
-{
-    postEvent(new MachineUninitEvent(this, aMachine));
-}
-
 /**
  *  @note Doesn't lock any object.
@@ -3180 +3068 @@
     fireNATNetworkStartStopEvent(m->pEventSource, aName, fStart);
 }
-void VirtualBox::onNATNetworkSetting(IN_BSTR aNetworkName, BOOL aEnabled, 
-                                     IN_BSTR aNetwork, IN_BSTR aGateway, 
-                                     BOOL aAdvertiseDefaultIpv6RouteEnabled, 
+void VirtualBox::onNATNetworkSetting(IN_BSTR aNetworkName, BOOL aEnabled,
+                                     IN_BSTR aNetwork, IN_BSTR aGateway,
+                                     BOOL aAdvertiseDefaultIpv6RouteEnabled,
                                      BOOL fNeedDhcpServer)
 {
-    fireNATNetworkSettingEvent(m->pEventSource, aNetworkName, aEnabled, 
+    fireNATNetworkSettingEvent(m->pEventSource, aNetworkName, aEnabled,
                                aNetwork, aGateway,
                                aAdvertiseDefaultIpv6RouteEnabled, fNeedDhcpServer);
 }
 
-void VirtualBox::onNATNetworkPortForward(IN_BSTR aNetworkName, BOOL create, BOOL fIpv6, 
-                                         IN_BSTR aRuleName, NATProtocol_T proto, 
-                                         IN_BSTR aHostIp, LONG aHostPort, 
+void VirtualBox::onNATNetworkPortForward(IN_BSTR aNetworkName, BOOL create, BOOL fIpv6,
+                                         IN_BSTR aRuleName, NATProtocol_T proto,
+                                         IN_BSTR aHostIp, LONG aHostPort,
                                          IN_BSTR aGuestIp, LONG aGuestPort)
 {
-    fireNATNetworkPortForwardEvent(m->pEventSource, aNetworkName, create, 
+    fireNATNetworkPortForwardEvent(m->pEventSource, aNetworkName, create,
                                    fIpv6, aRuleName, proto,
                                    aHostIp, aHostPort,
@@ -3257 +3145 @@
         }
     }
+}
+
+/**
+ * Gets a reference to the machine list. This is the real thing, not a copy,
+ * so bad things will happen if the caller doesn't hold the necessary lock.
+ *
+ * @returns reference to machine list
+ *
+ * @note Caller must hold the VirtualBox object lock at least for reading.
+ */
+VirtualBox::MachinesOList &VirtualBox::getMachinesList(void)
+{
+    return m->allMachines;
 }
 
@@ -4849 +4750 @@
 
 /**
- *  Thread function that watches the termination of all client processes
- *  that have opened sessions using IMachine::LockMachine()
- */
-// static
-DECLCALLBACK(int) VirtualBox::ClientWatcher(RTTHREAD /* thread */, void *pvUser)
-{
-    LogFlowFuncEnter();
-
-    VirtualBox *that = (VirtualBox*)pvUser;
-    Assert(that);
-
-    typedef std::vector< ComObjPtr<Machine> > MachineVector;
-    typedef std::vector< ComObjPtr<SessionMachine> > SessionMachineVector;
-
-    SessionMachineVector machines;
-    MachineVector spawnedMachines;
-
-    size_t cnt = 0;
-    size_t cntSpawned = 0;
-
-    VirtualBoxBase::initializeComForThread();
-
-#if defined(RT_OS_WINDOWS)
-
-    /// @todo (dmik) processes reaping!
-
-    HANDLE handles[MAXIMUM_WAIT_OBJECTS];
-    handles[0] = that->m->updateReq;
-
-    do
-    {
-        AutoCaller autoCaller(that);
-        /* VirtualBox has been early uninitialized, terminate */
-        if (!autoCaller.isOk())
-            break;
-
-        do
-        {
-            /* release the caller to let uninit() ever proceed */
-            autoCaller.release();
-
-            DWORD rc = ::WaitForMultipleObjects((DWORD)(1 + cnt + cntSpawned),
-                                                handles,
-                                                FALSE,
-                                                INFINITE);
-
-            /* Restore the caller before using VirtualBox. If it fails, this
-             * means VirtualBox is being uninitialized and we must terminate. */
-            autoCaller.add();
-            if (!autoCaller.isOk())
-                break;
-
-            bool update = false;
-
-            if (rc == WAIT_OBJECT_0)
-            {
-                /* update event is signaled */
-                update = true;
-            }
-            else if (rc > WAIT_OBJECT_0 && rc <= (WAIT_OBJECT_0 + cnt))
-            {
-                /* machine mutex is released */
-                (machines[rc - WAIT_OBJECT_0 - 1])->checkForDeath();
-                update = true;
-            }
-            else if (rc > WAIT_ABANDONED_0 && rc <= (WAIT_ABANDONED_0 + cnt))
-            {
-                /* machine mutex is abandoned due to client process termination */
-                (machines[rc - WAIT_ABANDONED_0 - 1])->checkForDeath();
-                update = true;
-            }
-            else if (rc > WAIT_OBJECT_0 + cnt && rc <= (WAIT_OBJECT_0 + cntSpawned))
-            {
-                /* spawned VM process has terminated (normally or abnormally) */
-                (spawnedMachines[rc - WAIT_OBJECT_0 - cnt - 1])->
-                    checkForSpawnFailure();
-                update = true;
-            }
-
-            if (update)
-            {
-                /* close old process handles */
-                for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++i)
-                    CloseHandle(handles[i]);
-
-                // lock the machines list for reading
-                AutoReadLock thatLock(that->m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-                /* obtain a new set of opened machines */
-                cnt = 0;
-                machines.clear();
-
-                for (MachinesOList::iterator it = that->m->allMachines.begin();
-                     it != that->m->allMachines.end();
-                     ++it)
-                {
-                    /// @todo handle situations with more than 64 objects
-                    AssertMsgBreak((1 + cnt) <= MAXIMUM_WAIT_OBJECTS,
-                                   ("MAXIMUM_WAIT_OBJECTS reached"));
-
-                    ComObjPtr<SessionMachine> sm;
-                    HANDLE ipcSem;
-                    if ((*it)->isSessionOpenOrClosing(sm, NULL, &ipcSem))
-                    {
-                        machines.push_back(sm);
-                        handles[1 + cnt] = ipcSem;
-                        ++cnt;
-                    }
-                }
-
-                LogFlowFunc(("UPDATE: direct session count = %d\n", cnt));
-
-                /* obtain a new set of spawned machines */
-                cntSpawned = 0;
-                spawnedMachines.clear();
-
-                for (MachinesOList::iterator it = that->m->allMachines.begin();
-                     it != that->m->allMachines.end();
-                     ++it)
-                {
-                    /// @todo handle situations with more than 64 objects
-                    AssertMsgBreak((1 + cnt + cntSpawned) <= MAXIMUM_WAIT_OBJECTS,
-                                   ("MAXIMUM_WAIT_OBJECTS reached"));
-
-                    RTPROCESS pid;
-                    if ((*it)->isSessionSpawning(&pid))
-                    {
-                        HANDLE ph = OpenProcess(SYNCHRONIZE, FALSE, pid);
-                        AssertMsg(ph != NULL, ("OpenProcess (pid=%d) failed with %d\n",
-                                               pid, GetLastError()));
-                        if (rc == 0)
-                        {
-                            spawnedMachines.push_back(*it);
-                            handles[1 + cnt + cntSpawned] = ph;
-                            ++cntSpawned;
-                        }
-                    }
-                }
-
-                LogFlowFunc(("UPDATE: spawned session count = %d\n", cntSpawned));
-
-                // machines lock unwinds here
-            }
-        }
-        while (true);
-    }
-    while (0);
-
-    /* close old process handles */
-    for (size_t i = 1 + cnt; i < 1 + cnt + cntSpawned; ++ i)
-        CloseHandle(handles[i]);
-
-    /* release sets of machines if any */
-    machines.clear();
-    spawnedMachines.clear();
-
-    ::CoUninitialize();
-
-#elif defined(RT_OS_OS2)
-
-    /// @todo (dmik) processes reaping!
-
-    /* according to PMREF, 64 is the maximum for the muxwait list */
-    SEMRECORD handles[64];
-
-    HMUX muxSem = NULLHANDLE;
-
-    do
-    {
-        AutoCaller autoCaller(that);
-        /* VirtualBox has been early uninitialized, terminate */
-        if (!autoCaller.isOk())
-            break;
-
-        do
-        {
-            /* release the caller to let uninit() ever proceed */
-            autoCaller.release();
-
-            int vrc = RTSemEventWait(that->m->updateReq, 500);
-
-            /* Restore the caller before using VirtualBox. If it fails, this
-             * means VirtualBox is being uninitialized and we must terminate. */
-            autoCaller.add();
-            if (!autoCaller.isOk())
-                break;
-
-            bool update = false;
-            bool updateSpawned = false;
-
-            if (RT_SUCCESS(vrc))
-            {
-                /* update event is signaled */
-                update = true;
-                updateSpawned = true;
-            }
-            else
-            {
-                AssertMsg(vrc == VERR_TIMEOUT || vrc == VERR_INTERRUPTED,
-                          ("RTSemEventWait returned %Rrc\n", vrc));
-
-                /* are there any mutexes? */
-                if (cnt > 0)
-                {
-                    /* figure out what's going on with machines */
-
-                    unsigned long semId = 0;
-                    APIRET arc = ::DosWaitMuxWaitSem(muxSem,
-                                                     SEM_IMMEDIATE_RETURN, &semId);
-
-                    if (arc == NO_ERROR)
-                    {
-                        /* machine mutex is normally released */
-                        Assert(semId >= 0 && semId < cnt);
-                        if (semId >= 0 && semId < cnt)
-                        {
-#if 0//def DEBUG
-                            {
-                                AutoReadLock machineLock(machines[semId] COMMA_LOCKVAL_SRC_POS);
-                                LogFlowFunc(("released mutex: machine='%ls'\n",
-                                             machines[semId]->name().raw()));
-                            }
-#endif
-                            machines[semId]->checkForDeath();
-                        }
-                        update = true;
-                    }
-                    else if (arc == ERROR_SEM_OWNER_DIED)
-                    {
-                        /* machine mutex is abandoned due to client process
-                         * termination; find which mutex is in the Owner Died
-                         * state */
-                        for (size_t i = 0; i < cnt; ++ i)
-                        {
-                            PID pid; TID tid;
-                            unsigned long reqCnt;
-                            arc = DosQueryMutexSem((HMTX)handles[i].hsemCur, &pid, &tid, &reqCnt);
-                            if (arc == ERROR_SEM_OWNER_DIED)
-                            {
-                                /* close the dead mutex as asked by PMREF */
-                                ::DosCloseMutexSem((HMTX)handles[i].hsemCur);
-
-                                Assert(i >= 0 && i < cnt);
-                                if (i >= 0 && i < cnt)
-                                {
-#if 0//def DEBUG
-                                    {
-                                        AutoReadLock machineLock(machines[semId] COMMA_LOCKVAL_SRC_POS);
-                                        LogFlowFunc(("mutex owner dead: machine='%ls'\n",
-                                                     machines[i]->name().raw()));
-                                    }
-#endif
-                                    machines[i]->checkForDeath();
-                                }
-                            }
-                        }
-                        update = true;
-                    }
-                    else
-                        AssertMsg(arc == ERROR_INTERRUPT || arc == ERROR_TIMEOUT,
-                                  ("DosWaitMuxWaitSem returned %d\n", arc));
-                }
-
-                /* are there any spawning sessions? */
-                if (cntSpawned > 0)
-                {
-                    for (size_t i = 0; i < cntSpawned; ++ i)
-                        updateSpawned |= (spawnedMachines[i])->
-                            checkForSpawnFailure();
-                }
-            }
-
-            if (update || updateSpawned)
-            {
-                AutoReadLock thatLock(that COMMA_LOCKVAL_SRC_POS);
-
-                if (update)
-                {
-                    /* close the old muxsem */
-                    if (muxSem != NULLHANDLE)
-                        ::DosCloseMuxWaitSem(muxSem);
-
-                    /* obtain a new set of opened machines */
-                    cnt = 0;
-                    machines.clear();
-
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end(); ++ it)
-                    {
-                        /// @todo handle situations with more than 64 objects
-                        AssertMsg(cnt <= 64 /* according to PMREF */,
-                                  ("maximum of 64 mutex semaphores reached (%d)",
-                                   cnt));
-
-                        ComObjPtr<SessionMachine> sm;
-                        HMTX ipcSem;
-                        if ((*it)->isSessionOpenOrClosing(sm, NULL, &ipcSem))
-                        {
-                            machines.push_back(sm);
-                            handles[cnt].hsemCur = (HSEM)ipcSem;
-                            handles[cnt].ulUser = cnt;
-                            ++ cnt;
-                        }
-                    }
-
-                    LogFlowFunc(("UPDATE: direct session count = %d\n", cnt));
-
-                    if (cnt > 0)
-                    {
-                        /* create a new muxsem */
-                        APIRET arc = ::DosCreateMuxWaitSem(NULL, &muxSem, cnt,
-                                                           handles,
-                                                           DCMW_WAIT_ANY);
-                        AssertMsg(arc == NO_ERROR,
-                                  ("DosCreateMuxWaitSem returned %d\n", arc));
-                        NOREF(arc);
-                    }
-                }
-
-                if (updateSpawned)
-                {
-                    /* obtain a new set of spawned machines */
-                    spawnedMachines.clear();
-
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end(); ++ it)
-                    {
-                        if ((*it)->isSessionSpawning())
-                            spawnedMachines.push_back(*it);
-                    }
-
-                    cntSpawned = spawnedMachines.size();
-                    LogFlowFunc(("UPDATE: spawned session count = %d\n", cntSpawned));
-                }
-            }
-        }
-        while (true);
-    }
-    while (0);
-
-    /* close the muxsem */
-    if (muxSem != NULLHANDLE)
-        ::DosCloseMuxWaitSem(muxSem);
-
-    /* release sets of machines if any */
-    machines.clear();
-    spawnedMachines.clear();
-
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
-
-    bool update = false;
-    bool updateSpawned = false;
-
-    do
-    {
-        AutoCaller autoCaller(that);
-        if (!autoCaller.isOk())
-            break;
-
-        do
-        {
-            /* release the caller to let uninit() ever proceed */
-            autoCaller.release();
-
-            /* determine wait timeout adaptively: after updating information
-             * relevant to the client watcher, check a few times more
-             * frequently. This ensures good reaction time when the signalling
-             * has to be done a bit before the actual change for technical
-             * reasons, and saves CPU cycles when no activities are expected. */
-            RTMSINTERVAL cMillies;
-            {
-                uint8_t uOld, uNew;
-                do
-                {
-                    uOld = ASMAtomicUoReadU8(&that->m->updateAdaptCtr);
-                    uNew = uOld ? uOld - 1 : uOld;
-                } while (!ASMAtomicCmpXchgU8(&that->m->updateAdaptCtr, uNew, uOld));
-                Assert(uOld <= RT_ELEMENTS(s_updateAdaptTimeouts) - 1);
-                cMillies = s_updateAdaptTimeouts[uOld];
-            }
-
-            int rc = RTSemEventWait(that->m->updateReq, cMillies);
-
-            /*
-             *  Restore the caller before using VirtualBox. If it fails, this
-             *  means VirtualBox is being uninitialized and we must terminate.
-             */
-            autoCaller.add();
-            if (!autoCaller.isOk())
-                break;
-
-            if (RT_SUCCESS(rc) || update || updateSpawned)
-            {
-                /* RT_SUCCESS(rc) means an update event is signaled */
-
-                // lock the machines list for reading
-                AutoReadLock thatLock(that->m->allMachines.getLockHandle() COMMA_LOCKVAL_SRC_POS);
-
-                if (RT_SUCCESS(rc) || update)
-                {
-                    /* obtain a new set of opened machines */
-                    machines.clear();
-
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end();
-                         ++it)
-                    {
-                        ComObjPtr<SessionMachine> sm;
-                        if ((*it)->isSessionOpenOrClosing(sm))
-                            machines.push_back(sm);
-                    }
-
-                    cnt = machines.size();
-                    LogFlowFunc(("UPDATE: direct session count = %d\n", cnt));
-                }
-
-                if (RT_SUCCESS(rc) || updateSpawned)
-                {
-                    /* obtain a new set of spawned machines */
-                    spawnedMachines.clear();
-
-                    for (MachinesOList::iterator it = that->m->allMachines.begin();
-                         it != that->m->allMachines.end();
-                         ++it)
-                    {
-                        if ((*it)->isSessionSpawning())
-                            spawnedMachines.push_back(*it);
-                    }
-
-                    cntSpawned = spawnedMachines.size();
-                    LogFlowFunc(("UPDATE: spawned session count = %d\n", cntSpawned));
-                }
-
-                // machines lock unwinds here
-            }
-
-            update = false;
-            for (size_t i = 0; i < cnt; ++ i)
-                update |= (machines[i])->checkForDeath();
-
-            updateSpawned = false;
-            for (size_t i = 0; i < cntSpawned; ++ i)
-                updateSpawned |= (spawnedMachines[i])->checkForSpawnFailure();
-
-            /* reap child processes */
-            {
-                AutoWriteLock alock(that COMMA_LOCKVAL_SRC_POS);
-                if (that->m->llProcesses.size())
-                {
-                    LogFlowFunc(("UPDATE: child process count = %d\n",
-                                 that->m->llProcesses.size()));
-                    VirtualBox::Data::ProcessList::iterator it = that->m->llProcesses.begin();
-                    while (it != that->m->llProcesses.end())
-                    {
-                        RTPROCESS pid = *it;
-                        RTPROCSTATUS status;
-                        int vrc = ::RTProcWait(pid, RTPROCWAIT_FLAGS_NOBLOCK, &status);
-                        if (vrc == VINF_SUCCESS)
-                        {
-                            LogFlowFunc(("pid %d (%x) was reaped, status=%d, reason=%d\n",
-                                         pid, pid, status.iStatus,
-                                         status.enmReason));
-                            it = that->m->llProcesses.erase(it);
-                        }
-                        else
-                        {
-                            LogFlowFunc(("pid %d (%x) was NOT reaped, vrc=%Rrc\n",
-                                         pid, pid, vrc));
-                            if (vrc != VERR_PROCESS_RUNNING)
-                            {
-                                /* remove the process if it is not already running */
-                                it = that->m->llProcesses.erase(it);
-                            }
-                            else
-                                ++ it;
-                        }
-                    }
-                }
-            }
-        }
-        while (true);
-    }
-    while (0);
-
-    /* release sets of machines if any */
-    machines.clear();
-    spawnedMachines.clear();
-
-#else
-# error "Port me!"
-#endif
-
-    VirtualBoxBase::uninitializeComForThread();
-    LogFlowFuncLeave();
-    return 0;
-}
-
-/**
  *  Thread function that handles custom events posted using #postEvent().
  */