Changeset 39418 in vbox for trunk/src/VBox/Additions/common/VBoxService

Timestamp:

Nov 25, 2011 10:11:06 AM (13 years ago)

Author:

vboxsync

Message:

GuestCtrl: Added support for explicitly waiting on stdout/stderr, bugfixes, logging adjustments.

Location:

trunk/src/VBox/Additions/common/VBoxService

Files:

• VBoxServiceControl.cpp (modified) (16 diffs)
• VBoxServiceControlThread.cpp (modified) (48 diffs)
• VBoxServiceInternal.h (modified) (4 diffs)

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

@@ -314 +314 @@
             /* Tell the host. */
             rc = VbglR3GuestCtrlExecReportStatus(uClientID, uContextID, 0 /* PID, invalid. */,
-                                                 PROC_STS_ERROR, VERR_MAX_PROCS_REACHED,
+                                                 PROC_STS_ERROR,
+                                                 !fAllowed ? VERR_MAX_PROCS_REACHED : rc,
                                                  NULL /* pvData */, 0 /* cbData */);
         }
@@ -335 +336 @@
  * @param   pcbRead                 Pointer to number of bytes read.  Optional.
  */
-int VBoxServiceControlExecGetOutput(uint32_t uPID, uint32_t uHandleId, uint32_t uTimeout,
+int VBoxServiceControlExecGetOutput(uint32_t uPID, uint32_t uCID,
+                                    uint32_t uHandleId, uint32_t uTimeout,
                                     void *pvBuf, uint32_t cbBuf, uint32_t *pcbRead)
 {
@@ -345 +347 @@
 
     VBOXSERVICECTRLREQUEST ctrlRequest;
+    ctrlRequest.uCID   = uCID;
     ctrlRequest.cbData = cbBuf;
     ctrlRequest.pvData = (uint8_t*)pvBuf;
@@ -389 +392 @@
  * @param   pcbWritten              Pointer to number of bytes written to the process.  Optional.
  */
-int VBoxServiceControlSetInput(uint32_t uPID, bool fPendingClose,
+int VBoxServiceControlSetInput(uint32_t uPID, uint32_t uCID,
+                               bool fPendingClose,
                                void *pvBuf, uint32_t cbBuf,
                                uint32_t *pcbWritten)
@@ -400 +404 @@
 
     VBOXSERVICECTRLREQUEST ctrlRequest;
+    ctrlRequest.uCID    = uCID;
     ctrlRequest.cbData  = cbBuf;
     ctrlRequest.pvData  = pvBuf;
@@ -470 +475 @@
         }
 
-        rc = VBoxServiceControlSetInput(uPID, fPendingClose, pabBuffer,
+        rc = VBoxServiceControlSetInput(uPID, uContextID, fPendingClose, pabBuffer,
                                         cbSize, &cbWritten);
-        VBoxServiceVerbose(4, "Control: [PID %u]: Written input, rc=%Rrc, uFlags=0x%x, fPendingClose=%d, cbSize=%u, cbWritten=%u\n",
-                           uPID, rc, uFlags, fPendingClose, cbSize, cbWritten);
+        VBoxServiceVerbose(4, "Control: [PID %u]: Written input, CID=%u, rc=%Rrc, uFlags=0x%x, fPendingClose=%d, cbSize=%u, cbWritten=%u\n",
+                           uPID, uContextID, rc, uFlags, fPendingClose, cbSize, cbWritten);
         if (RT_SUCCESS(rc))
         {
@@ -543 +548 @@
         if (pBuf)
         {
-            rc = VBoxServiceControlExecGetOutput(uPID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
+            rc = VBoxServiceControlExecGetOutput(uPID, uContextID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
                                                  pBuf, _64K /* cbSize */, &cbRead);
+
+            /** Note: Don't convert/touch/modify/whatever the output data here! This might be binary
+             *        data which the host needs to work with -- so just pass through all data unfiltered! */
+
             if (RT_SUCCESS(rc))
-                VBoxServiceVerbose(3, "Control: [PID %u]: Got output, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
+                VBoxServiceVerbose(2, "Control: Got output, PID=%u, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
                                    uPID, uContextID, cbRead, uHandleID, uFlags);
+            else if (rc == VERR_NOT_FOUND)
+                VBoxServiceVerbose(2, "Control: PID=%u not found, CID=%u, uHandle=%u\n",
+                                   uPID, uContextID, uHandleID, rc);
             else
-                VBoxServiceError("Control: [PID %u]: Failed to retrieve output, CID=%u, uHandle=%u, rc=%Rrc\n",
+                VBoxServiceError("Control: Failed to retrieve output for PID=%u, CID=%u, uHandle=%u, rc=%Rrc\n",
                                  uPID, uContextID, uHandleID, rc);
             /* Note: Since the context ID is unique the request *has* to be completed here,
@@ -598 +610 @@
 
 
+/**
+ * Destroys all guest process threads which are still active.
+ */
 static void VBoxServiceControlDestroyThreads(void)
 {
-    VBoxServiceVerbose(3, "Control: Destroying threads ...\n");
+    VBoxServiceVerbose(2, "Control: Destroying threads ...\n");
 
     /* Signal all threads that we want to shutdown. */
@@ -625 +640 @@
     }
 
+#ifdef DEBUG
+        PVBOXSERVICECTRLTHREAD pThreadCur;
+        uint32_t cThreads = 0;
+        RTListForEach(&g_GuestControlThreads, pThreadCur, VBOXSERVICECTRLTHREAD, Node)
+            cThreads++;
+        VBoxServiceVerbose(4, "Control: Guest process threads left=%u\n", cThreads);
+#endif
     AssertMsg(RTListIsEmpty(&g_GuestControlThreads),
               ("Guest process thread list still contains children when it should not\n"));
@@ -680 +702 @@
             RTListForEach(&g_GuestControlThreads, pThread, VBOXSERVICECTRLTHREAD, Node)
             {
-    // THREAD LOCKING!!
-                Assert(pThread->fStarted != pThread->fStopped);
-                if (pThread->fStarted)
+                VBOXSERVICECTRLTHREADSTATUS enmStatus = VBoxServiceControlThreadGetStatus(pThread);
+                if (enmStatus == VBOXSERVICECTRLTHREADSTATUS_STARTED)
                     uProcsRunning++;
-                else if (pThread->fStopped)
+                else if (enmStatus == VBOXSERVICECTRLTHREADSTATUS_STOPPED)
                     uProcsStopped++;
                 else
@@ -690 +711 @@
             }
 
-            VBoxServiceVerbose(2, "Control: Maximum served guest processes set to %u, running=%u, stopped=%u\n",
+            VBoxServiceVerbose(3, "Control: Maximum served guest processes set to %u, running=%u, stopped=%u\n",
                                g_GuestControlProcsMaxKept, uProcsRunning, uProcsStopped);
 
@@ -714 +735 @@
 
 /**
- * Finds a (formerly) started process given by its PID.
+ * Finds a (formerly) started process given by its PID and locks it. Must be unlocked
+ * by the caller with VBoxServiceControlThreadUnlock().
  *
  * @return  PVBOXSERVICECTRLTHREAD      Process structure if found, otherwise NULL.
  * @param   uPID                        PID to search for.
  */
-PVBOXSERVICECTRLTHREAD VBoxServiceControlGetThreadByPID(uint32_t uPID)
+const PVBOXSERVICECTRLTHREAD VBoxServiceControlGetThreadLocked(uint32_t uPID)
 {
     PVBOXSERVICECTRLTHREAD pThread = NULL;
@@ -730 +752 @@
             if (pThreadCur->uPID == uPID)
             {
-                pThread = pThreadCur;
+                rc = RTCritSectEnter(&pThreadCur->CritSect);
+                if (RT_SUCCESS(rc))
+                    pThread = pThreadCur;
                 break;
             }
@@ -745 +769 @@
 
 /**
+ * Unlocks a previously locked guest process thread.
+ *
+ * @param   pThread                 Thread to unlock.
+ */
+void VBoxServiceControlThreadUnlock(const PVBOXSERVICECTRLTHREAD pThread)
+{
+    AssertPtr(pThread);
+
+    int rc = RTCritSectLeave(&pThread->CritSect);
+    AssertRC(rc);
+}
+
+
+/**
+ * Assigns a valid PID to a guest control thread and also checks if there already was
+ * another (stale) guest process which was using that PID before and destroys it.
+ *
+ * @return  IPRT status code.
+ * @param   pThread        Thread to assign PID to.
+ * @param   uPID           PID to assign to the specified guest control execution thread.
+ */
+int VBoxServiceControlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID)
+{
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertReturn(uPID, VERR_INVALID_PARAMETER);
+
+    int rc = RTCritSectEnter(&g_GuestControlThreadsCritSect);
+    if (RT_SUCCESS(rc))
+    {
+        /* Search old threads using the desired PID and shut them down completely -- it's
+         * not used anymore. */
+        PVBOXSERVICECTRLTHREAD pThreadCur;
+        RTListForEach(&g_GuestControlThreads, pThreadCur, VBOXSERVICECTRLTHREAD, Node)
+        {
+            if (   pThreadCur->uPID == uPID
+                && pThreadCur       != pThread)
+            {
+                VBoxServiceVerbose(2, "ControlThread: PID %u was used before, shutting down stale exec thread ...\n",
+                                   uPID);
+                rc = VBoxServiceControlThreadSignalShutdown(pThreadCur);
+                if (RT_SUCCESS(rc))
+                    rc = VBoxServiceControlThreadWaitForShutdown(pThreadCur,
+                                                                 30 * 1000 /* Wait 30 seconds max. */);
+            }
+        }
+
+        /* Assign PID to current thread. */
+        pThread->uPID = uPID;
+
+        rc = RTCritSectLeave(&g_GuestControlThreadsCritSect);
+        AssertRC(rc);
+    }
+
+    return rc;
+}
+
+
+/**
  * Removes the specified guest process thread from the global thread
  * list.
@@ -751 +833 @@
  * @param   pThread             Thread to remove.
  */
-void VBoxServiceControlRemoveThread(PVBOXSERVICECTRLTHREAD pThread)
+void VBoxServiceControlRemoveThread(const PVBOXSERVICECTRLTHREAD pThread)
 {
     if (!pThread)
@@ -763 +845 @@
         RTListNodeRemove(&pThread->Node);
 
-        int rc2 = RTCritSectLeave(&g_GuestControlThreadsCritSect);
-        AssertRC(rc2);
+#ifdef DEBUG
+        PVBOXSERVICECTRLTHREAD pThreadCur;
+        uint32_t cThreads = 0;
+        RTListForEach(&g_GuestControlThreads, pThreadCur, VBOXSERVICECTRLTHREAD, Node)
+            cThreads++;
+        VBoxServiceVerbose(4, "Control: Guest process threads left=%u\n", cThreads);
+#endif
+        rc = RTCritSectLeave(&g_GuestControlThreadsCritSect);
+        AssertRC(rc);
     }
 }

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

@@ -42 +42 @@
 
 /* Internal functions. */
-static int vboxServiceControlThreadAssignPID(PVBOXSERVICECTRLTHREAD pData, uint32_t uPID);
-static void vboxServiceControlThreadFree(PVBOXSERVICECTRLTHREAD pData);
-static int vboxServiceControlThreadShutdown(PVBOXSERVICECTRLTHREAD pThread);
+static int vboxServiceControlThreadFree(PVBOXSERVICECTRLTHREAD pThread);
 
 /**
@@ -154 +152 @@
 
 /**
+ * Frees a guest thread.
+ *
+ * @return  IPRT status code.
+ * @param   pThread                 Thread to shut down.
+ */
+static int vboxServiceControlThreadFree(PVBOXSERVICECTRLTHREAD pThread)
+{
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+
+    VBoxServiceVerbose(1, "ControlThread: [PID %u]: Shutting down ...\n",
+                       pThread->uPID);
+
+    /* Signal the request event to unblock potential waiters. */
+    int rc = RTSemEventMultiSignal(pThread->RequestEvent);
+    if (RT_FAILURE(rc))
+        VBoxServiceError("ControlThread: [PID %u]: Signalling request event failed, rc=%Rrc\n",
+                         pThread->uPID, rc);
+
+    rc = RTCritSectEnter(&pThread->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        VBoxServiceVerbose(3, "ControlThread: [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);
+
+        rc = RTSemEventMultiDestroy(pThread->RequestEvent);
+        AssertRC(rc);
+
+        VBoxServiceVerbose(3, "ControlThread: [PID %u]: Cleaning up ...\n",
+                           pThread->uPID);
+
+        /* Set stopped status. */
+        ASMAtomicXchgBool(&pThread->fStopped, true);
+
+        rc = RTCritSectLeave(&pThread->CritSect);
+        AssertRC(rc);
+    }
+
+    /*
+     * Destroy other thread data.
+     */
+    if (RTCritSectIsInitialized(&pThread->CritSect))
+        RTCritSectDelete(&pThread->CritSect);
+
+    /*
+     * Destroy thread structure as final step.
+     */
+    RTMemFree(pThread);
+    pThread = NULL;
+
+    return rc;
+}
+
+
+/**
  * Signals a guest process thread that we want it to shut down in
  * a gentle way.
@@ -164 +227 @@
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
 
-    VBoxServiceVerbose(3, "ControlThead: [PID %u]: Signalling shutdown ...\n",
+    VBoxServiceVerbose(3, "ControlThread: [PID %u]: Signalling shutdown ...\n",
                        pThread->uPID);
 
@@ -176 +239 @@
     int rc = VBoxServiceControlThreadPerform(pThread->uPID, &ctrlRequest);
     if (RT_FAILURE(rc))
-        VBoxServiceVerbose(3, "ControlThead: [PID %u]: Sending quit request failed with rc=%Rrc\n",
+        VBoxServiceVerbose(3, "ControlThread: [PID %u]: Sending quit request failed with rc=%Rrc\n",
                            pThread->uPID, rc);
     return rc;
@@ -197 +260 @@
         && !ASMAtomicReadBool(&pThread->fStopped)) /* Only shutdown threads which aren't yet. */
     {
-        VBoxServiceVerbose(3, "ControlThead: [PID %u]: Waiting for shutdown ...\n",
+        VBoxServiceVerbose(2, "ControlThread: [PID %u]: Waiting for shutdown ...\n",
                            pThread->uPID);
 
@@ -205 +268 @@
         if (RT_FAILURE(rcThread))
         {
-            VBoxServiceError("ControlThead: [PID %u]: Shutdown returned error rc=%Rrc\n",
+            VBoxServiceError("ControlThread: [PID %u]: Shutdown returned error rc=%Rrc\n",
                              pThread->uPID, rcThread);
             if (RT_SUCCESS(rc))
@@ -216 +279 @@
 
 /**
- * Frees an allocated thread data structure along with all its allocated parameters.
- *
- * @param   pThread             Pointer to thread data to free.
- */
-static void vboxServiceControlThreadFree(const PVBOXSERVICECTRLTHREAD pThread)
-{
-    if (!pThread)
-        return;
-
-    VBoxServiceVerbose(3, "ControlThead: [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);
-    }
+ * Returns the guest process thread's current status.
+ *
+ * @return  VBOXSERVICECTRLTHREADSTATUS
+ * @param   pThread             Thread to determine current status for.
+ */
+VBOXSERVICECTRLTHREADSTATUS VBoxServiceControlThreadGetStatus(const PVBOXSERVICECTRLTHREAD pThread)
+{
+    AssertPtrReturn(pThread, VBOXSERVICECTRLTHREADSTATUS_UNKNOWN);
+
+    int rc = RTCritSectEnter(&pThread->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        Assert(pThread->fStarted != pThread->fStopped);
+
+        VBOXSERVICECTRLTHREADSTATUS enmStatus = VBOXSERVICECTRLTHREADSTATUS_UNKNOWN;
+        /** @todo Add more logic here. */
+        /** @todo Remove fStarted/fStopped and just use this VBOXSERVICECTRLTHREADSTATUS. */
+        if (pThread->fStarted)
+            enmStatus = VBOXSERVICECTRLTHREADSTATUS_STARTED;
+        else if (pThread->fStopped)
+            enmStatus = VBOXSERVICECTRLTHREADSTATUS_STOPPED;
+        else
+            AssertMsgFailed(("ControlThread: Uknown thread status (0x%x)\n"));
+
+        rc = RTCritSectLeave(&pThread->CritSect);
+        AssertRC(rc);
+
+        return enmStatus;
+    }
+
+    return VBOXSERVICECTRLTHREADSTATUS_UNKNOWN;
 }
 
@@ -294 +360 @@
  *
  */
+static int VBoxServiceControlThreadHandleOutputError(RTPOLLSET hPollSet, uint32_t fPollEvt,
+                                                     PRTPIPE phPipeR, uint32_t idPollHnd)
+{
+    int rc = VINF_SUCCESS;
+
+    rc = RTPollSetRemove(hPollSet, idPollHnd);
+    AssertRC(rc);
+
+    rc = RTPipeClose(*phPipeR);
+    AssertRC(rc);
+    *phPipeR = NIL_RTPIPE;
+
+    return rc;
+}
+
+
+/**
+ * Handle pending output data or error on standard out or standard error.
+ *
+ * @returns IPRT status code from client send.
+ * @param   hPollSet            The polling set.
+ * @param   fPollEvt            The event mask returned by RTPollNoResume.
+ * @param   phPipeR             The pipe handle.
+ * @param   idPollHnd           The pipe ID to handle.
+ *
+ */
 static int VBoxServiceControlThreadHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt,
                                                      PRTPIPE phPipeR, uint32_t idPollHnd)
 {
     int rc = VINF_SUCCESS;
-
-#if 0
-    if (fPollEvt & RTPOLL_EVT_READ)
-    {
-        /** @todo Later: Notify the host about the read operation! */
-
-        /* Make sure we go another poll round in case there was too much data
-           for the buffer to hold. */
-        fPollEvt &= RTPOLL_EVT_ERROR;
-
-        /* Remove read event from poll set and just poll for errors from now on.
-         * This is necessary for doing a RTPipeRead. */
-        rc = RTPollSetEventsChange(hPollSet, idPollHnd, RTPOLL_EVT_ERROR);
-        AssertRC(rc);
-    }
+    if (fPollEvt == RTPOLL_EVT_READ)
+    {
+        char abBuf[_64K];
+        size_t cbRead;
+        int rc = RTPipeRead(*phPipeR, abBuf, sizeof(abBuf), &cbRead);
+        if (RT_SUCCESS(rc) && cbRead)
+        {
+#ifdef DEBUG
+            VBoxServiceVerbose(4, "ControlThread: Drain idPollHnd=%u, abBuf=0x%p, cbRead=%u\n",
+                               idPollHnd, abBuf, cbRead);
 #endif
-
+            /* Goes to bit bucket ... */
+
+            /* Make sure we go another poll round in case there was too much data
+               for the buffer to hold. */
+            fPollEvt &= RTPOLL_EVT_ERROR;
+        }
+        else if (RT_FAILURE(rc))
+        {
+            fPollEvt |= RTPOLL_EVT_ERROR;
+            AssertMsg(rc == VERR_BROKEN_PIPE, ("%Rrc\n", rc));
+        }
+    }
+
+    if (fPollEvt & RTPOLL_EVT_ERROR)
+        rc = VBoxServiceControlThreadHandleOutputError(hPollSet, fPollEvt,
+                                                       phPipeR, idPollHnd);
+    return rc;
+}
+
+
+static int VBoxServiceControlThreadHandleRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
+                                                 PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
+                                                 PVBOXSERVICECTRLTHREAD pThread)
+{
 #ifdef DEBUG_andy
-    VBoxServiceVerbose(4, "ControlThead: HandleOutputEvent fPollEvt=0x%x, idPollHnd=%u\n",
-                       fPollEvt, idPollHnd);
-#endif
-
-    /*
-     * If an error was raised signalled
-     */
-    if (fPollEvt & RTPOLL_EVT_ERROR)
-    {
-        rc = RTPollSetRemove(hPollSet, idPollHnd);
-        AssertRC(rc);
-
-        rc = RTPipeClose(*phPipeR);
-        AssertRC(rc);
-        *phPipeR = NIL_RTPIPE;
-    }
-
-    return rc;
-}
-
-
-static int VBoxServiceControlThreadHandleIPCRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
-                                                    PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
-                                                    PVBOXSERVICECTRLTHREAD pThread)
-{
-#ifdef DEBUG_andy
-    VBoxServiceVerbose(4, "ControlThead: HandleIPCRequest\n");
+    VBoxServiceVerbose(4, "ControlThread: HandleIPCRequest\n");
 #endif
 
@@ -350 +434 @@
     AssertPtrReturn(phStdErrR, VERR_INVALID_POINTER);
 
-    int rc = RTCritSectEnter(&pThread->CritSect);
+    /*int rc = RTCritSectEnter(&pThread->CritSect);
     if (RT_SUCCESS(rc))
-    {
+    {*/
         /* Drain the notification pipe. */
         uint8_t abBuf[8];
@@ -358 +442 @@
         rc = RTPipeRead(pThread->hNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
         if (RT_FAILURE(rc))
-            VBoxServiceError("ControlThead: Draining IPC notification pipe failed with rc=%Rrc\n", rc);
+            VBoxServiceError("ControlThread: Draining IPC notification pipe failed with rc=%Rrc\n", rc);
 
         int rcReq = VINF_SUCCESS; /* Actual request result. */
@@ -438 +522 @@
                      ? rcReq : rc;
 
-        VBoxServiceVerbose(4, "ControlThead: Handled IPC request with rcReq=%Rrc, enmType=%u, cbData=%u\n",
-                           rcReq, pRequest->enmType, pRequest->cbData);
+        VBoxServiceVerbose(2, "ControlThread: [PID %u]: Handled req=%u, CID=%u, rcReq=%Rrc, cbData=%u\n",
+                           pThread->uPID, pRequest->enmType, pRequest->uCID, rcReq, pRequest->cbData);
 
         /* In any case, regardless of the result, we notify
@@ -448 +532 @@
          * or modified already! */
 
-        rc2 = RTCritSectLeave(&pThread->CritSect);
+        /*rc2 = RTCritSectLeave(&pThread->CritSect);
         AssertRC(rc2);
-    }
+    }*/
 
     return rc;
@@ -475 +559 @@
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdInW, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(phStdOutR, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(phStdErrR, VERR_INVALID_PARAMETER);
+    /* Rest is optional. */
 
     int                         rc;
@@ -495 +578 @@
      * the first (stale) entry will be found and we get really weird results!
      */
-    rc = vboxServiceControlThreadAssignPID(pThread, hProcess);
+    rc = VBoxServiceControlAssignPID(pThread, hProcess);
     if (RT_FAILURE(rc))
     {
-        VBoxServiceError("ControlThead: Unable to assign PID to new thread, rc=%Rrc\n", rc);
+        VBoxServiceError("ControlThread: Unable to assign PID=%u, to new thread, rc=%Rrc\n",
+                         hProcess, rc);
         return rc;
     }
@@ -506 +590 @@
      * and that it's now OK to send input to the process.
      */
-    VBoxServiceVerbose(3, "ControlThead: [PID %u]: Process started, CID=%u, User=%s\n",
-                       pThread->uPID, pThread->uContextID, pThread->pszUser);
+    VBoxServiceVerbose(2, "ControlThread: [PID %u]: Process \"%s\" started, CID=%u, User=%s\n",
+                       pThread->uPID, pThread->pszCmd, pThread->uContextID, pThread->pszUser);
     rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
                                          pThread->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
@@ -531 +615 @@
         if (RT_SUCCESS(rc2))
         {
-            /*VBoxServiceVerbose(4, "ControlThead: [PID %u}: RTPollNoResume idPollHnd=%u\n",
+            /*VBoxServiceVerbose(4, "ControlThread: [PID %u}: RTPollNoResume idPollHnd=%u\n",
                                  pThread->uPID, idPollHnd);*/
             switch (idPollHnd)
@@ -550 +634 @@
 
                 case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
-                    rc = VBoxServiceControlThreadHandleIPCRequest(hPollSet, fPollEvt,
-                                                                  phStdInW,phStdOutR,phStdErrR, pThread);
+                    rc = VBoxServiceControlThreadHandleRequest(hPollSet, fPollEvt,
+                                                               phStdInW, phStdOutR, phStdErrR, pThread);
                     break;
             }
@@ -608 +692 @@
             if (cMsElapsed >= cMsTimeout)
             {
-                VBoxServiceVerbose(3, "ControlThead: [PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...",
+                VBoxServiceVerbose(3, "ControlThread: [PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...",
                                    pThread->uPID, cMsElapsed, cMsTimeout);
 
@@ -644 +728 @@
         if (MsProcessKilled == UINT64_MAX)
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Is still alive and not killed yet\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Is still alive and not killed yet\n",
                                pThread->uPID);
 
@@ -654 +738 @@
         for (size_t i = 0; i < 10; i++)
         {
-            VBoxServiceVerbose(4, "ControlThead: [PID %u]: Kill attempt %d/10: Waiting to exit ...\n",
+            VBoxServiceVerbose(4, "ControlThread: [PID %u]: Kill attempt %d/10: Waiting to exit ...\n",
                                pThread->uPID, i + 1);
             rc2 = RTProcWait(hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
             if (RT_SUCCESS(rc2))
             {
-                VBoxServiceVerbose(4, "ControlThead: [PID %u]: Kill attempt %d/10: Exited\n",
+                VBoxServiceVerbose(4, "ControlThread: [PID %u]: Kill attempt %d/10: Exited\n",
                                    pThread->uPID, i + 1);
                 fProcessAlive = false;
@@ -666 +750 @@
             if (i >= 5)
             {
-                VBoxServiceVerbose(4, "ControlThead: [PID %u]: Kill attempt %d/10: Trying to terminate ...\n",
+                VBoxServiceVerbose(4, "ControlThread: [PID %u]: Kill attempt %d/10: Trying to terminate ...\n",
                                    pThread->uPID, i + 1);
                 RTProcTerminate(hProcess);
@@ -674 +758 @@
 
         if (fProcessAlive)
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Could not be killed\n", pThread->uPID);
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Could not be killed\n", pThread->uPID);
     }
 
@@ -688 +772 @@
         if (     fProcessTimedOut  && !fProcessAlive && MsProcessKilled != UINT64_MAX)
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Timed out and got killed\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Timed out and got killed\n",
                                pThread->uPID);
             uStatus = PROC_STS_TOK;
@@ -694 +778 @@
         else if (fProcessTimedOut  &&  fProcessAlive && MsProcessKilled != UINT64_MAX)
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Timed out and did *not* get killed\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Timed out and did *not* get killed\n",
                                pThread->uPID);
             uStatus = PROC_STS_TOA;
@@ -700 +784 @@
         else if (pThread->fShutdown && (fProcessAlive || MsProcessKilled != UINT64_MAX))
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Got terminated because system/service is about to shutdown\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Got terminated because system/service is about to shutdown\n",
                                pThread->uPID);
             uStatus = PROC_STS_DWN; /* Service is stopping, process was killed. */
@@ -707 +791 @@
         else if (fProcessAlive)
         {
-            VBoxServiceError("ControlThead: [PID %u]: Is alive when it should not!\n",
+            VBoxServiceError("ControlThread: [PID %u]: Is alive when it should not!\n",
                              pThread->uPID);
         }
         else if (MsProcessKilled != UINT64_MAX)
         {
-            VBoxServiceError("ControlThead: [PID %u]: Has been killed when it should not!\n",
+            VBoxServiceError("ControlThread: [PID %u]: Has been killed when it should not!\n",
                              pThread->uPID);
         }
         else if (ProcessStatus.enmReason == RTPROCEXITREASON_NORMAL)
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Ended with RTPROCEXITREASON_NORMAL (%u)\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Ended with RTPROCEXITREASON_NORMAL (%u)\n",
                                pThread->uPID, ProcessStatus.iStatus);
 
@@ -725 +809 @@
         else if (ProcessStatus.enmReason == RTPROCEXITREASON_SIGNAL)
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Ended with RTPROCEXITREASON_SIGNAL (%u)\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Ended with RTPROCEXITREASON_SIGNAL (%u)\n",
                                pThread->uPID, ProcessStatus.iStatus);
 
@@ -733 +817 @@
         else if (ProcessStatus.enmReason == RTPROCEXITREASON_ABEND)
         {
-            VBoxServiceVerbose(3, "ControlThead: [PID %u]: Ended with RTPROCEXITREASON_ABEND (%u)\n",
+            VBoxServiceVerbose(3, "ControlThread: [PID %u]: Ended with RTPROCEXITREASON_ABEND (%u)\n",
                                pThread->uPID, ProcessStatus.iStatus);
 
@@ -740 +824 @@
         }
         else
-            VBoxServiceVerbose(1, "ControlThead: [PID %u]: Handling process status %u not implemented\n",
+            VBoxServiceVerbose(1, "ControlThread: [PID %u]: Handling process status %u not implemented\n",
                                pThread->uPID, ProcessStatus.enmReason);
 
-        VBoxServiceVerbose(3, "ControlThead: [PID %u]: Sending final status, ClientID=%u, CID=%u, Status=%u, Flags=0x%x\n",
+        VBoxServiceVerbose(2, "ControlThread: [PID %u]: Ended, ClientID=%u, CID=%u, Status=%u, Flags=0x%x\n",
                            pThread->uPID, pThread->uClientID, pThread->uContextID, uStatus, uFlags);
         rc = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
@@ -749 +833 @@
                                              NULL /* pvData */, 0 /* cbData */);
         if (RT_FAILURE(rc))
-            VBoxServiceError("ControlThead: [PID %u]: Error reporting final status to host; rc=%Rrc\n",
+            VBoxServiceError("ControlThread: [PID %u]: Error reporting final status to host; rc=%Rrc\n",
                              pThread->uPID, rc);
 
-        VBoxServiceVerbose(3, "ControlThead: [PID %u]: Process loop ended with rc=%Rrc\n",
+        VBoxServiceVerbose(3, "ControlThread: [PID %u]: Process loop ended with rc=%Rrc\n",
                            pThread->uPID, rc);
     }
     else
-        VBoxServiceError("ControlThead: [PID %u]: Loop failed with rc=%Rrc\n",
+        VBoxServiceError("ControlThread: [PID %u]: Loop failed with rc=%Rrc\n",
                          pThread->uPID, rc);
     return rc;
+}
+
+
+static int vboxServiceControlThreadInitPipe(PRTHANDLE ph, PRTPIPE phPipe)
+{
+    AssertPtrReturn(ph, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(phPipe, VERR_INVALID_PARAMETER);
+
+    ph->enmType = RTHANDLETYPE_PIPE;
+    ph->u.hPipe = NIL_RTPIPE;
+    *phPipe     = NIL_RTPIPE;
+
+    return VINF_SUCCESS;
 }
 
@@ -781 +878 @@
     AssertPtrReturn(phPipe, VERR_INVALID_PARAMETER);
 
-    ph->enmType = RTHANDLETYPE_PIPE;
-    ph->u.hPipe = NIL_RTPIPE;
-    *pph        = NULL;
-    *phPipe     = NIL_RTPIPE;
-
     int rc;
 
@@ -833 +925 @@
 #endif
 #ifdef DEBUG
-    VBoxServiceVerbose(3, "ControlThead: VBoxServiceControlExecMakeFullPath: %s -> %s\n",
+    VBoxServiceVerbose(3, "ControlThread: VBoxServiceControlExecMakeFullPath: %s -> %s\n",
                        pszPath, pszExpanded);
 #endif
@@ -870 +962 @@
         rc = VBoxServiceControlThreadMakeFullPath(pszExecResolved, pszResolved, cbResolved);
 #ifdef DEBUG
-        VBoxServiceVerbose(3, "ControlThead: VBoxServiceControlExecResolveExecutable: %s -> %s\n",
+        VBoxServiceVerbose(3, "ControlThread: VBoxServiceControlExecResolveExecutable: %s -> %s\n",
                            pszFileName, pszResolved);
 #endif
@@ -1024 +1116 @@
             if (fFlags)
             {
-                /* Process Main flag "ExecuteProcessFlag_Hidden". */
-                if (fFlags & RT_BIT(2))
+                if (fFlags & EXECUTEPROCESSFLAG_HIDDEN)
                     uProcFlags |= RTPROC_FLAGS_HIDDEN;
-                /* Process Main flag "ExecuteProcessFlag_NoProfile". */
-                if (fFlags & RT_BIT(3))
+                if (fFlags & EXECUTEPROCESSFLAG_NO_PROFILE)
                     uProcFlags |= RTPROC_FLAGS_NO_PROFILE;
             }
@@ -1041 +1131 @@
                 uProcFlags |= RTPROC_FLAGS_SERVICE;
 #ifdef DEBUG
-            VBoxServiceVerbose(3, "ControlThead: Command: %s\n", szExecExp);
+            VBoxServiceVerbose(3, "ControlThread: Command: %s\n", szExecExp);
             for (size_t i = 0; papszArgsExp[i]; i++)
-                VBoxServiceVerbose(3, "ControlThead:\targv[%ld]: %s\n", i, papszArgsExp[i]);
+                VBoxServiceVerbose(3, "ControlThread:\targv[%ld]: %s\n", i, papszArgsExp[i]);
 #endif
             /* Do normal execution. */
@@ -1066 +1156 @@
 {
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
-    VBoxServiceVerbose(3, "ControlThead: Thread of process \"%s\" started\n", pThread->pszCmd);
+    VBoxServiceVerbose(3, "ControlThread: Thread of process \"%s\" started\n", pThread->pszCmd);
 
     int rc = VbglR3GuestCtrlConnect(&pThread->uClientID);
     if (RT_FAILURE(rc))
     {
-        VBoxServiceError("ControlThead: Thread failed to connect to the guest control service, aborted! Error: %Rrc\n", rc);
+        VBoxServiceError("ControlThread: Thread failed to connect to the guest control service, aborted! Error: %Rrc\n", rc);
         RTThreadUserSignal(RTThreadSelf());
         return rc;
     }
-    VBoxServiceVerbose(3, "ControlThead: Guest process \"%s\" got client ID=%u\n",
-                       pThread->pszCmd, pThread->uClientID);
+    VBoxServiceVerbose(3, "ControlThread: Guest process \"%s\" got client ID=%u, flags=0x%x\n",
+                       pThread->pszCmd, pThread->uClientID, pThread->uFlags);
 
     bool fSignalled = false; /* Indicator whether we signalled the thread user event already. */
@@ -1130 +1220 @@
                             /* Stdout. */
                             if (RT_SUCCESS(rc))
-                                rc = RTPollSetAddPipe(hPollSet, hStdOutR, RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDOUT);
+                            {
+                                uint32_t uFlags = RTPOLL_EVT_ERROR;
+                                if (!(pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT))
+                                {
+                                    uFlags |= RTPOLL_EVT_READ;
+                                    VBoxServiceVerbose(3, "ControlThread: Host is not interested in getting stdout for \"%s\", poll flags=0x%x\n",
+                                                        pThread->pszCmd, uFlags);
+                                }
+                                rc = RTPollSetAddPipe(hPollSet, hStdOutR, uFlags, VBOXSERVICECTRLPIPEID_STDOUT);
+                            }
                             /* Stderr. */
                             if (RT_SUCCESS(rc))
-                                rc = RTPollSetAddPipe(hPollSet, hStdErrR, RTPOLL_EVT_ERROR, VBOXSERVICECTRLPIPEID_STDERR);
+                            {
+                                uint32_t uFlags = RTPOLL_EVT_ERROR;
+                                if (!(pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR))
+                                {
+                                    uFlags |= RTPOLL_EVT_READ;
+                                    VBoxServiceVerbose(3, "ControlThread: Host is not interested in getting stderr for \"%s\", poll flags=0x%x\n",
+                                                        pThread->pszCmd, uFlags);
+                                }
+                                rc = RTPollSetAddPipe(hPollSet, hStdErrR, uFlags, VBOXSERVICECTRLPIPEID_STDERR);
+                            }
                             /* IPC notification pipe. */
                             if (RT_SUCCESS(rc))
@@ -1148 +1256 @@
                                                                            &hProcess);
                                 if (RT_FAILURE(rc))
-                                    VBoxServiceError("ControlThead: Error starting process, rc=%Rrc\n", rc);
+                                    VBoxServiceError("ControlThread: Error starting process, rc=%Rrc\n", rc);
                                 /*
                                  * Tell the control thread that it can continue
@@ -1176 +1284 @@
                                                                           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);
-
                                     /*
                                      * The handles that are no longer in the set have
@@ -1203 +1304 @@
                                 else /* Something went wrong; report error! */
                                 {
-                                    VBoxServiceError("ControlThead: Could not start process '%s' (CID: %u)! Error: %Rrc\n",
+                                    VBoxServiceError("ControlThread: Could not start process '%s' (CID: %u)! Error: %Rrc\n",
                                                      pThread->pszCmd, pThread->uContextID, rc);
 
@@ -1210 +1311 @@
                                                                           NULL /* pvData */, 0 /* cbData */);
                                     if (RT_FAILURE(rc2))
-                                        VBoxServiceError("ControlThead: Could not report process start error! Error: %Rrc (process error %Rrc)\n",
+                                        VBoxServiceError("ControlThread: Could not report process start error! Error: %Rrc (process error %Rrc)\n",
                                                          rc2, rc);
                                 }
@@ -1238 +1339 @@
     if (pThread->uClientID)
     {
-        VBoxServiceVerbose(3, "ControlThead: [PID %u]: Cancelling pending waits (client ID=%u)\n",
+        VBoxServiceVerbose(3, "ControlThread: [PID %u]: Cancelling pending waits (client ID=%u)\n",
                            pThread->uPID, pThread->uClientID);
         int rc2 = VbglR3GuestCtrlCancelPendingWaits(pThread->uClientID);
         if (RT_FAILURE(rc2))
         {
-            VBoxServiceError("ControlThead: [PID %u]: Cancelling pending waits failed; rc=%Rrc\n",
+            VBoxServiceError("ControlThread: [PID %u]: Cancelling pending waits failed; rc=%Rrc\n",
                              pThread->uPID, rc2);
             if (RT_SUCCESS(rc))
@@ -1250 +1351 @@
 
         /* Disconnect from guest control service. */
-        VBoxServiceError("ControlThead: [PID %u]: Disconnecting (client ID=%u) ...\n",
-                         pThread->uPID, pThread->uClientID);
+        VBoxServiceVerbose(3, "ControlThread: [PID %u]: Disconnecting (client ID=%u) ...\n",
+                           pThread->uPID, pThread->uClientID);
         VbglR3GuestCtrlDisconnect(pThread->uClientID);
         pThread->uClientID = 0;
     }
 
-    VBoxServiceVerbose(3, "ControlThead: [PID %u]: Thread of process \"%s\" ended with rc=%Rrc\n",
+    VBoxServiceVerbose(3, "ControlThread: [PID %u]: Thread of process \"%s\" ended with rc=%Rrc\n",
                        pThread->uPID, pThread->pszCmd, rc);
 
@@ -1268 +1369 @@
         RTThreadUserSignal(RTThreadSelf());
 
-    int rc2 = vboxServiceControlThreadShutdown(pThread);
+    /*
+     * Remove thread from global thread list. After this it's safe to shutdown
+     * and deallocate this thread.
+     */
+    VBoxServiceControlRemoveThread(pThread);
+
+    int rc2 = vboxServiceControlThreadFree(pThread);
     if (RT_SUCCESS(rc))
         rc = rc2;
@@ -1348 +1455 @@
         if (RT_FAILURE(rc))
         {
-            VBoxServiceError("ControlThead: RTThreadCreate failed, rc=%Rrc\n, pThread=%p\n",
+            VBoxServiceError("ControlThread: RTThreadCreate failed, rc=%Rrc\n, pThread=%p\n",
                              rc, pThread);
         }
         else
         {
-            VBoxServiceVerbose(4, "ControlThead: Waiting for thread to initialize ...\n");
+            VBoxServiceVerbose(4, "ControlThread: Waiting for thread to initialize ...\n");
 
             /* Wait for the thread to initialize. */
@@ -1359 +1466 @@
             if (ASMAtomicReadBool(&pThread->fShutdown))
             {
-                VBoxServiceError("ControlThead: Thread for process \"%s\" failed to start!\n", pszCmd);
+                VBoxServiceError("ControlThread: Thread for process \"%s\" failed to start!\n", pszCmd);
                 rc = VERR_GENERAL_FAILURE;
             }
@@ -1380 +1487 @@
 
 /**
- * Assigns a valid PID to a guest control thread and also checks if there already was
- * another (stale) guest process which was using that PID before and destroys it.
- *
- * @return  IPRT status code.
- * @param   pData          Pointer to guest control execution thread data.
- * @param   uPID           PID to assign to the specified guest control execution thread.
- */
-int vboxServiceControlThreadAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID)
-{
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
-    AssertReturn(uPID, VERR_INVALID_PARAMETER);
-
-    int rc = VINF_SUCCESS;
-
-    /* Search an old thread using the desired PID and shut it down completely -- it's
-     * not used anymore. */
-    PVBOXSERVICECTRLTHREAD pOldThread = VBoxServiceControlGetThreadByPID(uPID);
-    if (   pOldThread
-        && pOldThread != pThread)
-    {
-        PVBOXSERVICECTRLTHREAD pNext = RTListNodeGetNext(&pOldThread->Node, VBOXSERVICECTRLTHREAD, Node);
-
-        VBoxServiceVerbose(3, "ControlThead: PID %u was used before, shutting down stale exec thread ...\n",
-                           uPID);
-        rc = vboxServiceControlThreadShutdown(pOldThread);
-        if (RT_FAILURE(rc))
-        {
-            VBoxServiceVerbose(3, "ControlThead: Unable to shut down stale exec thread, rc=%Rrc\n", rc);
-            /* Keep going. */
-        }
-    }
-
-    /* Assign PID to current thread. */
-    pThread->uPID = uPID;
-
-    return rc;
-}
-
-
-/**
  * Performs a request to a specific (formerly started) guest process and waits
  * for its response.
@@ -1433 +1500 @@
     /* Rest in pRequest is optional (based on the request type). */
 
-    VBoxServiceVerbose(4, "ControlThead: 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
-        && !ASMAtomicReadBool(&pThread->fStopped))
-    {
-        rc = RTCritSectEnter(&pThread->CritSect);
+    int rc = VINF_SUCCESS;
+    const PVBOXSERVICECTRLTHREAD pThread = VBoxServiceControlGetThreadLocked(uPID);
+    if (pThread)
+    {
+        /* Set request result to some defined state in case
+         * it got cancelled. */
+        pRequest->rc = VERR_CANCELLED;
+
+        /* Set request structure pointer. */
+        pThread->pRequest = pRequest;
+
+        /** @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
+         * that RTPoll unblocks (returns) and we then can do our requested operation. */
+        if (pThread->hNotificationPipeW == NIL_RTPIPE)
+            rc = VERR_BROKEN_PIPE;
+        size_t cbWritten;
         if (RT_SUCCESS(rc))
-        {
-            /* Set request structure pointer. */
-            pThread->pRequest = pRequest;
-
-            /** @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
-             * that RTPoll unblocks (returns) and we then can do our requested operation. */
-            if (pThread->hNotificationPipeW == NIL_RTPIPE)
-                rc = VERR_BROKEN_PIPE;
-            size_t cbWritten;
+            rc = RTPipeWrite(pThread->hNotificationPipeW, "i", 1, &cbWritten);
+
+        if (   RT_SUCCESS(rc)
+            && cbWritten)
+        {
+            VBoxServiceVerbose(3, "ControlThread: [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);
             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, "ControlThead: [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);
-                if (RT_SUCCESS(rc))
-                {
-                    VBoxServiceVerbose(4, "ControlThead: [PID %u]: Performed with rc=%Rrc, cbData=%u\n",
-                                       uPID, pRequest->rc, pRequest->cbData);
-
-                    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("ControlThead: Unable to reset request event, rc=%Rrc\n", rc2);
-
-                        rc2 = RTCritSectLeave(&pThread->CritSect);
-                        AssertRCReturn(rc2, rc2);
-                    }
-                }
+                VBoxServiceVerbose(4, "ControlThread: [PID %u]: Performed with rc=%Rrc, cbData=%u\n",
+                                   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("ControlThread: [PID %u]: Unable to reset request event, rc=%Rrc\n",
+                                     uPID, rc2);
             }
-        }
+            else
+                VBoxServiceError("ControlThread: [PID %u]: Wait failed, rc=%Rrc\n",
+                                 uPID, rc);
+        }
+
+        VBoxServiceControlThreadUnlock(pThread);
     }
     else /* PID not found! */
         rc = VERR_NOT_FOUND;
 
-    VBoxServiceVerbose(4, "ControlThead: Performed PID=%u, enmType=%u, pvData=0x%p, cbData=%u with rc=%Rrc\n",
-                       uPID, pRequest->enmType, pRequest->pvData, pRequest->cbData, rc);
-    return rc;
-}
-
-
-/**
- * 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, "ControlThead: [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.
-     */
-    RTMemFree(pThread);
-    pThread = NULL;
-
-    return rc;
-}
-
+    VBoxServiceVerbose(3, "ControlThread: [PID %u]: Performed enmType=%u, uCID=%u, pvData=0x%p, cbData=%u, rc=%Rrc\n",
+                       uPID, pRequest->enmType, pRequest->uCID, pRequest->pvData, pRequest->cbData, rc);
+    return rc;
+}
+

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

@@ -171 +171 @@
     /** Payload data; a pre-allocated data buffer for input/output. */
     void                      *pvData;
+    /** The context ID which is required to complete the
+     *  request. */
+    uint32_t                   uCID;
     /** The overall result of the operation. */
     int                        rc;
@@ -230 +233 @@
 /** Pointer to thread data. */
 typedef VBOXSERVICECTRLTHREAD *PVBOXSERVICECTRLTHREAD;
+
+/**
+ * Request types to perform on a started guest process.
+ */
+typedef enum VBOXSERVICECTRLTHREADSTATUS
+{
+    /** Unknown status. Do not use / should not happen. */
+    VBOXSERVICECTRLTHREADSTATUS_UNKNOWN          = 0,
+    VBOXSERVICECTRLTHREADSTATUS_STARTED          = 100,
+    VBOXSERVICECTRLTHREADSTATUS_STOPPED          = 200
+} VBOXSERVICECTRLTHREADSTATUS;
 #endif /* VBOX_WITH_GUEST_CONTROL */
 #ifdef VBOX_WITH_GUEST_PROPS
@@ -329 +343 @@
 extern int          VBoxServiceControlHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, size_t cbMaxBufSize);
 extern int          VBoxServiceControlHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);
-extern PVBOXSERVICECTRLTHREAD VBoxServiceControlGetThreadByPID(uint32_t uPID);
-extern void         VBoxServiceControlRemoveThread(PVBOXSERVICECTRLTHREAD pThread);
+extern const PVBOXSERVICECTRLTHREAD VBoxServiceControlGetThreadLocked(uint32_t uPID);
+extern void         VBoxServiceControlThreadUnlock(const PVBOXSERVICECTRLTHREAD pThread);
+extern int          VBoxServiceControlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID);
+extern void         VBoxServiceControlRemoveThread(const PVBOXSERVICECTRLTHREAD pThread);
 /* Guest process functions. */
+extern VBOXSERVICECTRLTHREADSTATUS VBoxServiceControlThreadGetStatus(const PVBOXSERVICECTRLTHREAD pThread);
 extern int          VBoxServiceControlThreadStart(uint32_t uClientID, uint32_t uContext,
                                                   const char *pszCmd, uint32_t uFlags,
@@ -338 +355 @@
                                                   const char *pszUser, const char *pszPassword, uint32_t uTimeLimitMS,
                                                   PRTLISTNODE *ppNode);
-int                 VBoxServiceControlThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest);
+extern int          VBoxServiceControlThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest);
 extern int          VBoxServiceControlThreadSignalShutdown(const PVBOXSERVICECTRLTHREAD pThread);
 extern int          VBoxServiceControlThreadWaitForShutdown(const PVBOXSERVICECTRLTHREAD pThread, RTMSINTERVAL msTimeout);