Changeset 36673 in vbox for trunk/src/VBox/Main/src-server

Timestamp:

Apr 14, 2011 3:22:37 PM (14 years ago)

Author:

vboxsync

Message:

Main/Machine: add a way to terminate VM processes if they don't respond to the usual requests. Not an API change, just a comment change, and a slight VBoxManage touch up so that one can trigger it.

File:

• trunk/src/VBox/Main/src-server/MachineImpl.cpp (modified) (15 diffs)

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

@@ -3044 +3044 @@
             // this machine is awaiting for a spawning session to be opened:
             // then the calling process must be the one that got started by
-            // launchVMProcess()
+            // LaunchVMProcess()
 
             LogFlowThisFunc(("mSession.mPid=%d(0x%x)\n", mData->mSession.mPid, mData->mSession.mPid));
@@ -3052 +3052 @@
                 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"),
+                                   "machine '%s', while only the process started by LaunchVMProcess (PID=0x%08X) is allowed"),
                                 pid, mUserData->s.strName.c_str(), mData->mSession.mPid);
         }
@@ -3081 +3081 @@
              *  Leave the lock before calling the client process -- it will call
              *  Machine/SessionMachine methods. Leaving the lock here is quite safe
-             *  because the state is Spawning, so that openRemotesession() and
-             *  openExistingSession() calls will fail. This method, called before we
+             *  because the state is Spawning, so that LaunchVMProcess() and
+             *  LockMachine() calls will fail. This method, called before we
              *  enter the lock again, will fail because of the wrong PID.
              *
@@ -3120 +3120 @@
                 {
                     /*
-                     *  after openRemoteSession(), the first and the only
+                     *  after LaunchVMProcess(), the first and the only
                      *  entry in remoteControls is that remote session
                      */
@@ -3227 +3227 @@
                                       IProgress **aProgress)
 {
-    CheckComArgNotNull(aSession);
+    Utf8Str strType(aType);
+    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 (strType != "emergencystop")
+        CheckComArgNotNull(aSession);
     CheckComArgStrNotEmptyOrNull(aType);
     CheckComArgOutPointerValid(aProgress);
@@ -3234 +3242 @@
     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 IInternalSessionControl interface */
-    ComPtr<IInternalSessionControl> control = aSession;
-    ComAssertMsgRet(!!control, ("No IInternalSessionControl interface"),
-                      E_INVALIDARG);
+    ComPtr<IInternalSessionControl> control;
+    HRESULT rc = S_OK;
+
+    if (strType != "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 */
+        control = aSession;
+        ComAssertMsgRet(!control.isNull(),
+                        ("No IInternalSessionControl interface"),
+                        E_INVALIDARG);
+    }
 
     /* get the teleporter enable state for the progress object init. */
@@ -3255 +3271 @@
 
     /* create a progress object */
-    ComObjPtr<ProgressProxy> progress;
-    progress.createObject();
-    rc = progress->init(mParent,
-                        static_cast<IMachine*>(this),
-                        Bstr(tr("Spawning session")).raw(),
-                        TRUE /* aCancelable */,
-                        fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
-                        Bstr(tr("Spawning session")).raw(),
-                        2 /* uFirstOperationWeight */,
-                        fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
-    if (SUCCEEDED(rc))
-    {
-        rc = openRemoteSession(control, aType, aEnvironment, progress);
+    if (strType != "emergencystop")
+    {
+        ComObjPtr<ProgressProxy> progress;
+        progress.createObject();
+        rc = progress->init(mParent,
+                            static_cast<IMachine*>(this),
+                            BstrFmt(tr("Starting VM \"%s\" (%s)"), aType).raw(),
+                            TRUE /* aCancelable */,
+                            fTeleporterEnabled ? 20 : 10 /* uTotalOperationsWeight */,
+                            Bstr(tr("Spawning session")).raw(),
+                            2 /* uFirstOperationWeight */,
+                            fTeleporterEnabled ? 3 : 1 /* cOtherProgressObjectOperations */);
+
         if (SUCCEEDED(rc))
         {
-            progress.queryInterfaceTo(aProgress);
-
-            /* signal the client watcher thread */
-            mParent->updateClientWatcher();
-
-            /* fire an event */
-            mParent->onSessionStateChange(getId(), SessionState_Spawning);
-        }
+            rc = launchVMProcess(control, strType, 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();
     }
 
@@ -5947 +5994 @@
         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"),
@@ -6169 +6216 @@
  *        (inside the lock).
  */
-HRESULT Machine::openRemoteSession(IInternalSessionControl *aControl,
-                                   IN_BSTR aType,
-                                   IN_BSTR aEnvironment,
-                                   ProgressProxy *aProgress)
+HRESULT Machine::launchVMProcess(IInternalSessionControl *aControl,
+                                 const Utf8Str &strType,
+                                 const Utf8Str &strEnvironment,
+                                 ProgressProxy *aProgress)
 {
     LogFlowThisFuncEnter();
@@ -6215 +6262 @@
     RTENV env = RTENV_DEFAULT;
 
-    if (aEnvironment != NULL && *aEnvironment)
+    if (!strEnvironment.isEmpty())
     {
         char *newEnvStr = NULL;
@@ -6225 +6272 @@
             AssertRCBreakStmt(vrc2, vrc = vrc2);
 
-            newEnvStr = RTStrDup(Utf8Str(aEnvironment).c_str());
+            newEnvStr = RTStrDup(strEnvironment.c_str());
             AssertPtrBreakStmt(newEnvStr, vrc = vrc2);
 
@@ -6263 +6310 @@
             RTStrFree(newEnvStr);
     }
-
-    Utf8Str strType(aType);
 
     /* Qt is default */
@@ -10569 +10614 @@
     {
         /* mType is not null when this machine's process has been started by
-         * Machine::launchVMProcess(), therefore it is our child.  We
+         * Machine::LaunchVMProcess(), therefore it is our child.  We
          * need to queue the PID to reap the process (and avoid zombies on
          * Linux). */
@@ -10793 +10838 @@
         return VBOX_E_INVALID_OBJECT_STATE;
 
-    /* Finalize the openRemoteSession progress object. */
+    /* Finalize the LaunchVMProcess progress object. */
     if (mData->mSession.mProgress)
     {
@@ -11096 +11141 @@
          * it releases the IPC semaphore.
          * Note! Because we're "reusing" mProgress here, this must be a proxy
-         *       object just like for openRemoteSession. */
+         *       object just like for LaunchVMProcess. */
         Assert(mData->mSession.mProgress.isNull());
         ComObjPtr<ProgressProxy> progress;