Changeset 39300 in vbox

Timestamp:

Nov 15, 2011 9:57:05 AM (13 years ago)

Author:

vboxsync

Message:

VBoxService/GuestCtrl: Overhauled internals, removed pipe double buffering, now using an IPC request/response system for communication (work in progress).

Location:

trunk/src/VBox/Additions/common/VBoxService

Files:

• VBoxServiceControl.cpp (modified) (13 diffs)
• VBoxServiceControlExecThread.cpp (modified) (47 diffs)
• VBoxServiceControlExecThread.h (deleted)
• VBoxServiceInternal.h (modified) (3 diffs)

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp

@@ -30 +30 @@
 #include "VBoxServiceInternal.h"
 #include "VBoxServiceUtils.h"
-#include "VBoxServiceControlExecThread.h"
 
 using namespace guestControl;
@@ -210 +209 @@
                     break;
             }
-
-            if (RT_FAILURE(rc))
-                VBoxServiceVerbose(3, "Control: Message was processed with rc=%Rrc\n", rc);
         }
 
@@ -227 +223 @@
     }
 
-    RTSemEventMultiDestroy(g_hControlEvent);
-    g_hControlEvent = NIL_RTSEMEVENTMULTI;
     return rc;
 }
@@ -371 +365 @@
 
     if (RT_SUCCESS(rc))
-        rc = VBoxServiceControlExecThreadPerform(uPID, &ctrlRequest);
+        rc = VBoxServiceControlThreadPerform(uPID, &ctrlRequest);
 
     if (RT_SUCCESS(rc))
@@ -378 +372 @@
             *pcbRead = ctrlRequest.cbData;
     }
+    else /* Something went wrong, nothing read. */
+        *pcbRead = 0;
 
     return rc;
@@ -409 +405 @@
                         ? VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF : VBOXSERVICECTRLREQUEST_STDIN_WRITE;
     if (RT_SUCCESS(rc))
-        rc = VBoxServiceControlExecThreadPerform(uPID, &ctrlRequest);
+        rc = VBoxServiceControlThreadPerform(uPID, &ctrlRequest);
 
     if (RT_SUCCESS(rc))
@@ -583 +579 @@
     /** @todo Later, figure what to do if we're in RTProcWait(). It's a very
      *        annoying call since doesn't support timeouts in the posix world. */
-    RTSemEventMultiSignal(g_hControlEvent);
+    if (g_hControlEvent != NIL_RTSEMEVENTMULTI)
+        RTSemEventMultiSignal(g_hControlEvent);
 
     /*
@@ -591 +588 @@
     if (g_GuestControlSvcClientID)
     {
+        VBoxServiceVerbose(3, "Control: Cancelling pending waits ...\n");
+
         int rc = VbglR3GuestCtrlCancelPendingWaits(g_GuestControlSvcClientID);
         if (RT_FAILURE(rc))
@@ -602 +601 @@
     VBoxServiceVerbose(3, "Control: Destroying threads ...\n");
 
-    int rc = RTCritSectEnter(&g_GuestControlThreadsCritSect);
-    if (RT_SUCCESS(rc))
-    {
-        /* Signal all threads that we want to shutdown. */
-        PVBOXSERVICECTRLTHREAD pThread;
-        RTListForEach(&g_GuestControlThreads, pThread, VBOXSERVICECTRLTHREAD, Node)
-            VBoxServiceControlThreadSignalShutdown(pThread);
-
-        /* Wait for threads to shutdown. */
-        RTListForEach(&g_GuestControlThreads, pThread, VBOXSERVICECTRLTHREAD, Node)
-        {
-            int rc2 = VBoxServiceControlExecThreadShutdown(pThread);
-            if (RT_FAILURE(rc2))
-                VBoxServiceError("Control: Guest process thread failed to stop; rc2=%Rrc\n", rc2);
-        }
-
-        /* Finally destroy thread list. */
-        pThread = RTListGetFirst(&g_GuestControlThreads, VBOXSERVICECTRLTHREAD, Node);
-        while (pThread)
-        {
-            PVBOXSERVICECTRLTHREAD pNext = RTListNodeGetNext(&pThread->Node, VBOXSERVICECTRLTHREAD, Node);
-            bool fLast = RTListNodeIsLast(&g_GuestControlThreads, &pThread->Node);
-
-            VBoxServiceControlRemoveThread(pThread);
-            VBoxServiceControlExecThreadDestroy(pThread);
-
-            if (fLast)
-                break;
-
-            pThread = pNext;
-        }
-
-        int rc2 = RTCritSectLeave(&g_GuestControlThreadsCritSect);
-        if (RT_SUCCESS(rc))
-            rc = rc2;
-    }
-
+    /* Signal all threads that we want to shutdown. */
+    PVBOXSERVICECTRLTHREAD pThread;
+    RTListForEach(&g_GuestControlThreads, pThread, VBOXSERVICECTRLTHREAD, Node)
+        VBoxServiceControlThreadSignalShutdown(pThread);
+
+    /* Wait for threads to shutdown and destroy thread list. */
+    pThread = RTListGetFirst(&g_GuestControlThreads, VBOXSERVICECTRLTHREAD, Node);
+    while (pThread)
+    {
+        PVBOXSERVICECTRLTHREAD pNext = RTListNodeGetNext(&pThread->Node, VBOXSERVICECTRLTHREAD, Node);
+        bool fLast = RTListNodeIsLast(&g_GuestControlThreads, &pThread->Node);
+
+        int rc2 = VBoxServiceControlThreadWaitForShutdown(pThread,
+                                                          30 * 1000 /* Wait 30 seconds max. */);
+        if (RT_FAILURE(rc2))
+            VBoxServiceError("Control: Guest process thread failed to stop; rc=%Rrc\n", rc2);
+
+        if (fLast)
+            break;
+
+        pThread = pNext;
+    }
+
+    AssertMsg(RTListIsEmpty(&g_GuestControlThreads),
+              ("Guest process thread list still contains children when it should not\n"));
+
+    /* Destroy critical section. */
     RTCritSectDelete(&g_GuestControlThreadsCritSect);
 }
