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

Timestamp:

Apr 8, 2013 9:40:42 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

84843

Message:

GuestCtrl: Implemented using (public) VirtualBox events instead of own callback mechanisms. Bugfixes for testcases (still work in progress).

Location:

trunk/src/VBox/Additions/common/VBoxService

Files:

• VBoxServiceControl.cpp (modified) (6 diffs)
• VBoxServiceControl.h (modified) (5 diffs)
• VBoxServiceControlProcess.cpp (modified) (53 diffs)
• VBoxServiceControlSession.cpp (modified) (50 diffs)

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

@@ -274 +274 @@
                          * skip all not wanted messages here.
                          */
-                        VBoxServiceVerbose(3, "Skipping msg=%RU32 ...\n", uMsg);
+                        rc = VbglR3GuestCtrlMsgSkip(g_uControlSvcClientID);
+                        VBoxServiceVerbose(3, "Skipping msg=%RU32, rc=%Rrc\n", uMsg, rc);
                     }
                     break;
@@ -323 +324 @@
                            pHostCtx->uClientID, pHostCtx->uProtocol);
 
-        rc = GstCntlSessionThreadOpen(&g_lstControlSessionThreads,
-                                      &ssInfo, NULL /* Session */);
+        rc = GstCntlSessionThreadCreate(&g_lstControlSessionThreads,
+                                        &ssInfo, NULL /* Session */);
     }
 
@@ -350 +351 @@
 
     uint32_t uSessionID, uFlags;
-
     int rc = VbglR3GuestCtrlSessionGetClose(pHostCtx, &uFlags, &uSessionID);
     if (RT_SUCCESS(rc))
@@ -361 +361 @@
             if (pThread->StartupInfo.uSessionID == uSessionID)
             {
-                rc = GstCntlSessionThreadClose(pThread, uFlags);
+                rc = GstCntlSessionThreadDestroy(pThread, uFlags);
                 break;
             }
         }
-
+#if 0
         if (RT_FAILURE(rc))
         {
@@ -379 +379 @@
             }
         }
-    }
-
-    VBoxServiceVerbose(2, "Closing guest session %RU32 returned rc=%Rrc\n",
-                       uSessionID, rc);
+#endif
+        VBoxServiceVerbose(2, "Closing guest session %RU32 returned rc=%Rrc\n",
+                           uSessionID, rc);
+    }
+    else
+        VBoxServiceError("Closing guest session failed with rc=%Rrc\n", rc);
+
     return rc;
 }
@@ -420 +423 @@
     VBoxServiceVerbose(2, "Shutting down ...\n");
 
-    int rc2 = GstCntlSessionThreadCloseAll(&g_lstControlSessionThreads,
-                                           0 /* Flags */);
+    int rc2 = GstCntlSessionThreadDestroyAll(&g_lstControlSessionThreads,
+                                             0 /* Flags */);
     if (RT_FAILURE(rc2))
         VBoxServiceError("Closing session threads failed with rc=%Rrc\n", rc2);

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

@@ -169 +169 @@
 /**
  * Structure for a guest session thread to
- * observe the forked session instance.
+ * observe/control the forked session instance from
+ * the VBoxService main executable.
  */
 typedef struct VBOXSERVICECTRLSESSIONTHREAD
