Changeset 13457 in vbox

Timestamp:

Oct 21, 2008 5:46:36 PM (16 years ago)

Author:

vboxsync

Message:

Main: Implemented detection of the unexpected spawning session termination for Windows (#3128), optimized for other platforms.

Location:

trunk/src/VBox/Main

Files:

• MachineImpl.cpp (modified) (3 diffs)
• VirtualBoxImpl.cpp (modified) (14 diffs)
• include/MachineImpl.h (modified) (4 diffs)
• include/VirtualBoxImpl.h (modified) (2 diffs)

trunk/src/VBox/Main/MachineImpl.cpp

@@ -3153 +3153 @@
 
 /**
- * Returns the session machine object associated with the this machine.
- * The returned session machine is null if no direct session is currently open.
- *
- * @note locks this object for reading.
- */
-ComObjPtr <SessionMachine> Machine::sessionMachine()
-{
-    ComObjPtr <SessionMachine> sm;
-
-    AutoLimitedCaller autoCaller (this);
-    AssertComRCReturn (autoCaller.rc(), sm);
-
-    /* return null for inaccessible machines */
-    if (autoCaller.state() != Ready)
-        return sm;
-
-    AutoReadLock alock (this);
-
-    sm = mData->mSession.mMachine;
-    Assert (!sm.isNull() ||
-            mData->mSession.mState != SessionState_Open);
-
-    return  sm;
-}
-
-/**
- * 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).
- *
- * 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!"));
-        return true;
-    }
-
-    /* VirtualBox::addProcessToReap() needs a write lock */
-    AutoMultiWriteLock2 alock (mParent, this);
-
-    if (mData->mSession.mState != SessionState_Spawning)
-    {
-        /* nothing to do */
-        LogFlowThisFunc (("Not spawning any more!"));
-        return true;
-    }
-
-    HRESULT rc = S_OK;
-
-    RTPROCSTATUS status;
-    int vrc = ::RTProcWait (mData->mSession.mPid, RTPROCWAIT_FLAGS_NOBLOCK,
-                            &status);
-
-    if (vrc != VERR_PROCESS_RUNNING)
-        rc = setError (E_FAIL,
-                       tr ("Virtual machine '%ls' has terminated unexpectedly "
-                           "during startup"),
-                       name().raw());
-
-    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_Closed;
-
-        /* finalize the progress after setting the state, for consistency */
-        mData->mSession.mProgress->notifyComplete (rc);
-        mData->mSession.mProgress.setNull();
-
-        mParent->addProcessToReap (mData->mSession.mPid);
-        mData->mSession.mPid = NIL_RTPROCESS;
-
-        mParent->onSessionStateChange (mData->mUuid, SessionState_Closed);
-        return true;
-    }
-
-    return false;
-}
-
-/**
  *  Saves the registry entry of this machine to the given configuration node.
  *
@@ -4055 +3957 @@
     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 aIPCSem   Mutex IPC semaphore handle for this machine.
+ *
+ * @note locks this object for reading.
+ */
+#if defined (RT_OS_WINDOWS)
+bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
+                             HANDLE *aIPCSem /*= NULL*/)
+#elif defined (RT_OS_OS2)
+bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
+                             HMTX *aIPCSem /*= NULL*/);
+#else
+bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine)
+#endif
+{
+    AutoLimitedCaller autoCaller (this);
+    AssertComRCReturn (autoCaller.rc(), false);
+
+    /* just return false for inaccessible machines */
+    if (autoCaller.state() != Ready)
+        return false;
+
+    AutoReadLock alock (this);
+
+    if (mData->mSession.mState == SessionState_Open)
+    {
+        AssertReturn (!mData->mSession.mMachine.isNull(), false);
+
+        aMachine = mData->mSession.mMachine;
+
+#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);
+
+    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!"));
+        return true;
+    }
+
+    /* VirtualBox::addProcessToReap() needs a write lock */
+    AutoMultiWriteLock2 alock (mParent, this);
+
+    if (mData->mSession.mState != SessionState_Spawning)
+    {
+        /* nothing to do */
+        LogFlowThisFunc (("Not spawning any more!"));
+        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 ("Virtual machine '%ls' has terminated unexpectedly "
+                       "during startup"),
+                   name().raw());
+#else
+
+    RTPROCSTATUS status;
+    int vrc = ::RTProcWait (mData->mSession.mPid, RTPROCWAIT_FLAGS_NOBLOCK,
+                            &status);
+
+    if (vrc != VERR_PROCESS_RUNNING)
+        rc = setError (E_FAIL,
+                       tr ("Virtual machine '%ls' has terminated unexpectedly "
+                           "during startup"),
+                       name().raw());
+#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_Closed;
+
+        /* finalize the progress after setting the state, for consistency */
+        mData->mSession.mProgress->notifyComplete (rc);
+        mData->mSession.mProgress.setNull();
+
+        mParent->addProcessToReap (mData->mSession.mPid);
+        mData->mSession.mPid = NIL_RTPROCESS;
+
+        mParent->onSessionStateChange (mData->mUuid, SessionState_Closed);
+        return true;
+    }
+
+    return false;
 }
 