@@ -661 +650 @@
 
 
+/**
+ * Determines whether starting a new guest process according to the
+ * maximum number of concurrent guest processes defined is allowed or not.
+ *
+ * @return  IPRT status code.
+ * @param   pbAllowed           True if starting (another) guest process
+ *                              is allowed, false if not.
+ */
 static int VBoxServiceControlStartAllowed(bool *pbAllowed)
 {
@@ -721 +718 @@
 const PVBOXSERVICECTRLTHREAD VBoxServiceControlGetThreadByPID(uint32_t uPID)
 {
-    PVBOXSERVICECTRLTHREAD pNode = NULL;
+    PVBOXSERVICECTRLTHREAD pThread = NULL;
     int rc = RTCritSectEnter(&g_GuestControlThreadsCritSect);
     if (RT_SUCCESS(rc))
     {
-        PVBOXSERVICECTRLTHREAD pNodeCur;
-        RTListForEach(&g_GuestControlThreads, pNodeCur, VBOXSERVICECTRLTHREAD, Node)
-        {
-            if (pNodeCur->uPID == uPID)
+        PVBOXSERVICECTRLTHREAD pThreadCur;
+        RTListForEach(&g_GuestControlThreads, pThreadCur, VBOXSERVICECTRLTHREAD, Node)
+        {
+            if (pThreadCur->uPID == uPID)
             {
-                pNode = pNodeCur;
+                pThread = pThreadCur;
                 break;
             }
@@ -740 +737 @@
     }
 
-    return pNode;
-}
-
-
+    return pThread;
+}
+
+
+/**
+ * Removes the specified guest process thread from the global thread
+ * list.
+ *
+ * @return  IPRT status code.
+ * @param   pThread             Thread to remove.
+ */
 void VBoxServiceControlRemoveThread(PVBOXSERVICECTRLTHREAD pThread)
 {
@@ -752 +756 @@
     if (RT_SUCCESS(rc))
     {
+        VBoxServiceVerbose(4, "ControlExec: Removing thread (PID: %u) from thread list\n",
+                           pThread->uPID);
         RTListNodeRemove(&pThread->Node);
 
         int rc2 = RTCritSectLeave(&g_GuestControlThreadsCritSect);
-        if (RT_SUCCESS(rc))
-            rc = rc2;
+        AssertRC(rc2);
     }
 }

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlExecThread.cpp

@@ -38 +38 @@
 
 #include "VBoxServiceInternal.h"
-#include "VBoxServiceControlExecThread.h"
 
 using namespace guestControl;
 
 /* Internal functions. */
-static int vboxServiceControlExecThreadAssignPID(PVBOXSERVICECTRLTHREAD pData, uint32_t uPID);
-static void vboxServiceControlExecThreadFree(PVBOXSERVICECTRLTHREAD pData);
-static int vboxServiceControlThreadWaitForShutdown(const PVBOXSERVICECTRLTHREAD pThread);
+static int vboxServiceControlThreadAssignPID(PVBOXSERVICECTRLTHREAD pData, uint32_t uPID);
+static void vboxServiceControlThreadFree(PVBOXSERVICECTRLTHREAD pData);
+static int vboxServiceControlThreadShutdown(PVBOXSERVICECTRLTHREAD pThread);
 
 /**
@@ -84 +83 @@
 
     pThread->uContextID = u32ContextID;
-    /* ClientID will be assigned when thread is started! */
+    /* ClientID will be assigned when thread is started; every guest
+     * process has its own client ID to detect crashes on a per-guest-process
+     * level. */
 
     int rc = RTCritSectInit(&pThread->CritSect);
@@ -141 +142 @@
         /* User management. */
         pThread->pszUser     = RTStrDup(pszUser);
+        AssertPtr(pThread->pszUser);
         pThread->pszPassword = RTStrDup(pszPassword);
+        AssertPtr(pThread->pszPassword);
     }
 
     if (RT_FAILURE(rc)) /* Clean up on failure. */
-        vboxServiceControlExecThreadFree(pThread);
-    return rc;
-}
-
-
-/**
- * TODO
- *
- * @param   pThread
- */
-void VBoxServiceControlThreadSignalShutdown(const PVBOXSERVICECTRLTHREAD pThread)
-{
-    AssertPtrReturnVoid(pThread);
+        vboxServiceControlThreadFree(pThread);
+    return rc;
+}
+
+
+/**
+ * Signals a guest process thread that we want it to shut down in
+ * a gentle way.
+ *
+ * @return  IPRT status code.
+ * @param   pThread             Thread to shut down.
+ */
+int VBoxServiceControlThreadSignalShutdown(const PVBOXSERVICECTRLTHREAD pThread)
+{
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
 
     VBoxServiceVerbose(3, "ControlExec: [PID %u]: Signalling shutdown ...\n",
                        pThread->uPID);
 
-    /* First, set the shutdown flag. */
-    ASMAtomicXchgBool(&pThread->fShutdown, true);
+    /* Do *not* set pThread->fShutdown or other stuff here!
+     * The guest thread loop will do that as soon as it processes the quit message. */
 
     VBOXSERVICECTRLREQUEST ctrlRequest;
@@ -169 +174 @@
     ctrlRequest.enmType = VBOXSERVICECTRLREQUEST_QUIT;
 
-    int rc = VBoxServiceControlExecThreadPerform(pThread->uPID, &ctrlRequest);
+    int rc = VBoxServiceControlThreadPerform(pThread->uPID, &ctrlRequest);
     if (RT_FAILURE(rc))
         VBoxServiceVerbose(3, "ControlExec: [PID %u]: Sending quit request failed with rc=%Rrc\n",
                            pThread->uPID, rc);
-}
-
-
-static int vboxServiceControlThreadWaitForShutdown(const PVBOXSERVICECTRLTHREAD pThread)
+    return rc;
+}
+
+
+/**
+ * Wait for a guest process thread to shut down.
+ *
+ * @return  IPRT status code.
+ * @param   pThread             Thread to wait shutting down for.
+ * @param   RTMSINTERVAL        Timeout in ms to wait for shutdown.
+ */
+int VBoxServiceControlThreadWaitForShutdown(const PVBOXSERVICECTRLTHREAD pThread,
+                                            RTMSINTERVAL msTimeout)
 {
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
     int rc = VINF_SUCCESS;
     if (   pThread->Thread != NIL_RTTHREAD
-        && !pThread->fShutdown) /* Only shutdown threads which aren't yet. */
-    {
+        && !ASMAtomicReadBool(&pThread->fStopped)) /* Only shutdown threads which aren't yet. */
+    {
+        VBoxServiceVerbose(3, "ControlExec: [PID %u]: Waiting for shutdown ...\n",
+                           pThread->uPID);
+
         /* Wait a bit ... */
-        rc = RTThreadWait(pThread->Thread, 30 * 1000 /* Wait 30 seconds max. */, NULL);
+        int rcThread;
+        rc = RTThreadWait(pThread->Thread, msTimeout, &rcThread);
+        if (RT_FAILURE(rcThread))
+        {
+            VBoxServiceError("ControlExec: [PID %u]: Shutdown returned error rc=%Rrc\n",
+                             pThread->uPID, rcThread);
+            if (RT_SUCCESS(rc))
+                rc = rcThread;
+        }
     }
     return rc;
@@ -193 +218 @@
  * Frees an allocated thread data structure along with all its allocated parameters.
  *
- * @param   pThread        Pointer to thread data to free.
- */
-static void vboxServiceControlExecThreadFree(const PVBOXSERVICECTRLTHREAD pThread)
-{
-    if (pThread)
-    {
-        VBoxServiceVerbose(3, "ControlExec: [PID %u]: Freeing thread data ...\n",
-                           pThread->uPID);
-
-        RTStrFree(pThread->pszCmd);
-        if (pThread->uNumEnvVars)
-        {
-            for (uint32_t i = 0; i < pThread->uNumEnvVars; i++)
-                RTStrFree(pThread->papszEnv[i]);
-            RTMemFree(pThread->papszEnv);
-        }
-        RTGetOptArgvFree(pThread->papszArgs);
-        RTStrFree(pThread->pszUser);
-        RTStrFree(pThread->pszPassword);
+ * @param   pThread             Pointer to thread data to free.
+ */
+static void vboxServiceControlThreadFree(const PVBOXSERVICECTRLTHREAD pThread)
+{
+    if (!pThread)
+        return;
+
+    VBoxServiceVerbose(3, "ControlExec: [PID %u]: Freeing thread data ...\n",
+                       pThread->uPID);
+
+    RTStrFree(pThread->pszCmd);
+    if (pThread->uNumEnvVars)
+    {
+        for (uint32_t i = 0; i < pThread->uNumEnvVars; i++)
+            RTStrFree(pThread->papszEnv[i]);
+        RTMemFree(pThread->papszEnv);
+    }
+    RTGetOptArgvFree(pThread->papszArgs);
+    RTStrFree(pThread->pszUser);
+    RTStrFree(pThread->pszPassword);
+
+    if (pThread->RequestEvent != NIL_RTSEMEVENTMULTI)
+    {
+        int rc2 = RTSemEventMultiDestroy(pThread->RequestEvent);
+        AssertRC(rc2);
     }
 }
@@ -223 +254 @@
  * @param   phStdInW            The standard input pipe handle.
  */
-static int VBoxServiceControlExecProcCloseStdIn(RTPOLLSET hPollSet, PRTPIPE phStdInW)
+static int VBoxServiceControlThreadCloseStdIn(RTPOLLSET hPollSet, PRTPIPE phStdInW)
 {
     int rc = RTPollSetRemove(hPollSet, VBOXSERVICECTRLPIPEID_STDIN);
@@ -245 +276 @@
  * @param   phStdInW            The standard input pipe handle.
  */
-static int VBoxServiceControlExecProcHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW)
+static int VBoxServiceControlThreadHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW)
 {
     NOREF(fPollEvt);
 
-    return VBoxServiceControlExecProcCloseStdIn(hPollSet, phStdInW);
+    return VBoxServiceControlThreadCloseStdIn(hPollSet, phStdInW);
 }
 
@@ -263 +294 @@
  *
  */
-static int VBoxServiceControlExecProcHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt,
-                                                       PRTPIPE phPipeR, uint32_t idPollHnd)
+static int VBoxServiceControlThreadHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt,
+                                                     PRTPIPE phPipeR, uint32_t idPollHnd)
 {
     int rc = VINF_SUCCESS;
@@ -306 +337 @@
 
 
-int VBoxServiceControlExecProcHandleIPCNotify(RTPOLLSET hPollSet, uint32_t fPollEvt,
-                                              PRTPIPE phNotificationPipeR)
-{
-#ifdef DEBUG_andy
-    VBoxServiceVerbose(4, "ControlExec: HandleIPCNotify\n");
-#endif
-    /* Drain the notification pipe. */
-    uint8_t abBuf[8];
-    size_t cbIgnore;
-    int rc = RTPipeRead(*phNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
-    if (RT_FAILURE(rc))
-        VBoxServiceError("ControlExec: Draining IPC notification pipe failed with rc=%Rrc\n", rc);
-    return rc;
-}
-
-
-static int VBoxServiceControlExecHandleIPCRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
-                                                  PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
-                                                  PVBOXSERVICECTRLREQUEST pRequest)
+static int VBoxServiceControlThreadHandleIPCRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
+                                                    PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
+                                                    PVBOXSERVICECTRLTHREAD pThread)
 {
 #ifdef DEBUG_andy
@@ -330 +345 @@
 #endif
 
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdInW, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdOutR, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdErrR, VERR_INVALID_POINTER);
-    AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
-
-    int rc = VINF_SUCCESS;
-    int rcReq = VINF_SUCCESS; /* Actual request result. */
-
-    switch (pRequest->enmType)
-    {
-        case VBOXSERVICECTRLREQUEST_QUIT: /* Main control asked us to quit. */
-            /** @todo Check for some conditions to check to
-             *        veto quitting. */
-            pRequest->rc = VINF_SUCCESS;
-            break;
-
-        case VBOXSERVICECTRLREQUEST_STDIN_WRITE:
-            /* Fall through is intentional. */
-        case VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF:
-        {
-            AssertPtrReturn(pRequest->pvData, VERR_INVALID_POINTER);
-            AssertReturn(pRequest->cbData, VERR_INVALID_PARAMETER);
-
-            size_t cbWritten = 0;
-            if (*phStdInW != NIL_RTPIPE)
+
+    int rc = RTCritSectEnter(&pThread->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        /* Drain the notification pipe. */
+        uint8_t abBuf[8];
+        size_t cbIgnore;
+        int rc = RTPipeRead(pThread->hNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
+        if (RT_FAILURE(rc))
+            VBoxServiceError("ControlExec: Draining IPC notification pipe failed with rc=%Rrc\n", rc);
+
+        int rcReq = VINF_SUCCESS; /* Actual request result. */
+
+        PVBOXSERVICECTRLREQUEST pRequest = pThread->pRequest;
+        AssertPtr(pRequest);
+
+        switch (pRequest->enmType)
+        {
+            case VBOXSERVICECTRLREQUEST_QUIT: /* Main control asked us to quit. */
             {
-                rcReq = RTPipeWrite(*phStdInW,
-                                    pRequest->pvData, pRequest->cbData, &cbWritten);
+                /** @todo Check for some conditions to check to
+                 *        veto quitting. */
+                pThread->fShutdown = true;
+                rcReq = VINF_SUCCESS;
+                break;
             }
-            else
-                rcReq = VINF_EOF;
-
-            /* If this is the last write we need to close the stdin pipe on our
-             * end and remove it from the poll set. */
-            if (VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF == pRequest->enmType)
-                rc = VBoxServiceControlExecProcCloseStdIn(hPollSet, phStdInW);
-
-            /* Reqport back actual data written (if any). */
-            pRequest->cbData = cbWritten;
-            break;
-        }
-
-        case VBOXSERVICECTRLREQUEST_STDOUT_READ:
-            /* Fall through is intentional. */
-        case VBOXSERVICECTRLREQUEST_STDERR_READ:
-        {
-            AssertPtrReturn(pRequest->pvData, VERR_INVALID_POINTER);
-            AssertReturn(pRequest->cbData, VERR_INVALID_PARAMETER);
-
-            PRTPIPE pPipeR = pRequest->enmType == VBOXSERVICECTRLREQUEST_STDERR_READ
-                           ? phStdErrR : phStdOutR;
-            AssertPtr(pPipeR);
-
-            size_t cbRead = 0;
-            if (*pPipeR != NIL_RTPIPE)
+
+            case VBOXSERVICECTRLREQUEST_STDIN_WRITE:
+                /* Fall through is intentional. */
+            case VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF:
             {
-                rcReq = RTPipeRead(*pPipeR,
-                                   pRequest->pvData, pRequest->cbData, &cbRead);
-                if (rcReq == VERR_BROKEN_PIPE)
+                AssertPtrReturn(pRequest->pvData, VERR_INVALID_POINTER);
+                AssertReturn(pRequest->cbData, VERR_INVALID_PARAMETER);
+
+                size_t cbWritten = 0;
+                if (*phStdInW != NIL_RTPIPE)
+                {
+                    rcReq = RTPipeWrite(*phStdInW,
+                                        pRequest->pvData, pRequest->cbData, &cbWritten);
+                }
+                else
                     rcReq = VINF_EOF;
+
+                /* If this is the last write we need to close the stdin pipe on our
+                 * end and remove it from the poll set. */
+                if (VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF == pRequest->enmType)
+                    rc = VBoxServiceControlThreadCloseStdIn(hPollSet, phStdInW);
+
+                /* Reqport back actual data written (if any). */
+                pRequest->cbData = cbWritten;
+                break;
             }
-            else
-                rcReq = VINF_EOF;
-
-            /* Report back actual data read (if any). */
-            pRequest->cbData = cbRead;
-            break;
-        }
-
-        default:
-            rcReq = VERR_INVALID_PARAMETER;
-            break;
-    }
-
-    pRequest->rc = RT_SUCCESS(rc)
-                 ? rcReq : rc;
-
-    VBoxServiceVerbose(4, "ControlExec: Handled IPC request with rcReq=%Rrc, enmType=%u, cbData=%u\n",
-                       rcReq, pRequest->enmType, pRequest->cbData);
+
+            case VBOXSERVICECTRLREQUEST_STDOUT_READ:
+                /* Fall through is intentional. */
+            case VBOXSERVICECTRLREQUEST_STDERR_READ:
+            {
+                AssertPtrReturn(pRequest->pvData, VERR_INVALID_POINTER);
+                AssertReturn(pRequest->cbData, VERR_INVALID_PARAMETER);
+
+                PRTPIPE pPipeR = pRequest->enmType == VBOXSERVICECTRLREQUEST_STDERR_READ
+                               ? phStdErrR : phStdOutR;
+                AssertPtr(pPipeR);
+
+                size_t cbRead = 0;
+                if (*pPipeR != NIL_RTPIPE)
+                {
+                    rcReq = RTPipeRead(*pPipeR,
+                                       pRequest->pvData, pRequest->cbData, &cbRead);
+                    if (rcReq == VERR_BROKEN_PIPE)
+                        rcReq = VINF_EOF;
+                }
+                else
+                    rcReq = VINF_EOF;
+
+                /* Report back actual data read (if any). */
+                pRequest->cbData = cbRead;
+                break;
+            }
+
+            default:
+                rcReq = VERR_NOT_IMPLEMENTED;
+                break;
+        }
+
+        /* Assign overall result. */
+        pRequest->rc = RT_SUCCESS(rc)
+                     ? rcReq : rc;
+
+        VBoxServiceVerbose(4, "ControlExec: Handled IPC request with rcReq=%Rrc, enmType=%u, cbData=%u\n",
+                           rcReq, pRequest->enmType, pRequest->cbData);
+
+        /* In any case, regardless of the result, we notify
+         * the main guest control to unblock it. */
+        int rc2 = RTSemEventMultiSignal(pThread->RequestEvent);
+        AssertRC(rc2);
+        /* No access to pRequest here anymore -- could be out of scope
+         * or modified already! */
+
+        rc2 = RTCritSectLeave(&pThread->CritSect);
+        AssertRC(rc2);
+    }
+
     return rc;
 }