@@ -243 +244 @@
 typedef struct VBOXSERVICECTRLSESSION
 {
+    /* The session's startup information. */
     VBOXSERVICECTRLSESSIONSTARTUPINFO
                                     StartupInfo;
-    /** List of active guest control threads (VBOXSERVICECTRLTHREAD). */
-    RTLISTANCHOR                    lstControlThreadsActive;
-    /** List of inactive guest control threads (VBOXSERVICECTRLTHREAD). */
+    /** List of active guest process threads (VBOXSERVICECTRLPROCESS). */
+    RTLISTANCHOR                    lstProcessesActive;
+    /** List of inactive guest process threads (VBOXSERVICECTRLPROCESS). */
     /** @todo Still needed? */
-    RTLISTANCHOR                    lstControlThreadsInactive;
+    RTLISTANCHOR                    lstProcessesInactive;
     /** List of guest control files (VBOXSERVICECTRLFILE). */
     RTLISTANCHOR                    lstFiles;
-    /** Critical section for protecting the guest process
-     *  threading list. */
-    RTCRITSECT                      csControlThreads;
+    /** The session's critical section. */
+    RTCRITSECT                      CritSect;
     /** Session flags. */
     uint32_t                        uFlags;
@@ -330 +331 @@
     /** Critical section for thread-safe use. */
     RTCRITSECT                      CritSect;
-    /** @todo Document me! */
+    /** Process startup information. */
+    VBOXSERVICECTRLPROCSTARTUPINFO
+                                    StartupInfo;
+    /** The process' PID assigned by the guest OS. */
     uint32_t                        uPID;
-    char                           *pszCmd;
-    uint32_t                        uFlags;
-    char                          **papszArgs;
-    uint32_t                        uNumArgs;
-    char                          **papszEnv;
-    uint32_t                        uNumEnvVars;
-    /** Name of specified user account to run the
-     *  guest process under. */
-    char                           *pszUser;
-    /** Password of specified user account. */
-    char                           *pszPassword;
-    /** Overall time limit (in ms) that the guest process
-     *  is allowed to run. 0 for indefinite time. */
-    uint32_t                        uTimeLimitMS;
     /** Pointer to the current IPC request being
-     *  processed. */
+     *  processed. We only support one request at a
+     *  time at the moment.
+     ** @todo Implemenet a request queue. */
     PVBOXSERVICECTRLREQUEST         pRequest;
     /** StdIn pipe for addressing writes to the
@@ -374 +366 @@
 
 /* Guest session thread handling. */
-extern int                      GstCntlSessionThreadOpen(PRTLISTANCHOR pList, const PVBOXSERVICECTRLSESSIONSTARTUPINFO pSessionStartupInfo, PVBOXSERVICECTRLSESSIONTHREAD *ppSessionThread);
-extern int                      GstCntlSessionThreadClose(PVBOXSERVICECTRLSESSIONTHREAD pSession, uint32_t uFlags);
-extern int                      GstCntlSessionThreadCloseAll(PRTLISTANCHOR pList, uint32_t uFlags);
+extern int                      GstCntlSessionThreadCreate(PRTLISTANCHOR pList, const PVBOXSERVICECTRLSESSIONSTARTUPINFO pSessionStartupInfo, PVBOXSERVICECTRLSESSIONTHREAD *ppSessionThread);
+extern int                      GstCntlSessionThreadDestroy(PVBOXSERVICECTRLSESSIONTHREAD pSession, uint32_t uFlags);
+extern int                      GstCntlSessionThreadDestroyAll(PRTLISTANCHOR pList, uint32_t uFlags);
 extern int                      GstCntlSessionThreadTerminate(PVBOXSERVICECTRLSESSIONTHREAD pSession);
 extern RTEXITCODE               VBoxServiceControlSessionForkInit(int argc, char **argv);
@@ -392 +384 @@
 extern int                      GstCntlProcessPerform(PVBOXSERVICECTRLPROCESS pProcess, PVBOXSERVICECTRLREQUEST pRequest);
 extern int                      GstCntlProcessStart(const PVBOXSERVICECTRLSESSION pSession, const PVBOXSERVICECTRLPROCSTARTUPINFO pStartupInfo, uint32_t uContext);
-extern int                      GstCntlProcessStop(const PVBOXSERVICECTRLPROCESS pThread);
-extern void                     GstCntlProcessRelease(const PVBOXSERVICECTRLPROCESS pThread);
-extern int                      GstCntlProcessWait(const PVBOXSERVICECTRLPROCESS pThread, RTMSINTERVAL msTimeout, int *prc);
-extern int                      GstCntlProcessFree(PVBOXSERVICECTRLPROCESS pThread);
+extern int                      GstCntlProcessStop(PVBOXSERVICECTRLPROCESS pProcess);
+extern void                     GstCntlProcessRelease(const PVBOXSERVICECTRLPROCESS pProcess);
+extern int                      GstCntlProcessWait(const PVBOXSERVICECTRLPROCESS pProcess, RTMSINTERVAL msTimeout, int *pRc);
+extern int                      GstCntlProcessFree(PVBOXSERVICECTRLPROCESS pProcess);
 /* Process request handling. */
 extern int                      GstCntlProcessRequestAlloc(PVBOXSERVICECTRLREQUEST *ppReq, VBOXSERVICECTRLREQUESTTYPE enmType);

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

@@ -87 +87 @@
         return rc;
 
-    pProcess->uPID         = 0;          /* Don't have a PID yet. */
-    pProcess->pRequest     = NULL;       /* No request assigned yet. */
-    pProcess->uFlags       = pProcess->uFlags;
-    pProcess->uTimeLimitMS = (   pProcess->uTimeLimitMS == UINT32_MAX
-                              || pProcess->uTimeLimitMS == 0)
-                           ? RT_INDEFINITE_WAIT : pProcess->uTimeLimitMS;
-
-    /* Prepare argument list. */
-    pProcess->uNumArgs = 0; /* Initialize in case of RTGetOptArgvFromString() is failing ... */
-    rc = RTGetOptArgvFromString(&pProcess->papszArgs, (int*)&pProcess->uNumArgs,
-                                (pStartupInfo->uNumArgs > 0) ? pStartupInfo->szArgs : "", NULL);
-    /* Did we get the same result? */
-    Assert(pStartupInfo->uNumArgs == pProcess->uNumArgs);
-
-    if (RT_SUCCESS(rc))
-    {
-        /* Prepare environment list. */
-        pProcess->uNumEnvVars = 0;
-        if (pProcess->uNumEnvVars)
-        {
-            pProcess->papszEnv = (char **)RTMemAlloc(pStartupInfo->uNumEnvVars * sizeof(char*));
-            AssertPtr(pProcess->papszEnv);
-            pProcess->uNumEnvVars = pProcess->uNumEnvVars;
-
-            const char *pszCur = pStartupInfo->szEnv;
-            uint32_t i = 0;
-            uint32_t cbLen = 0;
-            while (cbLen < pStartupInfo->cbEnv)
-            {
-                /* sanity check */
-                if (i >= pStartupInfo->uNumEnvVars)
-                {
-                    rc = VERR_INVALID_PARAMETER;
-                    break;
-                }
-                int cbStr = RTStrAPrintf(&pProcess->papszEnv[i++], "%s", pszCur);
-                if (cbStr < 0)
-                {
-                    rc = VERR_NO_STR_MEMORY;
-                    break;
-                }
-                pszCur += cbStr + 1; /* Skip terminating '\0' */
-                cbLen  += cbStr + 1; /* Skip terminating '\0' */
-            }
-            Assert(i == pProcess->uNumEnvVars);
-        }
-
-        /* The actual command to execute. */
-        pProcess->pszCmd      = RTStrDup(pStartupInfo->szCmd);
-        AssertPtr(pProcess->pszCmd);
-
-        /* User management. */
-        pProcess->pszUser     = RTStrDup(pStartupInfo->szUser);
-        AssertPtr(pProcess->pszUser);
-        pProcess->pszPassword = RTStrDup(pStartupInfo->szPassword);
-        AssertPtr(pProcess->pszPassword);
-    }
+    pProcess->uPID     = 0;          /* Don't have a PID yet. */
+    pProcess->pRequest = NULL;       /* No request assigned yet. */
+
+    /* Copy over startup info. */
+    memcpy(&pProcess->StartupInfo, pStartupInfo, sizeof(VBOXSERVICECTRLPROCSTARTUPINFO));
+
+    /* Adjust timeout value. */
+    if (   pProcess->StartupInfo.uTimeLimitMS == UINT32_MAX
+        || pProcess->StartupInfo.uTimeLimitMS == 0)
+        pProcess->StartupInfo.uTimeLimitMS = RT_INDEFINITE_WAIT;
 
     if (RT_FAILURE(rc)) /* Clean up on failure. */
@@ -161 +114 @@
     AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
 
-    VBoxServiceVerbose(3, "[PID %u]: Freeing ...\n",
+    VBoxServiceVerbose(3, "[PID %RU32]: Freeing ...\n",
                        pProcess->uPID);
 
-    int rc = RTCritSectEnter(&pProcess->CritSect);
-    if (RT_SUCCESS(rc))
-    {
-        if (pProcess->uNumEnvVars)
-        {
-            for (uint32_t i = 0; i < pProcess->uNumEnvVars; i++)
-                RTStrFree(pProcess->papszEnv[i]);
-            RTMemFree(pProcess->papszEnv);
-        }
-        RTGetOptArgvFree(pProcess->papszArgs);
-
-        RTStrFree(pProcess->pszCmd);
-        RTStrFree(pProcess->pszUser);
-        RTStrFree(pProcess->pszPassword);
-
-        VBoxServiceVerbose(3, "[PID %u]: Setting stopped state\n",
-                           pProcess->uPID);
-
-        rc = RTCritSectLeave(&pProcess->CritSect);
-        AssertRC(rc);
-    }
 
     /*
@@ -198 +130 @@
     pProcess = NULL;
 
-    return rc;
+    return VINF_SUCCESS;
 }
 
@@ -207 +139 @@
  *
  * @return  IPRT status code.
- * @param   pThread             Thread to shut down.
- */
-int GstCntlProcessStop(const PVBOXSERVICECTRLPROCESS pThread)
-{
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
-
-    VBoxServiceVerbose(3, "[PID %u]: Stopping ...\n",
-                       pThread->uPID);
-
-    int rc = gstcntlProcessRequestCancel(pThread->pRequest);
-    if (RT_FAILURE(rc))
-        VBoxServiceError("[PID %u]: Signalling request event failed, rc=%Rrc\n",
-                         pThread->uPID, rc);
-
-    /* Do *not* set pThread->fShutdown or other stuff here!
-     * The guest thread loop will do that as soon as it processes the quit message. */
-
-    PVBOXSERVICECTRLREQUEST pRequest;
-    rc = GstCntlProcessRequestAlloc(&pRequest, VBOXSERVICECTRLREQUEST_QUIT);
+ * @param   pProcess            Process to stop.
+ */
+int GstCntlProcessStop(PVBOXSERVICECTRLPROCESS pProcess)
+{
+    AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
+
+    VBoxServiceVerbose(3, "[PID %RU32]: Stopping ...\n",
+                       pProcess->uPID);
+
+    int rc = RTCritSectEnter(&pProcess->CritSect);
     if (RT_SUCCESS(rc))
     {
-        rc = GstCntlProcessPerform(pThread, pRequest);
-        if (RT_FAILURE(rc))
-            VBoxServiceVerbose(3, "[PID %u]: Sending quit request failed with rc=%Rrc\n",
-                               pThread->uPID, rc);
-
-        GstCntlProcessRequestFree(pRequest);
-    }
+        if (pProcess->pRequest)
+        {
+            rc = gstcntlProcessRequestCancel(pProcess->pRequest);
+            if (RT_FAILURE(rc))
+                VBoxServiceError("[PID %RU32]: Signalling request event failed, rc=%Rrc\n",
+                                 pProcess->uPID, rc);
+        }
+
+        /* Do *not* set pThread->fShutdown or other stuff here!
+         * The guest thread loop will do that as soon as it processes the quit message. */
+
+        PVBOXSERVICECTRLREQUEST pRequest;
+        rc = GstCntlProcessRequestAlloc(&pRequest, VBOXSERVICECTRLREQUEST_QUIT);
+        if (RT_SUCCESS(rc))
+        {
+            rc = GstCntlProcessPerform(pProcess, pRequest);
+            if (RT_FAILURE(rc))
+                VBoxServiceVerbose(3, "[PID %RU32]: Sending quit request failed with rc=%Rrc\n",
+                                   pProcess->uPID, rc);
+
+            GstCntlProcessRequestFree(pRequest);
+        }
+
+        int rc2 = RTCritSectLeave(&pProcess->CritSect);
+        AssertRC(rc2);
+    }
+
     return rc;
 }
@@ -242 +185 @@
  * Releases (unlocks) a previously locked guest process.
  *
- * @param   pThread                 Thread to unlock.
- */
-void GstCntlProcessRelease(const PVBOXSERVICECTRLPROCESS pThread)
-{
-    AssertPtr(pThread);
-
-    int rc = RTCritSectLeave(&pThread->CritSect);
+ * @param   pProcess            Process to unlock.
+ */
+void GstCntlProcessRelease(const PVBOXSERVICECTRLPROCESS pProcess)
+{
+    AssertPtrReturnVoid(pProcess);
+
+    int rc = RTCritSectLeave(&pProcess->CritSect);
     AssertRC(rc);
 }
@@ -255 +198 @@
 /**
  * Wait for a guest process thread to shut down.
- *
- * @return  IPRT status code.
- * @param   pThread             Thread to wait shutting down for.
+ * Note: Caller is responsible for locking!
+ *
+ * @return  IPRT status code.
+ * @param   pProcess            Process to wait shutting down for.
  * @param   RTMSINTERVAL        Timeout in ms to wait for shutdown.
- * @param   prc                 Where to store the thread's return code. Optional.
- */
-int GstCntlProcessWait(const PVBOXSERVICECTRLPROCESS pThread,
-                       RTMSINTERVAL msTimeout, int *prc)
-{
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
-    /* prc is optional. */
+ * @param   pRc                 Where to store the thread's return code. Optional.
+ */
+int GstCntlProcessWait(const PVBOXSERVICECTRLPROCESS pProcess,
+                       RTMSINTERVAL msTimeout, int *pRc)
+{
+    AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
+    /* pRc is optional. */
 
     int rc = VINF_SUCCESS;
-    if (   pThread->Thread != NIL_RTTHREAD
-        && ASMAtomicReadBool(&pThread->fStarted))
-    {
-        VBoxServiceVerbose(2, "[PID %u]: Waiting for shutdown of pThread=0x%p = \"%s\"...\n",
-                           pThread->uPID, pThread, pThread->pszCmd);
+    if (   pProcess->Thread != NIL_RTTHREAD
+        && ASMAtomicReadBool(&pProcess->fStarted))
+    {
+        VBoxServiceVerbose(2, "[PID %RU32]: Waiting for shutdown (%RU32ms) ...\n",
+                           pProcess->uPID, msTimeout);
 
         /* Wait a bit ... */
         int rcThread;
-        rc = RTThreadWait(pThread->Thread, msTimeout, &rcThread);
+        rc = RTThreadWait(pProcess->Thread, msTimeout, &rcThread);
         if (RT_FAILURE(rc))
         {
-            VBoxServiceError("[PID %u]: Waiting for shutting down thread returned error rc=%Rrc\n",
-                             pThread->uPID, rc);
+            VBoxServiceError("[PID %RU32]: Waiting for shutting down thread returned error rc=%Rrc\n",
+                             pProcess->uPID, rc);
         }
         else
         {
-            VBoxServiceVerbose(3, "[PID %u]: Thread reported exit code=%Rrc\n",
-                               pThread->uPID, rcThread);
-            if (prc)
-                *prc = rcThread;
-        }
-    }
+            VBoxServiceVerbose(3, "[PID %RU32]: Thread reported exit code=%Rrc\n",
+                               pProcess->uPID, rcThread);
+            if (pRc)
+                *pRc = rcThread;
+        }
+    }
+
     return rc;
 }
@@ -368 +313 @@
         && cbReadable)
     {
-        VBoxServiceVerbose(3, "gstcntlProcessHandleOutputError: idPollHnd=%u has %ld bytes left, vetoing close\n",
+        VBoxServiceVerbose(3, "gstcntlProcessHandleOutputError: idPollHnd=%RU32 has %zu bytes left, vetoing close\n",
                            idPollHnd, cbReadable);
 
@@ -377 +322 @@
     }
     else
-        VBoxServiceVerbose(3, "gstcntlProcessHandleOutputError: idPollHnd=%u will be closed\n",
+        VBoxServiceVerbose(3, "gstcntlProcessHandleOutputError: idPollHnd=%RU32 will be closed\n",
                            idPollHnd);
 
@@ -460 +405 @@
     pRequest->rc = rc;
 
-#ifdef _DEBUG
-    VBoxServiceVerbose(4, "Handled req=%u, CID=%u, rc=%Rrc, cbData=%u, pvData=%p\n",
+#ifdef DEBUG_andy
+    VBoxServiceVerbose(4, "Handled req=%RU32, CID=%RU32, rc=%Rrc, cbData=%RU32, pvData=%p\n",
                        pRequest->enmType, pRequest->uCID, pRequest->rc,
                        pRequest->cbData, pRequest->pvData);
@@ -477 +422 @@
 static int gstcntlProcessHandleRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
                                        PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
-                                       PVBOXSERVICECTRLPROCESS pThread, PVBOXSERVICECTRLREQUEST pRequest)
+                                       PVBOXSERVICECTRLPROCESS pProcess, PVBOXSERVICECTRLREQUEST pRequest)
 {
     AssertPtrReturn(phStdInW, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdOutR, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdErrR, VERR_INVALID_POINTER);
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
     AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
+
+    VBoxServiceVerbose(4, "[PID %RU32]: Handling pRequest=%p\n",
+                       pProcess->uPID, pRequest);
 
     /* Drain the notification pipe. */
     uint8_t abBuf[8];
     size_t cbIgnore;
-    int rc = RTPipeRead(pThread->hNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
+    int rc = RTPipeRead(pProcess->hNotificationPipeR, abBuf, sizeof(abBuf), &cbIgnore);
     if (RT_FAILURE(rc))
         VBoxServiceError("Draining IPC notification pipe failed with rc=%Rrc\n", rc);
@@ -501 +449 @@
             /** @todo Check for some conditions to check to
              *        veto quitting. */
-            ASMAtomicXchgBool(&pThread->fShutdown, true);
+            ASMAtomicXchgBool(&pProcess->fShutdown, true);
             rcReq = VERR_CANCELLED;
             break;
@@ -572 +520 @@
 
         case VBOXSERVICECTRLREQUEST_PROC_TERM:
-            ASMAtomicXchgBool(&pThread->fShutdown, true);
+            ASMAtomicXchgBool(&pProcess->fShutdown, true);
             fDefer = true;
             break;
@@ -589 +537 @@
         /* No access to pRequest here anymore -- could be out of scope
          * or modified already! */
-        pThread->pRequest = pRequest = NULL;
+        pProcess->pRequest = pRequest = NULL;
     }
     else /* Completing the request defered. */
@@ -603 +551 @@
  *
  * @return  IPRT status code.
- * @param   pThread                     The process' thread handle.
+ * @param   pProcess                    The guest process to handle.
  * @param   hProcess                    The actual process handle.
  * @param   cMsTimeout                  Time limit (in ms) of the process' life time.
@@ -611 +559 @@
  * @param   hStdErrR                    Handle to the process' stderr read end.
  */
-static int gstcntlProcessProcLoop(PVBOXSERVICECTRLPROCESS pThread,
-                                  RTPROCESS hProcess, RTMSINTERVAL cMsTimeout, RTPOLLSET hPollSet,
+static int gstcntlProcessProcLoop(PVBOXSERVICECTRLPROCESS pProcess,
+                                  RTPROCESS hProcess, RTPOLLSET hPollSet,
                                   PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR)
 {
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdInW, VERR_INVALID_PARAMETER);
     /* Rest is optional. */
@@ -621 +569 @@
     int                         rc;
     int                         rc2;
-    uint64_t const              MsStart             = RTTimeMilliTS();
+    uint64_t const              uMsStart            = RTTimeMilliTS();
     RTPROCSTATUS                ProcessStatus       = { 254, RTPROCEXITREASON_ABEND };
     bool                        fProcessAlive       = true;
@@ -636 +584 @@
      * the first (stale) entry will be found and we get really weird results!
      */
-    rc = gstcntlProcessAssignPID(pThread, hProcess);
+    rc = gstcntlProcessAssignPID(pProcess, hProcess);
     if (RT_FAILURE(rc))
     {
@@ -648 +596 @@
      * and that it's now OK to send input to the process.
      */
-    VBoxServiceVerbose(2, "[PID %u]: Process \"%s\" started, CID=%u, User=%s\n",
-                       pThread->uPID, pThread->pszCmd, pThread->uContextID, pThread->pszUser);
-    VBGLR3GUESTCTRLCMDCTX ctx = { pThread->uClientID, pThread->uContextID };
+    VBoxServiceVerbose(2, "[PID %RU32]: Process \"%s\" started, CID=%u, User=%s, cMsTimeout=%RU32\n",
+                       pProcess->uPID, pProcess->StartupInfo.szCmd, pProcess->uContextID,
+                       pProcess->StartupInfo.szUser, pProcess->StartupInfo.uTimeLimitMS);
+    VBGLR3GUESTCTRLCMDCTX ctx = { pProcess->uClientID, pProcess->uContextID };
     rc = VbglR3GuestCtrlProcCbStatus(&ctx,
-                                     pThread->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
+                                     pProcess->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
                                      NULL /* pvData */, 0 /* cbData */);
 
@@ -660 +609 @@
     PVBOXSERVICECTRLREQUEST pReq = NULL;
     while (   RT_SUCCESS(rc)
-           && RT_UNLIKELY(!pThread->fShutdown))
+           && RT_UNLIKELY(!pProcess->fShutdown))
     {
         /*
@@ -668 +617 @@
         uint32_t fPollEvt;
         rc2 = RTPollNoResume(hPollSet, cMsPollCur, &fPollEvt, &idPollHnd);
-        if (pThread->fShutdown)
+        if (pProcess->fShutdown)
             continue;
 
@@ -675 +624 @@
         if (RT_SUCCESS(rc2))
         {
-            /*VBoxServiceVerbose(4, "[PID %u}: RTPollNoResume idPollHnd=%u\n",
-                                 pThread->uPID, idPollHnd);*/
             switch (idPollHnd)
             {
@@ -693 +640 @@
 
                 case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
-                    pReq = pThread->pRequest; /** @todo Implement request queue. */
+                    pReq = pProcess->pRequest; /** @todo Implement request queue. */
                     rc = gstcntlProcessHandleRequest(hPollSet, fPollEvt,
                                                      phStdInW, phStdOutR, phStdErrR,
-                                                     pThread, pReq);
+                                                     pProcess, pReq);
                     if (rc != VINF_AIO_TASK_PENDING)
                         pReq = NULL;
@@ -708 +655 @@
             if (RT_FAILURE(rc) || rc == VINF_EOF)
                 break; /* Abort command, or client dead or something. */
-
-            if (RT_UNLIKELY(pThread->fShutdown))
-                break; /* We were asked to shutdown. */
-
-            continue;
-        }
-
-#if 0
-        VBoxServiceVerbose(4, "[PID %u]: Polling done, pollRC=%Rrc, pollCnt=%u, rc=%Rrc, fShutdown=%RTbool\n",
-                           pThread->uPID, rc2, RTPollSetGetCount(hPollSet), rc, pThread->fShutdown);
+        }
+#ifdef DEBUG_andy
+        VBoxServiceVerbose(4, "[PID %RU32]: Polling done, pollRc=%Rrc, pollCnt=%u, idPollHnd=%RU32, rc=%Rrc, fProcessAlive=%RTbool, fShutdown=%RTbool\n",
+                           pProcess->uPID, rc2, RTPollSetGetCount(hPollSet), idPollHnd, rc, fProcessAlive, pProcess->fShutdown);
 #endif
+
+        if (RT_UNLIKELY(pProcess->fShutdown))
+            break; /* We were asked to shutdown. */
+
         /*
          * Check for process death.
@@ -725 +670 @@
         {
             rc2 = RTProcWaitNoResume(hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
+#ifdef DEBUG_andy
+            VBoxServiceVerbose(4, "[PID %RU32]: RTProcWaitNoResume=%Rrc, stdOut=%s, stdErrR=%s\n",
+                               pProcess->uPID, rc2,
+                               *phStdOutR == NIL_RTPIPE ? "closed" : "open",
+                               *phStdErrR == NIL_RTPIPE ? "closed" : "open");
+#endif
             if (RT_SUCCESS_NP(rc2))
             {
@@ -756 +707 @@
          */
         uint32_t cMilliesLeft = RT_INDEFINITE_WAIT;
-        if (cMsTimeout != RT_INDEFINITE_WAIT)
+        if (pProcess->StartupInfo.uTimeLimitMS != RT_INDEFINITE_WAIT)
         {
             uint64_t u64Now = RTTimeMilliTS();
-            uint64_t cMsElapsed = u64Now - MsStart;
-            if (cMsElapsed >= cMsTimeout)
+            uint64_t cMsElapsed = u64Now - uMsStart;
+            if (cMsElapsed >= pProcess->StartupInfo.uTimeLimitMS)
             {
-                VBoxServiceVerbose(3, "[PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...\n",
-                                   pThread->uPID, cMsElapsed, cMsTimeout);
+                VBoxServiceVerbose(3, "[PID %RU32]: Timed out (%RU32ms elapsed > %RU32ms timeout), killing ...\n",
+                                   pProcess->uPID, cMsElapsed, pProcess->StartupInfo.uTimeLimitMS);
 
                 fProcessTimedOut = true;
@@ -778 +729 @@
             }
             else
-                cMilliesLeft = cMsTimeout - (uint32_t)cMsElapsed;
+                cMilliesLeft = pProcess->StartupInfo.uTimeLimitMS - (uint32_t)cMsElapsed;
         }
 
@@ -787 +738 @@
         if (cMilliesLeft < cMsPollCur)
             cMsPollCur = cMilliesLeft;
-
-        /*
-         * Need to exit?
-         */
-        if (pThread->fShutdown)
-            break;
-    }
-
-    rc2 = RTCritSectEnter(&pThread->CritSect);
+    }
+
+    rc2 = RTCritSectEnter(&pProcess->CritSect);
     if (RT_SUCCESS(rc2))
     {
-        ASMAtomicXchgBool(&pThread->fShutdown, true);
-
-        rc2 = RTCritSectLeave(&pThread->CritSect);
+        ASMAtomicXchgBool(&pProcess->fShutdown, true);
+
+        rc2 = RTCritSectLeave(&pProcess->CritSect);
         AssertRC(rc2);
     }
@@ -811 +756 @@
         if (MsProcessKilled == UINT64_MAX)
         {
-            VBoxServiceVerbose(3, "[PID %u]: Is still alive and not killed yet\n",
-                               pThread->uPID);
+            VBoxServiceVerbose(3, "[PID %RU32]: Is still alive and not killed yet\n",
+                               pProcess->uPID);
 
             MsProcessKilled = RTTimeMilliTS();
@@ -821 +766 @@
         for (size_t i = 0; i < 10; i++)
         {
-            VBoxServiceVerbose(4, "[PID %u]: Kill attempt %d/10: Waiting to exit ...\n",
-                               pThread->uPID, i + 1);
+            VBoxServiceVerbose(4, "[PID %RU32]: Kill attempt %d/10: Waiting to exit ...\n",
+                               pProcess->uPID, i + 1);
             rc2 = RTProcWait(hProcess, RTPROCWAIT_FLAGS_NOBLOCK, &ProcessStatus);
             if (RT_SUCCESS(rc2))
             {
-                VBoxServiceVerbose(4, "[PID %u]: Kill attempt %d/10: Exited\n",
-                                   pThread->uPID, i + 1);
+                VBoxServiceVerbose(4, "[PID %RU32]: Kill attempt %d/10: Exited\n",
+                                   pProcess->uPID, i + 1);
                 fProcessAlive = false;
                 break;
@@ -833 +778 @@
             if (i >= 5)
             {
-                VBoxServiceVerbose(4, "[PID %u]: Kill attempt %d/10: Trying to terminate ...\n",
-                                   pThread->uPID, i + 1);
+                VBoxServiceVerbose(4, "[PID %RU32]: Kill attempt %d/10: Trying to terminate ...\n",
+                                   pProcess->uPID, i + 1);
                 RTProcTerminate(hProcess);
             }
@@ -841 +786 @@
 
         if (fProcessAlive)
-            VBoxServiceVerbose(3, "[PID %u]: Could not be killed\n", pThread->uPID);
+            VBoxServiceVerbose(3, "[PID %RU32]: Could not be killed\n", pProcess->uPID);
 
         if (   pReq /* Handle deferred termination request. */
@@ -865 +810 @@
         if (     fProcessTimedOut  && !fProcessAlive && MsProcessKilled != UINT64_MAX)
         {
-            VBoxServiceVerbose(3, "[PID %u]: Timed out and got killed\n",
-                               pThread->uPID);
+            VBoxServiceVerbose(3, "[PID %RU32]: Timed out and got killed\n",
+                               pProcess->uPID);
             uStatus = PROC_STS_TOK;
         }
         else if (fProcessTimedOut  &&  fProcessAlive && MsProcessKilled != UINT64_MAX)
         {
-            VBoxServiceVerbose(3, "[PID %u]: Timed out and did *not* get killed\n",
-                               pThread->uPID);
+            VBoxServiceVerbose(3, "[PID %RU32]: Timed out and did *not* get killed\n",
+                               pProcess->uPID);
             uStatus = PROC_STS_TOA;
         }
-        else if (pThread->fShutdown && (fProcessAlive || MsProcessKilled != UINT64_MAX))
-        {
-            VBoxServiceVerbose(3, "[PID %u]: Got terminated because system/service is about to shutdown\n",
-                               pThread->uPID);
+        else if (pProcess->fShutdown && (fProcessAlive || MsProcessKilled != UINT64_MAX))
+        {
+            VBoxServiceVerbose(3, "[PID %RU32]: Got terminated because system/service is about to shutdown\n",
+                               pProcess->uPID);
             uStatus = PROC_STS_DWN; /* Service is stopping, process was killed. */
-            uFlags = pThread->uFlags; /* Return handed-in execution flags back to the host. */
+            uFlags = pProcess->StartupInfo.uFlags; /* Return handed-in execution flags back to the host. */
         }
         else if (fProcessAlive)
         {
-            VBoxServiceError("[PID %u]: Is alive when it should not!\n",
-                             pThread->uPID);
+            VBoxServiceError("[PID %RU32]: Is alive when it should not!\n",
+                             pProcess->uPID);
         }
         else if (MsProcessKilled != UINT64_MAX)
         {
-            VBoxServiceError("[PID %u]: Has been killed when it should not!\n",
-                             pThread->uPID);
+            VBoxServiceError("[PID %RU32]: Has been killed when it should not!\n",
+                             pProcess->uPID);
         }
         else if (ProcessStatus.enmReason == RTPROCEXITREASON_NORMAL)
         {
-            VBoxServiceVerbose(3, "[PID %u]: Ended with RTPROCEXITREASON_NORMAL (Exit code: %u)\n",
-                               pThread->uPID, ProcessStatus.iStatus);
+            VBoxServiceVerbose(3, "[PID %RU32]: Ended with RTPROCEXITREASON_NORMAL (Exit code: %u)\n",
+                               pProcess->uPID, ProcessStatus.iStatus);
 
             uStatus = PROC_STS_TEN;
@@ -902 +847 @@
         else if (ProcessStatus.enmReason == RTPROCEXITREASON_SIGNAL)
         {
-            VBoxServiceVerbose(3, "[PID %u]: Ended with RTPROCEXITREASON_SIGNAL (Signal: %u)\n",
-                               pThread->uPID, ProcessStatus.iStatus);
+            VBoxServiceVerbose(3, "[PID %RU32]: Ended with RTPROCEXITREASON_SIGNAL (Signal: %u)\n",
+                               pProcess->uPID, ProcessStatus.iStatus);
 
             uStatus = PROC_STS_TES;
@@ -911 +856 @@
         {
             /* ProcessStatus.iStatus will be undefined. */
-            VBoxServiceVerbose(3, "[PID %u]: Ended with RTPROCEXITREASON_ABEND\n",
-                               pThread->uPID);
+            VBoxServiceVerbose(3, "[PID %RU32]: Ended with RTPROCEXITREASON_ABEND\n",
+                               pProcess->uPID);
 
             uStatus = PROC_STS_TEA;
@@ -918 +863 @@
         }
         else
-            VBoxServiceVerbose(1, "[PID %u]: Handling process status %u not implemented\n",
-                               pThread->uPID, ProcessStatus.enmReason);
-
-        VBoxServiceVerbose(2, "[PID %u]: Ended, ClientID=%u, CID=%u, Status=%u, Flags=0x%x\n",
-                           pThread->uPID, pThread->uClientID, pThread->uContextID, uStatus, uFlags);
-
-        if (!(pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_START))
-        {
-            VBGLR3GUESTCTRLCMDCTX ctx = { pThread->uClientID, pThread->uContextID };
+            VBoxServiceVerbose(1, "[PID %RU32]: Handling process status %u not implemented\n",
+                               pProcess->uPID, ProcessStatus.enmReason);
+
+        VBoxServiceVerbose(2, "[PID %RU32]: Ended, ClientID=%u, CID=%u, Status=%u, Flags=0x%x\n",
+                           pProcess->uPID, pProcess->uClientID, pProcess->uContextID, uStatus, uFlags);
+
+        if (!(pProcess->StartupInfo.uFlags & EXECUTEPROCESSFLAG_WAIT_START))
+        {
+            VBGLR3GUESTCTRLCMDCTX ctx = { pProcess->uClientID, pProcess->uContextID };
             rc2 = VbglR3GuestCtrlProcCbStatus(&ctx,
-                                              pThread->uPID, uStatus, uFlags,
+                                              pProcess->uPID, uStatus, uFlags,
                                               NULL /* pvData */, 0 /* cbData */);
             if (RT_FAILURE(rc2))
-                VBoxServiceError("[PID %u]: Error reporting final status to host; rc=%Rrc\n",
-                                 pThread->uPID, rc2);
+                VBoxServiceError("[PID %RU32]: Error reporting final status to host; rc=%Rrc\n",
+                                 pProcess->uPID, rc2);
             if (RT_SUCCESS(rc))
                 rc = rc2;
         }
         else
-            VBoxServiceVerbose(3, "[PID %u]: Was started detached, no final status sent to host\n",
-                               pThread->uPID);
-
-        VBoxServiceVerbose(3, "[PID %u]: Process loop ended with rc=%Rrc\n",
-                           pThread->uPID, rc);
+            VBoxServiceVerbose(3, "[PID %RU32]: Was started detached, no final status sent to host\n",
+                               pProcess->uPID);
+
+        VBoxServiceVerbose(3, "[PID %RU32]: Process loop ended with rc=%Rrc\n",
+                           pProcess->uPID, rc);
     }
     else
-        VBoxServiceError("[PID %u]: Loop failed with rc=%Rrc\n",
-                         pThread->uPID, rc);
+        VBoxServiceError("[PID %RU32]: Loop failed with rc=%Rrc\n",
+                         pProcess->uPID, rc);
     return rc;
 }
@@ -1034 +979 @@
 
 /**
- * Cancels a previously fired off guest thread request.
- *
- * Note: Does *not* do locking since GstCntlProcessRequestWait()
- * holds the lock (critsect); so only trigger the signal; the owner
- * needs to clean up afterwards.
+ * Cancels a previously fired off guest process request.
+ * Note: Caller is responsible for locking!
  *
  * @return  IPRT status code.
@@ -1357 +1299 @@
 
     AssertPtr(pThread->pSession);
-    int rc = RTCritSectEnter(&pThread->pSession->csControlThreads);
+    int rc = RTCritSectEnter(&pThread->pSession->CritSect);
     if (RT_SUCCESS(rc))
     {
@@ -1366 +1308 @@
         do
         {
-            RTListForEach(&pThread->pSession->lstControlThreadsActive, pThreadCur, VBOXSERVICECTRLPROCESS, Node)
+            RTListForEach(&pThread->pSession->lstProcessesActive, pThreadCur, VBOXSERVICECTRLPROCESS, Node)
             {
                 if (pThreadCur->uPID == uPID)
@@ -1384 +1326 @@
         pThread->uPID = uPID;
 
-        rc = RTCritSectLeave(&pThread->pSession->csControlThreads);
+        rc = RTCritSectLeave(&pThread->pSession->CritSect);
         AssertRC(rc);
     }
@@ -1562 +1504 @@
     AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
     VBoxServiceVerbose(3, "Thread of process pThread=0x%p = \"%s\" started\n",
-                       pProcess, pProcess->pszCmd);
+                       pProcess, pProcess->StartupInfo.szCmd);
 
     int rc = GstCntlSessionListSet(pProcess->pSession,
@@ -1576 +1518 @@
     }
     VBoxServiceVerbose(3, "Guest process \"%s\" got client ID=%u, flags=0x%x\n",
-                       pProcess->pszCmd, pProcess->uClientID, pProcess->uFlags);
+                       pProcess->StartupInfo.szCmd, pProcess->uClientID, pProcess->StartupInfo.uFlags);
 
     bool fSignalled = false; /* Indicator whether we signalled the thread user event already. */
+
+    /*
+     * Prepare argument list.
+     */
+    char **papszArgs;
+    uint32_t uNumArgs = 0; /* Initialize in case of RTGetOptArgvFromString() is failing ... */
+    rc = RTGetOptArgvFromString(&papszArgs, (int*)&uNumArgs,
+                                (pProcess->StartupInfo.uNumArgs > 0) ? pProcess->StartupInfo.szArgs : "", NULL);
+    /* Did we get the same result? */
+    Assert(pProcess->StartupInfo.uNumArgs == uNumArgs);
+
+    /*
+     * Prepare environment variables list.
+     */
+    char **papszEnv;
+    uint32_t uNumEnvVars = 0; /* Initialize in case of failing ... */
+    if (RT_SUCCESS(rc))
+    {
+        /* Prepare environment list. */
+        if (pProcess->StartupInfo.uNumEnvVars)
+        {
+            papszEnv = (char **)RTMemAlloc(pProcess->StartupInfo.uNumEnvVars * sizeof(char*));
+            AssertPtr(papszEnv);
+            uNumEnvVars = pProcess->StartupInfo.uNumEnvVars;
+
+            const char *pszCur = pProcess->StartupInfo.szEnv;
+            uint32_t i = 0;
+            uint32_t cbLen = 0;
+            while (cbLen < pProcess->StartupInfo.cbEnv)
+            {
+                /* sanity check */
+                if (i >= pProcess->StartupInfo.uNumEnvVars)
+                {
+                    rc = VERR_INVALID_PARAMETER;
+                    break;
+                }
+                int cbStr = RTStrAPrintf(&papszEnv[i++], "%s", pszCur);
+                if (cbStr < 0)
+                {
+                    rc = VERR_NO_STR_MEMORY;
+                    break;
+                }
+                pszCur += cbStr + 1; /* Skip terminating '\0' */
+                cbLen  += cbStr + 1; /* Skip terminating '\0' */
+            }
+            Assert(i == pProcess->StartupInfo.uNumEnvVars);
+        }
+    }
 
     /*
@@ -1588 +1578 @@
     {
         size_t i;
-        for (i = 0; i < pProcess->uNumEnvVars && pProcess->papszEnv; i++)
-        {
-            rc = RTEnvPutEx(hEnv, pProcess->papszEnv[i]);
+        for (i = 0; i < uNumEnvVars && papszEnv; i++)
+        {
+            rc = RTEnvPutEx(hEnv, papszEnv[i]);
             if (RT_FAILURE(rc))
                 break;
@@ -1609 +1599 @@
                 PRTHANDLE   phStdOut;
                 RTPIPE      pipeStdOutR;
-                rc = gstcntlProcessSetupPipe(  (pProcess->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)
+                rc = gstcntlProcessSetupPipe(  (pProcess->StartupInfo.uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)
                                              ? "|" : "/dev/null",
                                              1 /*STDOUT_FILENO*/,
@@ -1618 +1608 @@
                     PRTHANDLE   phStdErr;
                     RTPIPE      pipeStdErrR;
-                    rc = gstcntlProcessSetupPipe(  (pProcess->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)
+                    rc = gstcntlProcessSetupPipe(  (pProcess->StartupInfo.uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)
                                                  ? "|" : "/dev/null",
                                                  2 /*STDERR_FILENO*/,
@@ -1658 +1648 @@
 
                                 RTPROCESS hProcess;
-                                rc = gstcntlProcessCreateProcess(pProcess->pszCmd, pProcess->papszArgs, hEnv, pProcess->uFlags,
+                                rc = gstcntlProcessCreateProcess(pProcess->StartupInfo.szCmd, papszArgs, hEnv, pProcess->StartupInfo.uFlags,
                                                                  phStdIn, phStdOut, phStdErr,
-                                                                 fNeedsImpersonation ? pProcess->pszUser : NULL,
-                                                                 fNeedsImpersonation ? pProcess->pszPassword : NULL,
+                                                                 fNeedsImpersonation ? pProcess->StartupInfo.szUser : NULL,
+                                                                 fNeedsImpersonation ? pProcess->StartupInfo.szPassword : NULL,
                                                                  &hProcess);
                                 if (RT_FAILURE(rc))
@@ -1689 +1679 @@
 
                                     /* Enter the process loop. */
-                                    rc = gstcntlProcessProcLoop(pProcess,
-                                                                hProcess, pProcess->uTimeLimitMS, hPollSet,
+                                    rc = gstcntlProcessProcLoop(pProcess, hProcess, hPollSet,
                                                                 &pProcess->pipeStdInW, &pipeStdOutR, &pipeStdErrR);
 
@@ -1759 +1748 @@
         /* Disconnect this client from the guest control service. This also cancels all
          * outstanding host requests. */
-        VBoxServiceVerbose(3, "[PID %u]: Disconnecting (client ID=%u) ...\n",
+        VBoxServiceVerbose(3, "[PID %RU32]: Disconnecting (client ID=%u) ...\n",
                            pProcess->uPID, pProcess->uClientID);
         VbglR3GuestCtrlDisconnect(pProcess->uClientID);
@@ -1765 +1754 @@
     }
 
-    VBoxServiceVerbose(3, "[PID %u]: Thread of process \"%s\" ended with rc=%Rrc\n",
-                       pProcess->uPID, pProcess->pszCmd, rc);
+    VBoxServiceVerbose(3, "[PID %RU32]: Thread of process \"%s\" ended with rc=%Rrc\n",
+                       pProcess->uPID, pProcess->StartupInfo.szCmd, rc);
+
+    /* Free argument + environment variable lists. */
+    if (uNumEnvVars)
+    {
+        for (uint32_t i = 0; i < uNumEnvVars; i++)
+            RTStrFree(papszEnv[i]);
+        RTMemFree(papszEnv);
+    }
+    if (uNumArgs)
+        RTGetOptArgvFree(papszArgs);
 
     /* Update started/stopped status. */
@@ -1779 +1778 @@
         RTThreadUserSignal(RTThreadSelf());
 
+    VBoxServiceVerbose(3, "[PID %RU32]: Thread returned with rc=%Rrc\n",
+                       pProcess->uPID, rc);
     return rc;
 }
@@ -1867 +1868 @@
  * Performs a request to a specific (formerly started) guest process and waits
  * for its response.
- * Note: Caller is responsible of locking!
+ * Note: Caller is responsible for locking!
  *
  * @return  IPRT status code.
@@ -1889 +1890 @@
     else
     {
+        VBoxServiceVerbose(3, "[PID %RU32]: Sending pRequest=%p\n",
+                           pProcess->uPID, pRequest);
+
         /* Set request structure pointer. */
         pProcess->pRequest = pRequest;
@@ -1894 +1898 @@
         /** @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
+        /* Wake up guest thread by sending a wakeup byte to the notification pipe so
          * that RTPoll unblocks (returns) and we then can do our requested operation. */
         Assert(pProcess->hNotificationPipeW != NIL_RTPIPE);
-        size_t cbWritten;
+        size_t cbWritten = 0;
         if (RT_SUCCESS(rc))
             rc = RTPipeWrite(pProcess->hNotificationPipeW, "i", 1, &cbWritten);
 
-        if (   RT_SUCCESS(rc)
-            && cbWritten)
-        {
-            VBoxServiceVerbose(3, "[PID %u]: Waiting for response on enmType=%u, pvData=0x%p, cbData=%u\n",
-                               pProcess->uPID, pRequest->enmType, pRequest->pvData, pRequest->cbData);
+        if (RT_SUCCESS(rc))
+        {
+            Assert(cbWritten);
+            VBoxServiceVerbose(3, "[PID %RU32]: Waiting for response on pRequest=%p, enmType=%u, pvData=0x%p, cbData=%u\n",
+                               pProcess->uPID, pRequest, pRequest->enmType, pRequest->pvData, pRequest->cbData);
 
             rc = GstCntlProcessRequestWait(pRequest);
@@ -1911 +1915 @@
     }
 
-    VBoxServiceVerbose(3, "[PID %u]: Performed enmType=%u, uCID=%u, pvData=0x%p, cbData=%u, rc=%Rrc\n",
-                       pProcess->uPID, pRequest->enmType, pRequest->uCID, pRequest->pvData, pRequest->cbData, rc);
+    VBoxServiceVerbose(3, "[PID %RU32]: Performed pRequest=%p, enmType=%u, uCID=%u, pvData=0x%p, cbData=%u, rc=%Rrc\n",
+                       pProcess->uPID, pRequest, pRequest->enmType, pRequest->uCID, pRequest->pvData, pRequest->cbData, rc);
     return rc;
 }

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

@@ -70 +70 @@
     VBOXSERVICESESSIONOPT_USERNAME,
     VBOXSERVICESESSIONOPT_SESSION_ID,
-    VBOXSERVICESESSIONOPT_SESSION_PROTO
+    VBOXSERVICESESSIONOPT_SESSION_PROTO,
+    VBOXSERVICESESSIONOPT_THREAD_ID
 };
 
@@ -568 +569 @@
         if (RT_SUCCESS(rc))
         {
-            VBoxServiceVerbose(3, "Request to start process szCmd=%s, uFlags=0x%x, szArgs=%s, szEnv=%s, szUser=%s, szPassword=%s, uTimeout=%RU32\n",
+            VBoxServiceVerbose(3, "Request to start process szCmd=%s, uFlags=0x%x, szArgs=%s, szEnv=%s, uTimeout=%RU32\n",
                                startupInfo.szCmd, startupInfo.uFlags,
                                startupInfo.uNumArgs ? startupInfo.szArgs : "<None>",
                                startupInfo.uNumEnvVars ? startupInfo.szEnv : "<None>",
-                               startupInfo.szUser,
-#ifdef DEBUG
-                               startupInfo.szPassword,
-#else
-                               "XXX", /* Never show passwords in release mode. */
-#endif
                                startupInfo.uTimeLimitMS);
 
-            rc = GstCntlSessionReapProcesses(pSession);
+            /*rc = GstCntlSessionReapProcesses(pSession);
             if (RT_FAILURE(rc))
-                VBoxServiceError("Reaping stopped guest processes failed with rc=%Rrc\n", rc);
+                VBoxServiceError("Reaping stopped guest processes failed with rc=%Rrc\n", rc);*/
             /* Keep going. */
 
@@ -741 +736 @@
 
     int rc = VbglR3GuestCtrlProcGetOutput(pHostCtx, &uPID, &uHandleID, &uFlags);
+#ifdef DEBUG_andy
+    VBoxServiceVerbose(4, "[PID %RU32]: Get output CID=%RU32, uHandleID=%RU32, uFlags=%RU32\n",
+                       uPID, pHostCtx->uContextID, uHandleID, uFlags);
+#endif
     if (RT_SUCCESS(rc))
     {
@@ -750 +749 @@
                                          pHostCtx->uContextID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
                                          pBuf, _64K /* cbSize */, &cbRead);
-            VBoxServiceVerbose(3, "[PID %RU32]: Got output, rc=%Rrc, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
+            VBoxServiceVerbose(3, "[PID %RU32]: Got output, rc=%Rrc, CID=%RU32, cbRead=%RU32, uHandle=%RU32, uFlags=%x\n",
                                uPID, rc, pHostCtx->uContextID, cbRead, uHandleID, uFlags);
 
@@ -973 +972 @@
 
         default:
-            VBoxServiceVerbose(3, "Unsupported message from host, uMsg=%RU32, cParms=%RU32\n",
+            rc = VbglR3GuestCtrlMsgSkip(pHostCtx->uClientID);
+            VBoxServiceVerbose(3, "Unsupported message (uMsg=%RU32, cParms=%RU32) from host, skipping\n",
                                uMsg, pHostCtx->uNumParms);
-            /* Don't terminate here; just wait for the next message. */
             break;
     }
@@ -1008 +1007 @@
     }
     else
+    {
         VBoxServiceError("Error connecting to guest control service, rc=%Rrc\n", rc);
+        return rc;
+    }
 
     /* Let caller know that we're done initializing. */
-    int rc2 = RTThreadUserSignal(RTThreadSelf());
-    if (RT_SUCCESS(rc))
-        rc = rc2;
+    rc = RTThreadUserSignal(RTThreadSelf());
+    if (RT_FAILURE(rc))
+        return rc;
 
     bool fProcessAlive = true;
@@ -1019 +1021 @@
     RT_ZERO(ProcessStatus);
 
+    int rcWait;
     if (RT_SUCCESS(rc))
     {
@@ -1024 +1027 @@
         uint64_t u64TimeoutStart = 0;
 
-        int rcWait;
         for (;;)
         {
@@ -1048 +1050 @@
                                        uSessionID);
                     u64TimeoutStart = RTTimeMilliTS();
+                    continue; /* Don't waste time on waiting. */
                 }
                 if (RTTimeMilliTS() - u64TimeoutStart > uTimeoutsMS)
@@ -1084 +1087 @@
         }
 
-        VBoxServiceVerbose(2, "Guest session ID=%RU32 process has been killed with rc=%Rc\n",
+        VBoxServiceVerbose(2, "Guest session ID=%RU32 process termination resulted in rc=%Rrc\n",
                            uSessionID, rc);
 
@@ -1092 +1095 @@
     else
     {
-        switch (ProcessStatus.enmReason)
-        {
-            case RTPROCEXITREASON_NORMAL:
-                uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEN;
-                break;
-
-            case RTPROCEXITREASON_ABEND:
-                uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEA;
-                break;
-
-            case RTPROCEXITREASON_SIGNAL:
-                uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TES;
-                break;
-
-            default:
-                AssertMsgFailed(("Unhandled process termination reason (%ld)",
-                                 ProcessStatus.enmReason));
-                uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEA;
-                break;
-        }
-    }
-
-    VBoxServiceVerbose(3, "Guest session ID=%RU32 thread ended with sessionStatus=%ld, sessionRc=%Rrc\n",
+        if (RT_SUCCESS(rcWait))
+        {
+            switch (ProcessStatus.enmReason)
+            {
+                case RTPROCEXITREASON_NORMAL:
+                    uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEN;
+                    break;
+
+                case RTPROCEXITREASON_ABEND:
+                    uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEA;
+                    break;
+
+                case RTPROCEXITREASON_SIGNAL:
+                    uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TES;
+                    break;
+
+                default:
+                    AssertMsgFailed(("Unhandled process termination reason (%ld)\n",
+                                     ProcessStatus.enmReason));
+                    uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEA;
+                    break;
+            }
+        }
+        else
+        {
+            /* If we didn't find the guest process anymore, just assume it
+             * terminated normally. */
+            uSessionStatus = GUEST_SESSION_NOTIFYTYPE_TEN;
+        }
+    }
+
+    VBoxServiceVerbose(3, "Guest session ID=%RU32 thread ended with sessionStatus=%RU32, sessionRc=%Rrc\n",
                        uSessionID, uSessionStatus, uSessionRc);
 
@@ -1120 +1132 @@
     Assert(uSessionStatus != GUEST_SESSION_NOTIFYTYPE_UNDEFINED);
     VBGLR3GUESTCTRLCMDCTX ctx = { uClientID, VBOX_GUESTCTRL_CONTEXTID_MAKE_SESSION(uSessionID) };
-    rc2 = VbglR3GuestCtrlSessionNotify(&ctx,
-                                       uSessionStatus, uSessionRc);
+    int rc2 = VbglR3GuestCtrlSessionNotify(&ctx,
+                                           uSessionStatus, uSessionRc);
     if (RT_FAILURE(rc2))
         VBoxServiceError("Reporting session ID=%RU32 final status failed with rc=%Rrc\n",
@@ -1254 +1266 @@
     AssertPtrReturn(pSession, NULL);
 
-    PVBOXSERVICECTRLPROCESS pThread = NULL;
-    int rc = RTCritSectEnter(&pSession->csControlThreads);
-    if (RT_SUCCESS(rc))
-    {
-        PVBOXSERVICECTRLPROCESS pThreadCur;
-        RTListForEach(&pSession->lstControlThreadsActive, pThreadCur, VBOXSERVICECTRLPROCESS, Node)
-        {
-            if (pThreadCur->uPID == uPID)
-            {
-                rc = RTCritSectEnter(&pThreadCur->CritSect);
+    PVBOXSERVICECTRLPROCESS pProcess = NULL;
+    int rc = RTCritSectEnter(&pSession->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        PVBOXSERVICECTRLPROCESS pCurProcess;
+        RTListForEach(&pSession->lstProcessesActive, pCurProcess, VBOXSERVICECTRLPROCESS, Node)
+        {
+            if (pCurProcess->uPID == uPID)
+            {
+                rc = RTCritSectEnter(&pCurProcess->CritSect);
                 if (RT_SUCCESS(rc))
-                    pThread = pThreadCur;
+                    pProcess = pCurProcess;
                 break;
             }
         }
 
-        int rc2 = RTCritSectLeave(&pSession->csControlThreads);
+        int rc2 = RTCritSectLeave(&pSession->CritSect);
         if (RT_SUCCESS(rc))
             rc = rc2;
     }
 
-    return pThread;
+    return pProcess;
 }
 
@@ -1286 +1298 @@
                        pSession->StartupInfo.uSessionID);
 
-    /*
-     * Close all guest processes.
-     */
-
-    /* Signal all guest processes in the active list that we want to shutdown. */
-    PVBOXSERVICECTRLPROCESS pProcess;
-    RTListForEach(&pSession->lstControlThreadsActive, pProcess, VBOXSERVICECTRLPROCESS, Node)
-        GstCntlProcessStop(pProcess);
-
-    /* Wait for all active threads to shutdown and destroy the active thread list. */
-    pProcess = RTListGetFirst(&pSession->lstControlThreadsActive, VBOXSERVICECTRLPROCESS, Node);
-    while (pProcess)
-    {
-        PVBOXSERVICECTRLPROCESS pNext = RTListNodeGetNext(&pProcess->Node, VBOXSERVICECTRLPROCESS, Node);
-        bool fLast = RTListNodeIsLast(&pSession->lstControlThreadsActive, &pProcess->Node);
-
-        int rc2 = GstCntlProcessWait(pProcess,
-                                     30 * 1000 /* Wait 30 seconds max. */,
-                                     NULL /* rc */);
-        if (RT_FAILURE(rc2))
-        {
-            VBoxServiceError("Guest process thread failed to stop; rc=%Rrc\n", rc2);
-            /* Keep going. */
-        }
-
-        if (fLast)
-            break;
-
-        pProcess = pNext;
-    }
-
-    int rc = GstCntlSessionReapProcesses(pSession);
-    if (RT_FAILURE(rc))
-        VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc);
-
-    AssertMsg(RTListIsEmpty(&pSession->lstControlThreadsActive),
-              ("Guest process active thread list still contains entries when it should not\n"));
-    AssertMsg(RTListIsEmpty(&pSession->lstControlThreadsInactive),
-              ("Guest process inactive thread list still contains entries when it should not\n"));
-
-    /*
-     * Close all left guest files.
-     */
-    PVBOXSERVICECTRLFILE pFile;
-    pFile = RTListGetFirst(&pSession->lstFiles, VBOXSERVICECTRLFILE, Node);
-    while (pFile)
-    {
-        PVBOXSERVICECTRLFILE pNext = RTListNodeGetNext(&pFile->Node, VBOXSERVICECTRLFILE, Node);
-        bool fLast = RTListNodeIsLast(&pSession->lstFiles, &pFile->Node);
-
-        int rc2 = gstcntlSessionFileDestroy(pFile);
-        if (RT_FAILURE(rc2))
-        {
-            VBoxServiceError("Unable to close file \"%s\"; rc=%Rrc\n",
-                             pFile->szName, rc2);
-            /* Keep going. */
-        }
-
-        if (fLast)
-            break;
-
-        pFile = pNext;
-    }
-
-    AssertMsg(RTListIsEmpty(&pSession->lstFiles),
-              ("Guest file list still contains entries when it should not\n"));
+    int rc = RTCritSectEnter(&pSession->CritSect);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Close all guest processes.
+         */
+
+        /* Signal all guest processes in the active list that we want to shutdown. */
+        PVBOXSERVICECTRLPROCESS pProcess;
+        RTListForEach(&pSession->lstProcessesActive, pProcess, VBOXSERVICECTRLPROCESS, Node)
+            GstCntlProcessStop(pProcess);
+
+        /* Wait for all active threads to shutdown and destroy the active thread list. */
+        pProcess = RTListGetFirst(&pSession->lstProcessesActive, VBOXSERVICECTRLPROCESS, Node);
+        while (pProcess)
+        {
+            PVBOXSERVICECTRLPROCESS pNext = RTListNodeGetNext(&pProcess->Node, VBOXSERVICECTRLPROCESS, Node);
+            bool fLast = RTListNodeIsLast(&pSession->lstProcessesActive, &pProcess->Node);
+
+            int rc2 = GstCntlProcessWait(pProcess,
+                                         30 * 1000 /* Wait 30 seconds max. */,
+                                         NULL /* rc */);
+            if (RT_FAILURE(rc2))
+            {
+                VBoxServiceError("Guest process thread failed to stop; rc=%Rrc\n", rc2);
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+                /* Keep going. */
+            }
+
+            rc2 = GstCntlProcessFree(pProcess);
+            if (RT_FAILURE(rc2))
+            {
+                VBoxServiceError("Guest process thread failed to free; rc=%Rrc\n", rc2);
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+                /* Keep going. */
+            }
+
+            RTListNodeRemove(&pProcess->Node);
+
+            if (fLast)
+                break;
+
+            pProcess = pNext;
+        }
+
+        /*rc = GstCntlSessionReapProcesses(pSession);
+        if (RT_FAILURE(rc))
+            VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc);*/
+
+        AssertMsg(RTListIsEmpty(&pSession->lstProcessesActive),
+                  ("Guest process active thread list still contains entries when it should not\n"));
+        /*AssertMsg(RTListIsEmpty(&pSession->lstProcessesInactive),
+                  ("Guest process inactive thread list still contains entries when it should not\n"));*/
+
+        /*
+         * Close all left guest files.
+         */
+        PVBOXSERVICECTRLFILE pFile;
+        pFile = RTListGetFirst(&pSession->lstFiles, VBOXSERVICECTRLFILE, Node);
+        while (pFile)
+        {
+            PVBOXSERVICECTRLFILE pNext = RTListNodeGetNext(&pFile->Node, VBOXSERVICECTRLFILE, Node);
+            bool fLast = RTListNodeIsLast(&pSession->lstFiles, &pFile->Node);
+
+            int rc2 = gstcntlSessionFileDestroy(pFile);
+            if (RT_FAILURE(rc2))
+            {
+                VBoxServiceError("Unable to close file \"%s\"; rc=%Rrc\n",
+                                 pFile->szName, rc2);
+                if (RT_SUCCESS(rc))
+                    rc = rc2;
+                /* Keep going. */
+            }
+
+            if (fLast)
+                break;
+
+            pFile = pNext;
+        }
+
+        AssertMsg(RTListIsEmpty(&pSession->lstFiles),
+                  ("Guest file list still contains entries when it should not\n"));
+
+        int rc2 = RTCritSectLeave(&pSession->CritSect);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
 
     return rc;
@@ -1364 +1399 @@
 
     /* Destroy critical section. */
-    RTCritSectDelete(&pSession->csControlThreads);
+    RTCritSectDelete(&pSession->CritSect);
 
     return rc;
@@ -1441 +1476 @@
     AssertPtrReturn(pSession, VERR_INVALID_POINTER);
 
-    RTListInit(&pSession->lstControlThreadsActive);
-    RTListInit(&pSession->lstControlThreadsInactive);
+    RTListInit(&pSession->lstProcessesActive);
+    RTListInit(&pSession->lstProcessesInactive);
     RTListInit(&pSession->lstFiles);
 
@@ -1457 +1492 @@
 
     /* Init critical section for protecting the thread lists. */
-    int rc = RTCritSectInit(&pSession->csControlThreads);
+    int rc = RTCritSectInit(&pSession->CritSect);
     AssertRC(rc);
 
@@ -1481 +1516 @@
     AssertPtrReturn(pProcess, VERR_INVALID_POINTER);
 
-    int rc = RTCritSectEnter(&pSession->csControlThreads);
+    int rc = RTCritSectEnter(&pSession->CritSect);
     if (RT_SUCCESS(rc))
     {
@@ -1491 +1526 @@
         {
             case VBOXSERVICECTRLTHREADLIST_STOPPED:
-                pAnchor = &pSession->lstControlThreadsInactive;
+                pAnchor = &pSession->lstProcessesInactive;
                 break;
 
             case VBOXSERVICECTRLTHREADLIST_RUNNING:
-                pAnchor = &pSession->lstControlThreadsActive;
+                pAnchor = &pSession->lstProcessesActive;
                 break;
 
             default:
-                AssertMsgFailed(("Unknown list type: %u", enmList));
+                AssertMsgFailed(("Unknown list type: %u\n",
+                                 enmList));
                 break;
         }
@@ -1520 +1556 @@
         }
 
-        int rc2 = RTCritSectLeave(&pSession->csControlThreads);
+        int rc2 = RTCritSectLeave(&pSession->CritSect);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -1546 +1582 @@
     AssertPtrReturn(pbAllowed, VERR_INVALID_POINTER);
 
-    int rc = RTCritSectEnter(&pSession->csControlThreads);
+    int rc = RTCritSectEnter(&pSession->CritSect);
     if (RT_SUCCESS(rc))
     {
@@ -1557 +1593 @@
         {
             uint32_t uProcsRunning = 0;
-            PVBOXSERVICECTRLPROCESS pThread;
-            RTListForEach(&pSession->lstControlThreadsActive, pThread, VBOXSERVICECTRLPROCESS, Node)
+            PVBOXSERVICECTRLPROCESS pProcess;
+            RTListForEach(&pSession->lstProcessesActive, pProcess, VBOXSERVICECTRLPROCESS, Node)
                 uProcsRunning++;
 
@@ -1575 +1611 @@
         *pbAllowed = !fLimitReached;
 
-        int rc2 = RTCritSectLeave(&pSession->csControlThreads);
+        int rc2 = RTCritSectLeave(&pSession->CritSect);
         if (RT_SUCCESS(rc))
             rc = rc2;
@@ -1583 +1619 @@
 }
 
-
+#if 0
 /**
  * Reaps all inactive guest process threads.
+ * Does not do locking; this is the job of the caller.
  *
  * @return  IPRT status code.
@@ -1593 +1630 @@
     AssertPtrReturn(pSession, VERR_INVALID_POINTER);
 
-    int rc = RTCritSectEnter(&pSession->csControlThreads);
-    if (RT_SUCCESS(rc))
-    {
-        PVBOXSERVICECTRLPROCESS pThread =
-            RTListGetFirst(&pSession->lstControlThreadsInactive, VBOXSERVICECTRLPROCESS, Node);
-        while (pThread)
-        {
-            PVBOXSERVICECTRLPROCESS pNext = RTListNodeGetNext(&pThread->Node, VBOXSERVICECTRLPROCESS, Node);
-            bool fLast = RTListNodeIsLast(&pSession->lstControlThreadsInactive, &pThread->Node);
-            int rc2 = GstCntlProcessWait(pThread, 30 * 1000 /* 30 seconds max. */,
-                                         NULL /* rc */);
-            if (RT_SUCCESS(rc2))
-            {
-                RTListNodeRemove(&pThread->Node);
-
-                rc2 = GstCntlProcessFree(pThread);
-                if (RT_FAILURE(rc2))
-                {
-                    VBoxServiceError("Freeing guest process thread failed with rc=%Rrc\n", rc2);
-                    if (RT_SUCCESS(rc)) /* Keep original failure. */
-                        rc = rc2;
-                }
-            }
-            else
-                VBoxServiceError("Waiting on guest process thread failed with rc=%Rrc\n", rc2);
-            /* Keep going. */
-
-            if (fLast)
-                break;
-
-            pThread = pNext;
-        }
-
-        int rc2 = RTCritSectLeave(&pSession->csControlThreads);
-        if (RT_SUCCESS(rc))
-            rc = rc2;
+    PVBOXSERVICECTRLPROCESS pThread =
+        RTListGetFirst(&pSession->lstProcessesInactive, VBOXSERVICECTRLPROCESS, Node);
+    while (pThread)
+    {
+        PVBOXSERVICECTRLPROCESS pNext = RTListNodeGetNext(&pThread->Node, VBOXSERVICECTRLPROCESS, Node);
+        bool fLast = RTListNodeIsLast(&pSession->lstProcessesInactive, &pThread->Node);
+        int rc2 = GstCntlProcessWait(pThread, 30 * 1000 /* 30 seconds max. */,
+                                     NULL /* rc */);
+        if (RT_SUCCESS(rc2))
+        {
+            RTListNodeRemove(&pThread->Node);
+
+            rc2 = GstCntlProcessFree(pThread);
+            if (RT_FAILURE(rc2))
+            {
+                VBoxServiceError("Freeing guest process thread failed with rc=%Rrc\n", rc2);
+                if (RT_SUCCESS(rc)) /* Keep original failure. */
+                    rc = rc2;
+            }
+        }
+        else
+            VBoxServiceError("Waiting on guest process thread failed with rc=%Rrc\n", rc2);
+        /* Keep going. */
+
+        if (fLast)
+            break;
+
+        pThread = pNext;
     }
 
@@ -1634 +1663 @@
     return rc;
 }
+#endif
 
 
@@ -1700 +1730 @@
  *                                  Optional.
  */
-int GstCntlSessionThreadOpen(PRTLISTANCHOR pList,
-                             const PVBOXSERVICECTRLSESSIONSTARTUPINFO pSessionStartupInfo,
-                             PVBOXSERVICECTRLSESSIONTHREAD *ppSessionThread)
+int GstCntlSessionThreadCreate(PRTLISTANCHOR pList,
+                               const PVBOXSERVICECTRLSESSIONSTARTUPINFO pSessionStartupInfo,
+                               PVBOXSERVICECTRLSESSIONTHREAD *ppSessionThread)
 {
     AssertPtrReturn(pList, VERR_INVALID_POINTER);
@@ -1716 +1746 @@
         if (pSessionCur->StartupInfo.uSessionID == pSessionStartupInfo->uSessionID)
         {
-            AssertMsgFailed(("Guest session %RU32 (%p) already exists when it should not",
+            AssertMsgFailed(("Guest session thread ID=%RU32 (%p) already exists when it should not\n",
                              pSessionCur->StartupInfo.uSessionID, pSessionCur));
             return VERR_ALREADY_EXISTS;
@@ -1724 +1754 @@
     int rc = VINF_SUCCESS;
 
-    PVBOXSERVICECTRLSESSIONTHREAD pSession = (PVBOXSERVICECTRLSESSIONTHREAD)RTMemAllocZ(sizeof(VBOXSERVICECTRLSESSIONTHREAD));
-    if (pSession)
+    /* Static counter to help tracking session thread <-> process relations. */
+    static uint32_t s_uCtrlSessionThread = 0;
+    if (s_uCtrlSessionThread++ == UINT32_MAX)
+        s_uCtrlSessionThread = 0; /* Wrap around to not let IPRT freak out. */
+
+    PVBOXSERVICECTRLSESSIONTHREAD pSessionThread =
+        (PVBOXSERVICECTRLSESSIONTHREAD)RTMemAllocZ(sizeof(VBOXSERVICECTRLSESSIONTHREAD));
+    if (pSessionThread)
     {
         /* Copy over session startup info. */
-        memcpy(&pSession->StartupInfo, pSessionStartupInfo, sizeof(VBOXSERVICECTRLSESSIONSTARTUPINFO));
-
-        pSession->fShutdown = false;
-        pSession->fStarted  = false;
-        pSession->fStopped  = false;
+        memcpy(&pSessionThread->StartupInfo, pSessionStartupInfo,
+               sizeof(VBOXSERVICECTRLSESSIONSTARTUPINFO));
+
+        pSessionThread->fShutdown = false;
+        pSessionThread->fStarted  = false;
+        pSessionThread->fStopped  = false;
 
         /* Is this an anonymous session? */
         /* Anonymous sessions run with the same privileges as the main VBoxService executable. */
-        bool fAnonymous = !RT_BOOL(strlen(pSession->StartupInfo.szUser));
+        bool fAnonymous = !RT_BOOL(strlen(pSessionThread->StartupInfo.szUser));
         if (fAnonymous)
         {
-            Assert(!strlen(pSession->StartupInfo.szPassword));
-            Assert(!strlen(pSession->StartupInfo.szDomain));
+            Assert(!strlen(pSessionThread->StartupInfo.szPassword));
+            Assert(!strlen(pSessionThread->StartupInfo.szDomain));
 
             VBoxServiceVerbose(3, "New anonymous guest session ID=%RU32 created, uFlags=%x, using protocol %RU32\n",
@@ -1762 +1799 @@
         }
 
-        rc = RTCritSectInit(&pSession->CritSect);
+        rc = RTCritSectInit(&pSessionThread->CritSect);
         AssertRC(rc);
 
@@ -1773 +1810 @@
             if (!fAnonymous)
             {
-                if (!RTStrPrintf(szParmUserName, sizeof(szParmUserName), "--username=%s", pSession->StartupInfo.szUser))
+                if (!RTStrPrintf(szParmUserName, sizeof(szParmUserName), "--user=%s", pSessionThread->StartupInfo.szUser))
                     rc = VERR_BUFFER_OVERFLOW;
             }
             char szParmSessionID[32];
             if (RT_SUCCESS(rc) && !RTStrPrintf(szParmSessionID, sizeof(szParmSessionID), "--session-id=%RU32",
-                                               pSession->StartupInfo.uSessionID))
+                                               pSessionThread->StartupInfo.uSessionID))
             {
                 rc = VERR_BUFFER_OVERFLOW;
@@ -1784 +1821 @@
             char szParmSessionProto[32];
             if (RT_SUCCESS(rc) && !RTStrPrintf(szParmSessionProto, sizeof(szParmSessionProto), "--session-proto=%RU32",
-                                               pSession->StartupInfo.uProtocol))
+                                               pSessionThread->StartupInfo.uProtocol))
             {
                 rc = VERR_BUFFER_OVERFLOW;
             }
-
+#ifdef DEBUG
+            char szParmThreadId[32];
+            if (RT_SUCCESS(rc) && !RTStrPrintf(szParmThreadId, sizeof(szParmThreadId), "--thread-id=%RU32",
+                                               s_uCtrlSessionThread))
+            {
+                rc = VERR_BUFFER_OVERFLOW;
+            }
+#endif /* DEBUG */
             if (RT_SUCCESS(rc))
             {
                 int iOptIdx = 0; /* Current index in argument vector. */
 
-                char const *papszArgs[8];
+                char const *papszArgs[16];
                 papszArgs[iOptIdx++] = pszExeName;
                 papszArgs[iOptIdx++] = "guestsession";
                 papszArgs[iOptIdx++] = szParmSessionID;
                 papszArgs[iOptIdx++] = szParmSessionProto;
+#ifdef DEBUG
+                papszArgs[iOptIdx++] = szParmThreadId;
+#endif /* DEBUG */
                 if (!fAnonymous)
                     papszArgs[iOptIdx++] = szParmUserName;
@@ -1829 +1876 @@
                         RTPathStripExt(pszLogFile);
                         char *pszLogSuffix;
+#ifndef DEBUG
                         if (RTStrAPrintf(&pszLogSuffix, "-%RU32-%s",
                                          pSessionStartupInfo->uSessionID,
@@ -1835 +1883 @@
                             rc2 = VERR_NO_MEMORY;
                         }
+#else
+                        if (RTStrAPrintf(&pszLogSuffix, "-%RU32-%RU32-%s",
+                                         pSessionStartupInfo->uSessionID,
+                                         s_uCtrlSessionThread,
+                                         pSessionStartupInfo->szUser) < 0)
+                        {
+                            rc2 = VERR_NO_MEMORY;
+                        }
+#endif /* DEBUG */
                         else
                         {
@@ -1940 +1997 @@
                         hStdOutAndErr.enmType = RTHANDLETYPE_FILE;
 
-                        /** @todo Do we need a custom/cloned environment block? */
+                        /** @todo Set custom/cloned guest session environment block. */
                         rc = RTProcCreateEx(pszExeName, papszArgs, RTENV_DEFAULT, uProcFlags,
                                             &hStdIn, &hStdOutAndErr, &hStdOutAndErr,
-                                            !fAnonymous ? pSession->StartupInfo.szUser : NULL,
-                                            !fAnonymous ? pSession->StartupInfo.szPassword : NULL,
-                                            &pSession->hProcess);
+                                            !fAnonymous ? pSessionThread->StartupInfo.szUser : NULL,
+                                            !fAnonymous ? pSessionThread->StartupInfo.szPassword : NULL,
+                                            &pSessionThread->hProcess);
 
                         RTFileClose(hStdOutAndErr.u.hFile);
                     }
 
-                    RTFileClose(hStdOutAndErr.u.hFile);
+                    RTFileClose(hStdIn.u.hFile);
                 }
 #endif
@@ -1961 +2018 @@
         {
             /* Start session thread. */
-            static uint32_t s_uCtrlSessionThread = 0;
-            if (s_uCtrlSessionThread++ == UINT32_MAX)
-                s_uCtrlSessionThread = 0; /* Wrap around to not let IPRT freak out. */
-            rc = RTThreadCreateF(&pSession->Thread, gstcntlSessionThread,
-                                 pSession /*pvUser*/, 0 /*cbStack*/,
+            rc = RTThreadCreateF(&pSessionThread->Thread, gstcntlSessionThread,
+                                 pSessionThread /*pvUser*/, 0 /*cbStack*/,
                                  RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "sess%u", s_uCtrlSessionThread);
             if (RT_FAILURE(rc))
@@ -1974 +2028 @@
             {
                 /* Wait for the thread to initialize. */
-                rc = RTThreadUserWait(pSession->Thread, 60 * 1000 /* 60s timeout */);
-                AssertRC(rc);
-                if (   ASMAtomicReadBool(&pSession->fShutdown)
+                rc = RTThreadUserWait(pSessionThread->Thread, 60 * 1000 /* 60s timeout */);
+                if (   ASMAtomicReadBool(&pSessionThread->fShutdown)
                     || RT_FAILURE(rc))
                 {
                     VBoxServiceError("Thread for session ID=%RU32 failed to start, rc=%Rrc\n",
-                                     pSession->StartupInfo.uSessionID, rc);
+                                     pSessionThread->StartupInfo.uSessionID, rc);
                     if (RT_SUCCESS(rc))
                         rc = VERR_CANT_CREATE; /** @todo Find a better rc. */
@@ -1986 +2039 @@
                 else
                 {
-                    ASMAtomicXchgBool(&pSession->fStarted, true);
+                    VBoxServiceVerbose(2, "Thread for session ID=%RU32 started\n",
+                                       pSessionThread->StartupInfo.uSessionID);
+
+                    ASMAtomicXchgBool(&pSessionThread->fStarted, true);
 
                     /* Add session to list. */
-                    /* rc = */ RTListAppend(pList, &pSession->Node);
+                    /* rc = */ RTListAppend(pList, &pSessionThread->Node);
                     if (ppSessionThread) /* Return session if wanted. */
-                        *ppSessionThread = pSession;
+                        *ppSessionThread = pSessionThread;
                 }
             }
@@ -1998 +2054 @@
         if (RT_FAILURE(rc))
         {
-            RTMemFree(pSession);
+            RTMemFree(pSessionThread);
         }
     }
@@ -2004 +2060 @@
         rc = VERR_NO_MEMORY;
 
-    VBoxServiceVerbose(3, "Forking returned returned rc=%Rrc\n", rc);
+    VBoxServiceVerbose(3, "Forking session thread returned returned rc=%Rrc\n", rc);
     return rc;
 }
@@ -2010 +2066 @@
 
 /**
- * Closes a formerly opened guest session and removes it from
- * the session list.
+ * Waits for a formerly opened guest session process to close.
  *
  * @return  IPRT status code.
- * @param   pThread                 Guest session thread to close.
+ * @param   pThread                 Guest session thread to wait for.
+ * @param   uTimeoutMS              Waiting timeout (in ms).
  * @param   uFlags                  Closing flags.
  */
-int GstCntlSessionThreadClose(PVBOXSERVICECTRLSESSIONTHREAD pThread, uint32_t uFlags)
+int GstCntlSessionThreadWait(PVBOXSERVICECTRLSESSIONTHREAD pThread,
+                             uint32_t uTimeoutMS, uint32_t uFlags)
 {
     AssertPtrReturn(pThread, VERR_INVALID_POINTER);
@@ -2024 +2081 @@
     if (pThread->Thread == NIL_RTTHREAD)
     {
-        AssertMsgFailed(("Guest session thread of session %p does not exist when it should",
+        AssertMsgFailed(("Guest session thread of session %p does not exist when it should\n",
                          pThread));
         return VERR_NOT_FOUND;
@@ -2031 +2088 @@
     int rc = VINF_SUCCESS;
 
-    /* The fork should have received the same closing request,
+    /*
+     * The fork should have received the same closing request,
      * so just wait 30s for the process to close. On timeout kill
-     * it in a not so gentle manner. */
+     * it in a not so gentle manner.
+     */
     if (ASMAtomicReadBool(&pThread->fStarted))
     {
@@ -2039 +2098 @@
         ASMAtomicXchgBool(&pThread->fShutdown, true);
 
-        uint32_t cMsTimeout = 30 * 1000; /** @todo 30s default. Make this configurable. Later. */
-
         VBoxServiceVerbose(3, "Waiting for session thread ID=%RU32 to close (%RU32ms) ...\n",
-                           pThread->StartupInfo.uSessionID, cMsTimeout);
+                           pThread->StartupInfo.uSessionID, uTimeoutMS);
 
         int rcThread;
-        rc = RTThreadWait(pThread->Thread, cMsTimeout, &rcThread);
+        rc = RTThreadWait(pThread->Thread, uTimeoutMS, &rcThread);
         if (RT_FAILURE(rc))
         {
@@ -2054 +2111 @@
             VBoxServiceVerbose(3, "Session thread ID=%RU32 ended with rc=%Rrc\n",
                                pThread->StartupInfo.uSessionID, rcThread);
-
-        /* Remove session from list and destroy object. */
-        RTListNodeRemove(&pThread->Node);
-
-        if (RT_FAILURE(rc))
-            VBoxServiceError("Closing session ID=%RU32 failed with rc=%Rrc\n",
-                             pThread->StartupInfo.uSessionID, rc);
-
-        RTMemFree(pThread);
-        pThread = NULL;
-    }
-
-    return rc;
-}
-
+    }
+
+    return rc;
+}
+
+/**
+ * Waits for the specified session thread to end and remove
+ * it from the session thread list.
+ *
+ * @return  IPRT status code.
+ * @param   pThread                 Session thread to destroy.
+ * @param   uFlags                  Closing flags.
+ */
+int GstCntlSessionThreadDestroy(PVBOXSERVICECTRLSESSIONTHREAD pThread, uint32_t uFlags)
+{
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+
+    int rc = GstCntlSessionThreadWait(pThread,
+                                      30 * 1000 /* 30s timeout */, uFlags);
+    /** @todo Kill session process if still around? */
+
+    /* Remove session from list and destroy object. */
+    RTListNodeRemove(&pThread->Node);
+    RTMemFree(pThread);
+
+    return rc;
+}
 
 /**
@@ -2077 +2146 @@
  * @param   uFlags                  Closing flags.
  */
-int GstCntlSessionThreadCloseAll(PRTLISTANCHOR pList, uint32_t uFlags)
+int GstCntlSessionThreadDestroyAll(PRTLISTANCHOR pList, uint32_t uFlags)
 {
     AssertPtrReturn(pList, VERR_INVALID_POINTER);
@@ -2083 +2152 @@
     int rc = VINF_SUCCESS;
 
-    PVBOXSERVICECTRLSESSIONTHREAD pSessionCur
+    PVBOXSERVICECTRLSESSIONTHREAD pSessionThread
          = RTListGetFirst(pList, VBOXSERVICECTRLSESSIONTHREAD, Node);
-    while (pSessionCur)
-    {
-        PVBOXSERVICECTRLSESSIONTHREAD pSessionNext =
-            RTListGetNext(pList, pSessionCur, VBOXSERVICECTRLSESSIONTHREAD, Node);
-        bool fLast = RTListNodeIsLast(pList, &pSessionCur->Node);
-
-        int rc2 = GstCntlSessionThreadClose(pSessionCur, uFlags);
-        if (RT_SUCCESS(rc))
-        {
-            rc = rc2;
+    while (pSessionThread)
+    {
+        PVBOXSERVICECTRLSESSIONTHREAD pSessionThreadNext =
+            RTListGetNext(pList, pSessionThread, VBOXSERVICECTRLSESSIONTHREAD, Node);
+        bool fLast = RTListNodeIsLast(pList, &pSessionThread->Node);
+
+        int rc2 = GstCntlSessionThreadDestroy(pSessionThread, uFlags);
+        if (RT_FAILURE(rc2))
+        {
+            VBoxServiceError("Closing session thread failed with rc=%Rrc\n", rc2);
+            if (RT_SUCCESS(rc))
+                rc = rc2;
             /* Keep going. */
         }
@@ -2101 +2172 @@
             break;
 
-        pSessionCur = pSessionNext;
-    }
-
-    return rc;
-}
-
+        pSessionThread = pSessionThreadNext;
+    }
+
+    return rc;
+}
 
 RTEXITCODE VBoxServiceControlSessionForkInit(int argc, char **argv)
@@ -2113 +2183 @@
     {
         { "--logfile",         VBOXSERVICESESSIONOPT_LOG_FILE,        RTGETOPT_REQ_STRING },
-        { "--username",        VBOXSERVICESESSIONOPT_USERNAME,        RTGETOPT_REQ_STRING },
+        { "--user",            VBOXSERVICESESSIONOPT_USERNAME,        RTGETOPT_REQ_STRING },
         { "--session-id",      VBOXSERVICESESSIONOPT_SESSION_ID,      RTGETOPT_REQ_UINT32 },
         { "--session-proto",   VBOXSERVICESESSIONOPT_SESSION_PROTO,   RTGETOPT_REQ_UINT32 },
+#ifdef DEBUG
+        { "--thread-id",       VBOXSERVICESESSIONOPT_THREAD_ID,       RTGETOPT_REQ_UINT32 },
+#endif /* DEBUG */
         { "--verbose",         'v',                                   RTGETOPT_REQ_NOTHING }
     };
@@ -2157 +2230 @@
                 break;
 
+            case VBOXSERVICESESSIONOPT_THREAD_ID:
+                /* Not handled. */
+                break;
+
             /** @todo Implement help? */