@@ -9316 +9394 @@
  * death of the client process that has a direct session to this machine.
  *
- * @note On Win32 and on OS/2, this method is called only when we've got the
+ * 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).
  *
- * @note On Linux, the method returns @c true if the client process has
+ * 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.

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -2930 +2930 @@
 
 /**
- *  Returns the list of opened machines (i.e. machines having direct sessions
- *  opened by client processes).
- *
- *  @note the returned list contains 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 a) lock the instance and b) chheck for
- *  instance->isReady() return value before manipulating the object directly
- *  (i.e. not through COM methods).
- *
- *  @note Locks objects for reading.
+ * Returns the list of opened machines (machines having direct sessionsopened by
+ * client processes).
+ *
+ * @note The returned list contains 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
+ * whenaccessing unprotected data directly.
+ *
+ * @note Locks objects for reading.
  */
 void VirtualBox::getOpenedMachines (SessionMachineVector &aVector)
 {
     AutoCaller autoCaller (this);
-    AssertComRCReturn (autoCaller.rc(), (void) 0);
-
-    std::list <ComObjPtr <SessionMachine> > list;
-
-    {
-        AutoReadLock alock (this);
-
-        for (MachineList::iterator it = mData.mMachines.begin();
-             it != mData.mMachines.end();
-             ++ it)
-        {
-            ComObjPtr <SessionMachine> sm = (*it)->sessionMachine();
-            /* SessionMachine is null when there are no open sessions */
-            if (!sm.isNull())
-                list.push_back (sm);
-        }
-    }
-
-    aVector = SessionMachineVector (list.begin(), list.end());
-    return;
-}
-
-/**
- *  Returns the list of opened machines (i.e. machines having direct sessions
- *  opened by client processes).
- *
- *  @note the returned list contains 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 a) lock the instance and b) chheck for
- *  instance->isReady() return value before manipulating the object directly
- *  (i.e. not through COM methods).
- *
- *  @note Locks objects for reading.
- */
-void VirtualBox::getSpawnedMachines (MachineVector &aVector)
-{
-    AutoCaller autoCaller (this);
-    AssertComRCReturn (autoCaller.rc(), (void) 0);
-
-    std::list <ComObjPtr <Machine> > list;
-
-    {
-        AutoReadLock alock (this);
-
-        for (MachineList::iterator it = mData.mMachines.begin();
-             it != mData.mMachines.end();
-             ++ it)
-        {
-            ComObjPtr <Machine> m = (*it);
-            SessionState_T state;
-            m->COMGETTER(SessionState(&state));
-            if (state == SessionState_Spawning)
-                list.push_back (m);
-        }
-    }
-
-    aVector = MachineVector (list.begin(), list.end());
-    return;
+    AssertComRCReturnVoid (autoCaller.rc());
+
+    aVector.clear();
+
+    AutoReadLock alock (this);
+
+    for (MachineList::iterator it = mData.mMachines.begin();
+         it != mData.mMachines.end();
+         ++ it)
+    {
+        ComObjPtr <SessionMachine> sm;
+        if ((*it)->isSessionOpen (sm))
+            aVector.push_back (sm);
+    }
 }
 