@@ -426 +469 @@
  * @param   hStdErrR                    Handle to the process' stderr read end.
  */
-static int VBoxServiceControlExecProcLoop(PVBOXSERVICECTRLTHREAD pThread,
-                                          RTPROCESS hProcess, RTMSINTERVAL cMsTimeout, RTPOLLSET hPollSet,
-                                          PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR)
+static int VBoxServiceControlThreadProcLoop(PVBOXSERVICECTRLTHREAD pThread,
+                                            RTPROCESS hProcess, RTMSINTERVAL cMsTimeout, RTPOLLSET hPollSet,
+                                            PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR)
 {
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
@@ -452 +495 @@
      * the first (stale) entry will be found and we get really weird results!
      */
-    rc = vboxServiceControlExecThreadAssignPID(pThread, hProcess);
+    rc = vboxServiceControlThreadAssignPID(pThread, hProcess);
     if (RT_FAILURE(rc))
     {
@@ -493 +536 @@
             {
                 case VBOXSERVICECTRLPIPEID_STDIN:
-                    rc = VBoxServiceControlExecProcHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW);
+                    rc = VBoxServiceControlThreadHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW);
                     break;
 
                 case VBOXSERVICECTRLPIPEID_STDOUT:
-                    rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt,
-                                                                     phStdOutR, idPollHnd);
+                    rc = VBoxServiceControlThreadHandleOutputEvent(hPollSet, fPollEvt,
+                                                                   phStdOutR, idPollHnd);
                     break;
 
                 case VBOXSERVICECTRLPIPEID_STDERR:
