Changeset 13405 in vbox for trunk/src

Timestamp:

Oct 20, 2008 7:49:09 PM (16 years ago)

Author:

vboxsync

Message:

Main: report unexpected failures when spawning a remote session

Location:

trunk/src/VBox/Main

Files:

• MachineImpl.cpp (modified) (1 diff)
• VirtualBoxImpl.cpp (modified) (5 diffs)
• include/MachineImpl.h (modified) (2 diffs)
• include/VirtualBoxImpl.h (modified) (1 diff)

trunk/src/VBox/Main/MachineImpl.cpp

@@ -3114 +3114 @@
 
 /**
+ *  Called from the client watcher thread to check for unexpected client
+ *  process death during Session_Spawning state.
+ *
+ *  @note 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). This
+ *  method always returns true.
+ *
+ *  @note On Linux, the method returns true if the client process has
+ *  terminated abnormally (and/or the session has been uninitialized) and
+ *  false if it is 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 ("The virtual machine '%ls' terminated unexpectedly during startup"),
+                       name().raw());
+
+    if (FAILED (rc))
+    {
+        /* Remove the remote control from the list on failure
+         * and reset session state to Closed. */
+        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.
  *

trunk/src/VBox/Main/VirtualBoxImpl.cpp

@@ -2138 +2138 @@
         progress.queryInterfaceTo (aProgress);
 
+        /* signal the client watcher thread */
+        updateClientWatcher();
+
         /* fire an event */
         onSessionStateChange (aMachineId, SessionState_Spawning);
@@ -2932 +2935 @@
 
     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;
 }
@@ -4637 +4679 @@
 
     SessionMachineVector machines;
+    MachineVector spawnedMachines;
     size_t cnt = 0;
+    size_t cntSpawned = 0;
 
 #if defined(RT_OS_WINDOWS)
@@ -4705 +4749 @@
                 for (size_t i = 0; i < cnt; ++ i)
                     handles [i + 1] = (machines [i])->ipcSem();
+
+#if 0 /* untested */
+                /* check for spawn errors */
+                that->getSpawnedMachines (spawnedMachines);
+                cntSpawned = spawnedMachines.size();
+                for (size_t i = 0; i < cntSpawned; ++ i)
+                    (spawnedMachines [i])->checkForSpawnFailure();
+#endif
             }
         }
@@ -4905 +4957 @@
             for (size_t i = 0; i < cnt; ++ i)
                 need_update |= (machines [i])->checkForDeath();
+
+            that->getSpawnedMachines (spawnedMachines);
+            cntSpawned = spawnedMachines.size();
+
+            for (size_t i = 0; i < cntSpawned; ++ i)
+                (spawnedMachines [i])->checkForSpawnFailure();
 
             /* reap child processes */

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

@@ -552 +552 @@
     // public methods only for internal purposes
 
+    //
+    //  Called from the client watcher thread to check for unexpected client
+    //  process death during Session_Spawning state.
+    //
+    bool checkForSpawnFailure();
+
     /// @todo (dmik) add lock and make non-inlined after revising classes
     //  that use it. Note: they should enter Machine lock to keep the returned
@@ -854 +860 @@
 
     bool checkForDeath();
+    bool checkForSpawnFailure();
 
 #if defined (RT_OS_WINDOWS)

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

@@ -230 +230 @@
 
     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)