@@ -4709 +4664 @@
     SessionMachineVector machines;
     MachineVector spawnedMachines;
+
     size_t cnt = 0;
     size_t cntSpawned = 0;
@@ -4721 +4677 @@
     /// @todo (dmik) processes reaping!
 
-    HANDLE *handles = new HANDLE [1];
+    HANDLE handles [MAXIMUM_WAIT_OBJECTS];
     handles [0] = that->mWatcherData.mUpdateReq;
 
@@ -4736 +4692 @@
             autoCaller.release();
 
-#undef VBOX_CHECK_SPAWN_FAILURES
-#ifdef VBOX_CHECK_SPAWN_FAILURES
-            DWORD rc = ::WaitForMultipleObjects (cnt + 1, handles, FALSE, 500);
-#else
-            DWORD rc = ::WaitForMultipleObjects (cnt + 1, handles, FALSE, INFINITE);
-#endif
-
-            /*
-             *  Restore the caller before using VirtualBox. If it fails, this
-             *  means VirtualBox is being uninitialized and we must terminate.
-             */
+            DWORD rc = ::WaitForMultipleObjects (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())
@@ -4752 +4702 @@
 
             bool update = false;
-#ifdef VBOX_CHECK_SPAWN_FAILURES
-            if (rc == WAIT_OBJECT_0 || rc == WAIT_TIMEOUT)
-#else
+
             if (rc == WAIT_OBJECT_0)
-#endif
             {
                 /* update event is signaled */
@@ -4773 +4720 @@
                 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]);
+
+                AutoReadLock thatLock (that);
+
                 /* obtain a new set of opened machines */
-                that->getOpenedMachines (machines);
-                cnt = machines.size();
+                cnt = 0;
+                machines.clear();
+
+                for (MachineList::iterator it = that->mData.mMachines.begin();
+                     it != that->mData.mMachines.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)->isSessionOpen (sm, &ipcSem))
+                    {
+                        machines.push_back (sm);
+                        handles [1 + cnt] = ipcSem;
+                        ++ cnt;
+                    }
+                }
+
                 LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
-                AssertMsg ((cnt + 1) <= MAXIMUM_WAIT_OBJECTS,
-                           ("MAXIMUM_WAIT_OBJECTS reached"));
-                /* renew the set of event handles */
-                delete [] handles;
-                handles = new HANDLE [cnt + 1];
-                handles [0] = that->mWatcherData.mUpdateReq;
-                for (size_t i = 0; i < cnt; ++ i)
-                    handles [i + 1] = (machines [i])->ipcSem();
-
-#ifdef VBOX_CHECK_SPAWN_FAILURES
-                /* check for spawn errors */
-                that->getSpawnedMachines (spawnedMachines);
-                cntSpawned = spawnedMachines.size();
-                for (size_t i = 0; i < cntSpawned; ++ i)
-                    (spawnedMachines [i])->checkForSpawnFailure();
-#endif
+
+                /* obtain a new set of spawned machines */
+                cntSpawned = 0;
+                spawnedMachines.clear();
+
+                for (MachineList::iterator it = that->mData.mMachines.begin();
+                     it != that->mData.mMachines.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));
             }
         }
@@ -4801 +4792 @@
     while (0);
 
-    /* delete the set of event handles */
-    delete [] handles;
-
-    /* delete the set of opened machines if any */
+    /* 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();
@@ -4832 +4825 @@
             int vrc = RTSemEventWait (that->mWatcherData.mUpdateReq, 500);
 
-            /*
-             *  Restore the caller before using VirtualBox. If it fails, this
-             *  means VirtualBox is being uninitialized and we must terminate.
-             */
+            /* Restore the caller before using VirtualBox. If it fails, this
+             * means VirtualBox is being uninitialized and we must terminate. */
             autoCaller.add();
             if (!autoCaller.isOk())