-                    rc = VBoxServiceControlExecProcHandleOutputEvent(hPollSet, fPollEvt,
-                                                                     phStdErrR, idPollHnd);
+                    rc = VBoxServiceControlThreadHandleOutputEvent(hPollSet, fPollEvt,
+                                                                   phStdErrR, idPollHnd);
                     break;
 
                 case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
-                    rc = VBoxServiceControlExecProcHandleIPCNotify(hPollSet, fPollEvt,
-                                                                   &pThread->hNotificationPipeR);
-                    /* Fall through is intentional. */
-                default:
-                    /* Handle IPC requests. */
-                    if (RT_SUCCESS(rc))
-                    {
-                        rc = VBoxServiceControlExecHandleIPCRequest(hPollSet, fPollEvt,
-                                                                    phStdInW, phStdOutR, phStdErrR,
-                                                                    pThread->pRequest);
-                    }
-
-                    /* If we were asked to terminate do so ... */
-                    if (pThread->pRequest->enmType == VBOXSERVICECTRLREQUEST_QUIT)
-                        rc = VINF_EOF;
-
-                    /* In any case, regardless of the result, we notify
-                     * the main guest control to unblock it. */
-                    rc2 = RTSemEventMultiSignal(pThread->RequestEvent);
-                    AssertRC(rc2);
-                    /* No access to pRequest here anymore -- could be out of scope
-                     * or modified already! */
+                    rc = VBoxServiceControlThreadHandleIPCRequest(hPollSet, fPollEvt,
+                                                                  phStdInW,phStdOutR,phStdErrR, pThread);
                     break;
             }
+
             if (RT_FAILURE(rc) || rc == VINF_EOF)
                 break; /* Abort command, or client dead or something. */
 
-            /* Only notification pipe left? Then there's nothing to poll for anymore really.
-             * Bail out .. */
+            if (RT_UNLIKELY(pThread->fShutdown))
+                break; /* We were asked to shutdown. */
+
+            /* Do we have more to poll for (e.g. is there (still) something in our pollset
+             * like stdout, stderr or stdin)? If we only have our notification pipe left we
+             * need to bail out. */
             if (RTPollSetGetCount(hPollSet) > 1)
                 continue;
@@ -655 +683 @@
     if (RT_SUCCESS(rc))
     {
-        /* Mark this thread as stopped and do some action required for stopping ... */
-        //VBoxServiceControlExecThreadCleanup(pThread);
-
         uint32_t uStatus = PROC_STS_UNDEFINED;
         uint32_t uFlags = 0;
@@ -718 +743 @@
                                pThread->uPID, ProcessStatus.enmReason);
 
+        VBoxServiceVerbose(3, "ControlExec: [PID %u]: Sending final status, ClientID=%u, CID=%u, Status=%u, Flags=0x%x\n",
+                           pThread->uPID, pThread->uClientID, pThread->uContextID, uStatus, uFlags);
         rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
                                              pThread->uPID, uStatus, uFlags,
@@ -724 +751 @@
             VBoxServiceError("ControlExec: [PID %u]: Error reporting final status to host; rc=%Rrc\n",
                              pThread->uPID, rc);