@@ -4841 +4832 @@
 
             bool update = false;
+            bool updateSpawned = false;
 
             if (VBOX_SUCCESS (vrc))
@@ -4846 +4838 @@
                 /* update event is signaled */
                 update = true;
+                updateSpawned = true;
             }
             else
@@ -4914 +4907 @@
                                    ("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)
+            if (update || updateSpawned)
             {
-                /* close the old muxsem */
-                if (muxSem != NULLHANDLE)
-                    ::DosCloseMuxWaitSem (muxSem);
-                /* obtain a new set of opened machines */
-                that->getOpenedMachines (machines);
-                cnt = machines.size();
-                LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
-                /// @todo use several muxwait sems if cnt is > 64
-                AssertMsg (cnt <= 64 /* according to PMREF */,
-                           ("maximum of 64 mutex semaphores reached (%d)", cnt));
-                if (cnt > 64)
-                    cnt = 64;
-                if (cnt > 0)
+                AutoReadLock thatLock (that);
+
+                if (update)
                 {
-                    /* renew the set of event handles */
-                    for (size_t i = 0; i < cnt; ++ i)
+                    /* close the old muxsem */
+                    if (muxSem != NULLHANDLE)
+                        ::DosCloseMuxWaitSem (muxSem);
+
+                    /* obtain a new set of opened machines */
+                    cnt = 0;
+                    machines.clear();
+
+                    for (MachineList::iterator it = that->mData.mMachines.begin();
+                         it != that->mData.mMachines.end(); ++ it)
                     {
-                        handles [i].hsemCur = (HSEM) machines [i]->ipcSem();
-                        handles [i].ulUser = i;
+                        /// @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)->isSessionOpen (sm, &ipcSem))
+                        {
+                            machines.push_back (sm);
+                            handles [cnt].hsemCur = (HSEM) ipcSem;
+                            handles [cnt].ulUser = cnt;
+                            ++ cnt;
+                        }
                     }
-                    /* 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);
+
+                    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 (MachineList::iterator it = that->mData.mMachines.begin();
+                         it != that->mData.mMachines.end(); ++ it)
+                    {
+                        if ((*it)->isSessionSpawning())
+                            spawnedMachines.push_back (*it);
+                    }
+
+                    cntSpawned = spawnedMachines.size();
+                    LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
                 }
             }
@@ -4954 +4989 @@
         ::DosCloseMuxWaitSem (muxSem);
 
-    /* delete the set of opened machines if any */
+    /* release sets of machines if any */
     machines.clear();
+    spawnedMachines.clear();
 
 #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
@@ -4983 +5019 @@
                 break;
 
-            if (VBOX_SUCCESS (rc) || update)
+            if (VBOX_SUCCESS (rc) || update || updateSpawned)
             {
                 /* VBOX_SUCCESS (rc) means an update event is signaled */
 
-                /* obtain a new set of opened machines */
-                that->getOpenedMachines (machines);
-                cnt = machines.size();
-                LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
-            }
-
-            if (VBOX_SUCCESS (rc) || updateSpawned)
-            {
-                /* VBOX_SUCCESS (rc) means an update event is signaled */
-
-                /* obtain a new set of spawned machines */
-                that->getSpawnedMachines (spawnedMachines);
-                cntSpawned = spawnedMachines.size();
-                LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
+                AutoReadLock thatLock (that);
+
+                if (VBOX_SUCCESS (rc) || update)
+                {
+                    /* obtain a new set of opened machines */
+                    machines.clear();
+
+                    for (MachineList::iterator it = that->mData.mMachines.begin();
+                         it != that->mData.mMachines.end(); ++ it)
+                    {
+                        ComObjPtr <SessionMachine> sm;
+                        if ((*it)->isSessionOpen (sm))
+                            machines.push_back (sm);
+                    }
+
+                    cnt = machines.size();
+                    LogFlowFunc (("UPDATE: direct session count = %d\n", cnt));
+                }
+
+                if (VBOX_SUCCESS (rc) || updateSpawned)
+                {
+                    /* obtain a new set of spawned machines */
+                    spawnedMachines.clear();
+
+                    for (MachineList::iterator it = that->mData.mMachines.begin();
+                         it != that->mData.mMachines.end(); ++ it)
+                    {
+                        if ((*it)->isSessionSpawning())
+                            spawnedMachines.push_back (*it);
+                    }
+
+                    cntSpawned = spawnedMachines.size();
+                    LogFlowFunc (("UPDATE: spawned session count = %d\n", cntSpawned));
+                }
             }
 
@@ -5054 +5110 @@
     while (0);
 
-    /* delete the set of opened machines if any */
+    /* release sets of machines if any */
     machines.clear();
+    spawnedMachines.clear();
 
 #else

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

@@ -560 +560 @@
     bool isRegistered() { return !!mData->mRegistered; }
 
-    ComObjPtr <SessionMachine> sessionMachine();
-
-    bool checkForSpawnFailure();
-
     /**
      *  Returns the VirtualBox object this machine belongs to.
@@ -626 +622 @@
                                Progress *aProgress);
     HRESULT openExistingSession (IInternalSessionControl *aControl);
+
+#if defined (RT_OS_WINDOWS)
+    bool isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
+                        HANDLE *aIPCSem = NULL);
+    bool isSessionSpawning (RTPROCESS *aPID = NULL);
+#elif defined (RT_OS_OS2)
+    bool isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
+                        HMTX *aIPCSem = NULL);
+    bool isSessionSpawning (RTPROCESS *aPID = NULL);
+#else
+    bool isSessionOpen (ComObjPtr <SessionMachine> &aMachine);
+    bool isSessionSpawning();
+#endif
+
+    bool checkForSpawnFailure();
 
     HRESULT trySetRegistered (BOOL aRegistered);
@@ -859 +870 @@
 
     bool checkForDeath();
-    bool checkForSpawnFailure();
-
-#if defined (RT_OS_WINDOWS)
-    HANDLE ipcSem() { return mIPCSem; }
-#elif defined (RT_OS_OS2)
-    HMTX ipcSem() { return mIPCSem; }
-#endif
 
     HRESULT onDVDDriveChange();
@@ -930 +934 @@
     SnapshotData mSnapshotData;
 
-    /** interprocess semaphore handle (id) for this machine */
-#if defined(RT_OS_WINDOWS)
+    /** interprocess semaphore handle for this machine */
+#if defined (RT_OS_WINDOWS)
     HANDLE mIPCSem;
     Bstr mIPCSemName;
-#elif defined(RT_OS_OS2)
+    friend bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
+                                        HANDLE *aIPCSem);
+#elif defined (RT_OS_OS2)
     HMTX mIPCSem;
     Bstr mIPCSemName;
-#elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
+    friend bool Machine::isSessionOpen (ComObjPtr <SessionMachine> &aMachine,
+                                        HMTX *aIPCSem);
+#elif defined (VBOX_WITH_SYS_V_IPC_SESSION_WATCHER)
     int mIPCSem;
 #else

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

@@ -83 +83 @@
     typedef std::list <ComPtr <IVirtualBoxCallback> > CallbackList;
     typedef std::vector <ComPtr <IVirtualBoxCallback> > CallbackVector;
+
+    typedef std::vector <ComObjPtr <SessionMachine> > SessionMachineVector;
+    typedef std::vector <ComObjPtr <Machine> > MachineVector;
 
     class CallbackEvent;
@@ -231 +234 @@
     ComObjPtr <GuestOSType> getUnknownOSType();
 
-    typedef std::vector <ComObjPtr <SessionMachine> > SessionMachineVector;
-    typedef std::vector <ComObjPtr <Machine> > MachineVector;
     void getOpenedMachines (SessionMachineVector &aVector);
-    void getSpawnedMachines (MachineVector &aVector);
 
     bool isMachineIdValid (const Guid &aId)