-
-        VBoxServiceVerbose(3, "ControlExec: [PID %u]: Ended, CID=%u, Status=%u, Flags=%u\n",
-                           pThread->uPID, pThread->uContextID, uStatus, uFlags);
 
         VBoxServiceVerbose(3, "ControlExec: [PID %u]: Process loop ended with rc=%Rrc\n",
@@ -751 +775 @@
  *                              should service.  Always set.
  */
-static int VBoxServiceControlExecSetupPipe(int fd, PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
+static int VBoxServiceControlThreadSetupPipe(int fd, PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
 {
     AssertPtrReturn(ph, VERR_INVALID_PARAMETER);
@@ -798 +822 @@
  * @param   cbExpanded                  Size (in bytes) of string to store the resolved path.
  */
-static int VBoxServiceControlExecMakeFullPath(const char *pszPath, char *pszExpanded, size_t cbExpanded)
+static int VBoxServiceControlThreadMakeFullPath(const char *pszPath, char *pszExpanded, size_t cbExpanded)
 {
     int rc = VINF_SUCCESS;
@@ -825 +849 @@
  * @param   cbResolved                  Size (in bytes) of resolved file name string.
  */
-static int VBoxServiceControlExecResolveExecutable(const char *pszFileName, char *pszResolved, size_t cbResolved)
+static int VBoxServiceControlThreadResolveExecutable(const char *pszFileName, char *pszResolved, size_t cbResolved)
 {
     int rc = VINF_SUCCESS;
@@ -844 +868 @@
         AssertPtr(pszExecResolved);
 
-        rc = VBoxServiceControlExecMakeFullPath(pszExecResolved, pszResolved, cbResolved);
+        rc = VBoxServiceControlThreadMakeFullPath(pszExecResolved, pszResolved, cbResolved);
 #ifdef DEBUG
         VBoxServiceVerbose(3, "ControlExec: VBoxServiceControlExecResolveExecutable: %s -> %s\n",
@@ -865 +889 @@
  *                          Needs to be freed with RTGetOptArgvFree.
  */
-static int VBoxServiceControlExecPrepareArgv(const char *pszArgv0,
-                                             const char * const *papszArgs, char ***ppapszArgv)
+static int VBoxServiceControlThreadPrepareArgv(const char *pszArgv0,
+                                               const char * const *papszArgs, char ***ppapszArgv)
 {
 /** @todo RTGetOptArgvToString converts to MSC quoted string, while
@@ -920 +944 @@
  *                                      successful process start.
  */
-static int VBoxServiceControlExecCreateProcess(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,
-                                               PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser,
-                                               const char *pszPassword, PRTPROCESS phProcess)
+static int VBoxServiceControlThreadCreateProcess(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,
+                                                 PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser,
+                                                 const char *pszPassword, PRTPROCESS phProcess)
 {
     AssertPtrReturn(pszExec, VERR_INVALID_PARAMETER);
@@ -960 +984 @@
         {
             char **papszArgsExp;
-            rc = VBoxServiceControlExecPrepareArgv(szSysprepCmd /* argv0 */, papszArgs, &papszArgsExp);
+            rc = VBoxServiceControlThreadPrepareArgv(szSysprepCmd /* argv0 */, papszArgs, &papszArgsExp);
             if (RT_SUCCESS(rc))
             {
@@ -978 +1002 @@
         /* We want to use the internal toolbox (all internal
          * tools are starting with "vbox_" (e.g. "vbox_cat"). */
-        rc = VBoxServiceControlExecResolveExecutable(VBOXSERVICE_NAME, szExecExp, sizeof(szExecExp));
+        rc = VBoxServiceControlThreadResolveExecutable(VBOXSERVICE_NAME, szExecExp, sizeof(szExecExp));
     }
     else
@@ -986 +1010 @@
          * Do the environment variables expansion on executable and arguments.
          */
-        rc = VBoxServiceControlExecResolveExecutable(pszExec, szExecExp, sizeof(szExecExp));
+        rc = VBoxServiceControlThreadResolveExecutable(pszExec, szExecExp, sizeof(szExecExp));
 #ifdef VBOXSERVICE_TOOLBOX
     }
@@ -993 +1017 @@
     {
         char **papszArgsExp;
-        rc = VBoxServiceControlExecPrepareArgv(pszExec /* Always use the unmodified executable name as argv0. */,
-                                               papszArgs /* Append the rest of the argument vector (if any). */, &papszArgsExp);
+        rc = VBoxServiceControlThreadPrepareArgv(pszExec /* Always use the unmodified executable name as argv0. */,
+                                                 papszArgs /* Append the rest of the argument vector (if any). */, &papszArgsExp);
         if (RT_SUCCESS(rc))
         {
@@ -1039 +1063 @@
  * @param   PVBOXSERVICECTRLTHREAD         Thread data associated with a started process.
  */
-static DECLCALLBACK(int) VBoxServiceControlExecProcessWorker(PVBOXSERVICECTRLTHREAD pThread)
+static DECLCALLBACK(int) VBoxServiceControlThreadProcessWorker(PVBOXSERVICECTRLTHREAD pThread)
 {
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
@@ -1051 +1075 @@
         return rc;
     }
+    VBoxServiceVerbose(3, "ControlExec: Guest process \"%s\" got client ID=%u\n",
+                       pThread->pszCmd, pThread->uClientID);
 
     bool fSignalled = false; /* Indicator whether we signalled the thread user event already. */
@@ -1076 +1102 @@
             RTHANDLE    hStdIn;
             PRTHANDLE   phStdIn;
-            rc = VBoxServiceControlExecSetupPipe(0 /*STDIN_FILENO*/, &hStdIn, &phStdIn, &pThread->pipeStdInW);
+            rc = VBoxServiceControlThreadSetupPipe(0 /*STDIN_FILENO*/, &hStdIn, &phStdIn, &pThread->pipeStdInW);
             if (RT_SUCCESS(rc))
             {
@@ -1082 +1108 @@
                 PRTHANDLE   phStdOut;
                 RTPIPE      hStdOutR;
-                rc = VBoxServiceControlExecSetupPipe(1 /*STDOUT_FILENO*/, &hStdOut, &phStdOut, &hStdOutR);
+                rc = VBoxServiceControlThreadSetupPipe(1 /*STDOUT_FILENO*/, &hStdOut, &phStdOut, &hStdOutR);
                 if (RT_SUCCESS(rc))
                 {
@@ -1088 +1114 @@
                     PRTHANDLE   phStdErr;
                     RTPIPE      hStdErrR;
-                    rc = VBoxServiceControlExecSetupPipe(2 /*STDERR_FILENO*/, &hStdErr, &phStdErr, &hStdErrR);
+                    rc = VBoxServiceControlThreadSetupPipe(2 /*STDERR_FILENO*/, &hStdErr, &phStdErr, &hStdErrR);
                     if (RT_SUCCESS(rc))
                     {
@@ -1117 +1143 @@
                             {
                                 RTPROCESS hProcess;
-                                rc = VBoxServiceControlExecCreateProcess(pThread->pszCmd, pThread->papszArgs, hEnv, pThread->uFlags,
-                                                                         phStdIn, phStdOut, phStdErr,
-                                                                         pThread->pszUser, pThread->pszPassword,
-                                                                         &hProcess);
+                                rc = VBoxServiceControlThreadCreateProcess(pThread->pszCmd, pThread->papszArgs, hEnv, pThread->uFlags,
+                                                                           phStdIn, phStdOut, phStdErr,
+                                                                           pThread->pszUser, pThread->pszPassword,
+                                                                           &hProcess);
                                 if (RT_FAILURE(rc))
                                     VBoxServiceError("ControlExec: Error starting process, rc=%Rrc\n", rc);
@@ -1147 +1173 @@
 
                                     /* Enter the process loop. */
-                                    rc = VBoxServiceControlExecProcLoop(pThread,
-                                                                        hProcess, pThread->uTimeLimitMS, hPollSet,
-                                                                        &pThread->pipeStdInW, &hStdOutR, &hStdErrR);
-
-                                    /* Before cleaning up everything else, remove the thread from our thread list. */
+                                    rc = VBoxServiceControlThreadProcLoop(pThread,
+                                                                          hProcess, pThread->uTimeLimitMS, hPollSet,
+                                                                          &pThread->pipeStdInW, &hStdOutR, &hStdErrR);
+
+                                    /*
+                                     * Remove thread from global thread list. After this it's safe to shutdown
+                                     * and deallocate this thread.
+                                     */
                                     VBoxServiceControlRemoveThread(pThread);
 
@@ -1207 +1236 @@
     }
 
+    if (pThread->uClientID)
+    {
+        VBoxServiceVerbose(3, "ControlExec: [PID %u]: Cancelling pending waits (client ID=%u)\n",
+                           pThread->uPID, pThread->uClientID);
+        int rc2 = VbglR3GuestCtrlCancelPendingWaits(pThread->uClientID);
+        if (RT_FAILURE(rc2))
+        {
+            VBoxServiceError("ControlExec: [PID %u]: Cancelling pending waits failed; rc=%Rrc\n",
+                             pThread->uPID, rc2);
+            if (RT_SUCCESS(rc))
+                rc = rc2;
+        }
+
+        /* Disconnect from guest control service. */
+        VbglR3GuestCtrlDisconnect(pThread->uClientID);
+        pThread->uClientID = 0;
+    }
+
     VBoxServiceVerbose(3, "ControlExec: [PID %u]: Thread of process \"%s\" ended with rc=%Rrc\n",
                        pThread->uPID, pThread->pszCmd, rc);
 
-    /* Disconnect from guest control service. */
-    VbglR3GuestCtrlDisconnect(pThread->uClientID);
-    pThread->uClientID = 0;
-
     ASMAtomicXchgBool(&pThread->fStarted, false);
-    ASMAtomicXchgBool(&pThread->fStopped, true);
-
-    int rc2 = VBoxServiceControlExecThreadShutdown(pThread);
-    if (RT_SUCCESS(rc2))
-        VBoxServiceControlExecThreadDestroy(pThread);
 
     /*
@@ -1228 +1266 @@
         RTThreadUserSignal(RTThreadSelf());
 
+    int rc2 = vboxServiceControlThreadShutdown(pThread);
+    if (RT_SUCCESS(rc))
+        rc = rc2;
+
     return rc;
 }
@@ -1240 +1282 @@
  *
  */
-static DECLCALLBACK(int) VBoxServiceControlExecThread(RTTHREAD ThreadSelf, void *pvUser)
+static DECLCALLBACK(int) VBoxServiceControlThread(RTTHREAD ThreadSelf, void *pvUser)
 {
     PVBOXSERVICECTRLTHREAD pThread = (VBOXSERVICECTRLTHREAD*)pvUser;
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
-    return VBoxServiceControlExecProcessWorker(pThread);
+    return VBoxServiceControlThreadProcessWorker(pThread);
 }
 
@@ -1299 +1341 @@
             AssertMsgFailed(("Unable to create unique control exec thread name!\n"));
 
-        rc = RTThreadCreate(&pThread->Thread, VBoxServiceControlExecThread,
+        rc = RTThreadCreate(&pThread->Thread, VBoxServiceControlThread,
                             (void *)(PVBOXSERVICECTRLTHREAD*)pThread, 0,
                             RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, szThreadName);
@@ -1313 +1355 @@
             /* Wait for the thread to initialize. */
             RTThreadUserWait(pThread->Thread, 60 * 1000 /* 60 seconds max. */);
-            if (pThread->fShutdown)
+            if (ASMAtomicReadBool(&pThread->fShutdown))
             {
                 VBoxServiceError("ControlExec: Thread for process \"%s\" failed to start!\n", pszCmd);
@@ -1343 +1385 @@
  * @param   uPID           PID to assign to the specified guest control execution thread.
  */
-int vboxServiceControlExecThreadAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID)
+int vboxServiceControlThreadAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID)
 {
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
@@ -1360 +1402 @@
         VBoxServiceVerbose(3, "ControlExec: PID %u was used before, shutting down stale exec thread ...\n",
                            uPID);
-        rc = VBoxServiceControlExecThreadShutdown(pOldThread);
+        rc = vboxServiceControlThreadShutdown(pOldThread);
         if (RT_FAILURE(rc))
         {
@@ -1376 +1418 @@
 
 /**
- * TODO
+ * Performs a request to a specific (formerly started) guest process and waits
+ * for its response.
  *
  * @return  IPRT status code.
- * @return  int
- * @param   uPID
- * @param   pRequest
- */
-int VBoxServiceControlExecThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest)
+ * @param   uPID                PID of guest process to perform a request to.
+ * @param   pRequest            Pointer to request  to perform.
+ */
+int VBoxServiceControlThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest)
 {
     AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
@@ -1389 +1431 @@
     /* Rest in pRequest is optional (based on the request type). */
 
-    VBoxServiceVerbose(4, "ControlExec: [PID %u]: Performing enmType=%u, pvData=0x%p, cbData=%u ...\n",
+    VBoxServiceVerbose(4, "ControlExec: Performing PID=%u, enmType=%u, pvData=0x%p, cbData=%u ...\n",
                        uPID, pRequest->enmType, pRequest->pvData, pRequest->cbData);
 
     int rc;
     const PVBOXSERVICECTRLTHREAD pThread = VBoxServiceControlGetThreadByPID(uPID);
-    if (pThread)
+    if (   pThread
+        && !ASMAtomicReadBool(&pThread->fStopped))
     {
         rc = RTCritSectEnter(&pThread->CritSect);
@@ -1402 +1445 @@
             pThread->pRequest = pRequest;
 
-            /** @todo To speed up simultaneous guest process handling we could add a worker threads in order
-             *        to wait for the request to happen. Later. */
+            /** @todo To speed up simultaneous guest process handling we could add a worker threads
+             *        or queue in order to wait for the request to happen. Later. */
 
             /* Wake up guest thrad by sending a wakeup byte to the notification pipe so
@@ -1412 +1455 @@
             if (RT_SUCCESS(rc))
                 rc = RTPipeWrite(pThread->hNotificationPipeW, "i", 1, &cbWritten);
+
+            /* Make sure we leave the critical section before doing the wait. */
+            int rc2 = RTCritSectLeave(&pThread->CritSect);
+            AssertRCReturn(rc2, rc2);
+
             if (RT_SUCCESS(rc) && cbWritten)
             {
+                VBoxServiceVerbose(4, "ControlExec: [PID %u]: Waiting for response on enmType=%u, pvData=0x%p, cbData=%u\n",
+                                   uPID, pRequest->enmType, pRequest->pvData, pRequest->cbData);
                 /* Wait on the request to get completed (or we are asked to abort/shutdown). */
                 rc = RTSemEventMultiWait(pThread->RequestEvent, RT_INDEFINITE_WAIT);
@@ -1421 +1471 @@
                                        uPID, pRequest->rc, pRequest->cbData);
 
-                    /* Give back overall request result. */
-                    rc = pRequest->rc;
-
-                    /* Reset the semaphore. */
-                    int rc2 = RTSemEventMultiReset(pThread->RequestEvent);
-                    if (RT_FAILURE(rc2))
-                        VBoxServiceError("ControlExec: Unable to reset request event, rc=%Rrc\n", rc2);
+                    rc = RTCritSectEnter(&pThread->CritSect);
+                    if (RT_SUCCESS(rc))
+                    {
+                        /* Give back overall request result. */
+                        rc = pRequest->rc;
+
+                        /* Reset the semaphore. */
+                        rc2 = RTSemEventMultiReset(pThread->RequestEvent);
+                        if (RT_FAILURE(rc2))
+                            VBoxServiceError("ControlExec: Unable to reset request event, rc=%Rrc\n", rc2);
+
+                        rc2 = RTCritSectLeave(&pThread->CritSect);
+                        AssertRCReturn(rc2, rc2);
+                    }
                 }
             }
-
-            int rc2 = RTCritSectLeave(&pThread->CritSect);
-            AssertRCReturn(rc2, rc2);
         }
     }
@@ -1438 +1492 @@
         rc = VERR_NOT_FOUND;
 
-    VBoxServiceVerbose(4, "ControlExec: [PID %u]: Performed enmType=%u, pvData=0x%p, cbData=%u with rc=%Rrc\n",
+    VBoxServiceVerbose(4, "ControlExec: Performed PID=%u, enmType=%u, pvData=0x%p, cbData=%u with rc=%Rrc\n",
                        uPID, pRequest->enmType, pRequest->pvData, pRequest->cbData, rc);
     return rc;
@@ -1445 +1499 @@
 
 /**
- * Removes the guest thread from the global guest thread list and finally
- * destroys it. Does not do locking, must be done by the caller!
- *
- * @param   pThread                 Thread to destroy.
- */
-void VBoxServiceControlExecThreadDestroy(PVBOXSERVICECTRLTHREAD pThread)
-{
-    if (!pThread)
-        return;
-
+ * Shuts down a guest thread.
+ *
+ * @return  IPRT status code.
+ * @param   pThread                 Thread to shut down.
+ */
+static int vboxServiceControlThreadShutdown(PVBOXSERVICECTRLTHREAD pThread)
+{
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+
+    int rc = RTCritSectEnter(&pThread->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        VBoxServiceVerbose(3, "ControlExec: [PID %u]: Shutting down ...\n",
+                           pThread->uPID);
+
+        /*
+         * Destroy thread-specific data.
+         */
+        vboxServiceControlThreadFree(pThread);
+
+        /* Set stopped status. */
+        ASMAtomicXchgBool(&pThread->fStopped, true);
+
+        rc = RTCritSectLeave(&pThread->CritSect);
+    }
+
+    /*
+     * Destroy other thread data.
+     */
     if (RTCritSectIsInitialized(&pThread->CritSect))
         RTCritSectDelete(&pThread->CritSect);
 
-    /* Destroy thread structure as final step. */
+    /*
+     * Destroy thread structure as final step.
+     */
     RTMemFree(pThread);
     pThread = NULL;
-}
-
-
-/**
- * Shuts down a guest thread.
- * Does not do locking, must be done by the caller!
- *
- * @return  IPRT status code.
- * @param   pThread                 Thread to shut down.
- */
-int VBoxServiceControlExecThreadShutdown(PVBOXSERVICECTRLTHREAD pThread)
-{
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
-
-    if (ASMAtomicReadBool(&pThread->fShutdown)) /* Already shut down. */
-        return VINF_SUCCESS;
-
-    /* First, signal shut down. */
-    VBoxServiceControlThreadSignalShutdown(pThread);
-
-    /*
-     * Wait for thread to shutdown.
-     */
-    VBoxServiceVerbose(2, "ControlExec: [PID %u]: Waitng for shutting down ...\n",
-                       pThread->uPID);
-    int rc;
-    for (int i = 0; i < 3; i++)
-    {
-        rc = vboxServiceControlThreadWaitForShutdown(pThread);
-        if (RT_SUCCESS(rc))
-            break;
-
-        VBoxServiceError("ControlExec: [PID %u]: Attempt #%d: Waiting for shutdown failed with rc=%Rrc ...\n",
-                         pThread->uPID, i + 1, rc);
-        RTThreadSleep(500); /* Wait a bit before next try. */
-    }
-
-    /* Do not destroy critical section here! */
-
-    /*
-     * Destroy thread-specific data.
-     */
-    vboxServiceControlExecThreadFree(pThread);
-
-    return rc;
-}
-
+
+    return rc;
+}
+

trunk/src/VBox/Additions/common/VBoxService/VBoxServiceInternal.h

@@ -143 +143 @@
      *  marks the end of input. */
     VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF  = 71,
-    /** Kill process.
+    /** Kill/terminate process.
      *  @todo Implement this! */
     VBOXSERVICECTRLREQUEST_KILL             = 90,
     /** Gently ask process to terminate.
      *  @todo Implement this! */
-    VBOXSERVICECTRLREQUEST_HANGUP           = 91
+    VBOXSERVICECTRLREQUEST_HANGUP           = 91,
+    /** Ask the process in which status it
+     *  currently is.
+     *  @todo Implement this! */
+    VBOXSERVICECTRLREQUEST_STATUS           = 100
 } VBOXSERVICECTRLREQUESTTYPE;
 
@@ -161 +165 @@
     /** The request type to handle. */
     VBOXSERVICECTRLREQUESTTYPE enmType;
-    /** On input, this contains the (maximum) amount
-     *  of buffered data to read or write. On output,
+    /** Payload size; on input, this contains the (maximum) amount
+     *  of data the caller  wants to write or to read. On output,
      *  this show the actual amount of data read/written. */
     size_t                     cbData;
-    /** The provided, allocated data buffer for input/output. */
+    /** Payload data; a pre-allocated data buffer for input/output. */
     void                      *pvData;
     /** The overall result of the operation. */
@@ -334 +338 @@
                                                   const char *pszUser, const char *pszPassword, uint32_t uTimeLimitMS,
                                                   PRTLISTNODE *ppNode);
-extern void         VBoxServiceControlThreadSignalShutdown(const PVBOXSERVICECTRLTHREAD pThread);
+int                 VBoxServiceControlThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest);
+extern int          VBoxServiceControlThreadSignalShutdown(const PVBOXSERVICECTRLTHREAD pThread);
+extern int          VBoxServiceControlThreadWaitForShutdown(const PVBOXSERVICECTRLTHREAD pThread, RTMSINTERVAL msTimeout);
 #endif /* VBOX_WITH_GUEST_CONTROL */