Changeset 44863 in vbox for trunk/src/VBox/Additions/common

Timestamp:

Feb 28, 2013 12:18:17 PM (12 years ago)

Author:

vboxsync

Message:

GuestCtrl: Infrastructure changes for handling and executing dedicated guest sessions and protocol versioning (untested, work in progress).

Location:

trunk/src/VBox

Files:

• . (modified) (1 prop)
• Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestCtrl.cpp (modified) (31 diffs)
• Additions/common/VBoxService (modified) (1 prop)
• Additions/common/VBoxService/Makefile.kmk (modified) (2 diffs)
• Additions/common/VBoxService/VBoxService.cpp (modified) (8 diffs)
• Additions/common/VBoxService/VBoxServiceControl.cpp (modified) (39 diffs)
• Additions/common/VBoxService/VBoxServiceControl.h (added)
• Additions/common/VBoxService/VBoxServiceControlSession.cpp (added)
• Additions/common/VBoxService/VBoxServiceControlThread.cpp (modified) (21 diffs)
• Additions/common/VBoxService/VBoxServiceInternal.h (modified) (3 diffs)
• Additions/common/VBoxService/VBoxServicePageSharing.cpp (modified) (1 diff)
• Additions/common/VBoxService/VBoxServiceToolBox.cpp (modified) (1 diff)

trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxGuestR3LibGuestCtrl.cpp

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2010-2012 Oracle Corporation
+ * Copyright (C) 2010-2013 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -50 +50 @@
  *
  * @returns VBox status code
- * @param   pu32ClientId    Where to put the client id on success. The client id
- *                          must be passed to all the other calls to the service.
- */
-VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *pu32ClientId)
+ * @param   puClientId    Where to put the client id on success. The client id
+ *                        must be passed to all the other calls to the service.
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlConnect(uint32_t *puClientId)
 {
     VBoxGuestHGCMConnectInfo Info;
@@ -67 +67 @@
         rc = Info.result;
         if (RT_SUCCESS(rc))
-            *pu32ClientId = Info.u32ClientID;
+            *puClientId = Info.u32ClientID;
     }
     return rc;
@@ -77 +77 @@
  *
  * @returns VBox status code.
- * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
- */
-VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t u32ClientId)
+ * @param   uClientId     The client id returned by VbglR3GuestCtrlConnect().
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlDisconnect(uint32_t uClientId)
 {
     VBoxGuestHGCMDisconnectInfo Info;
     Info.result = VERR_WRONG_ORDER;
-    Info.u32ClientID = u32ClientId;
+    Info.u32ClientID = uClientId;
 
     int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_DISCONNECT, &Info, sizeof(Info));
@@ -97 +97 @@
  *
  * @returns VBox status code.
- * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
+ * @param   uClientId       The client id returned by VbglR3GuestCtrlConnect().
  * @param   puMsg           Where to store the message id.
  * @param   puNumParms      Where to store the number  of parameters which will be received
  *                          in a second call to the host.
  */
-VBGLR3DECL(int) VbglR3GuestCtrlWaitForHostMsg(uint32_t u32ClientId, uint32_t *puMsg, uint32_t *puNumParms)
+VBGLR3DECL(int) VbglR3GuestCtrlMsgWaitFor(uint32_t uClientId, uint32_t *puMsg, uint32_t *puNumParms)
 {
     AssertPtrReturn(puMsg, VERR_INVALID_POINTER);
     AssertPtrReturn(puNumParms, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgType Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG; /* Tell the host we want our next command. */
-    Msg.hdr.cParms      = 2;                  /* Just peek for the next message! */
+    HGCMMsgCmdWaitFor Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = uClientId;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT; /* Tell the host we want our next command. */
+    Msg.hdr.cParms      = 2;              /* Just peek for the next message! */
 
     VbglHGCMParmUInt32Set(&Msg.msg, 0);
@@ -132 +132 @@
 
 /**
+ * Asks the host guest control service to set a command filter to this
+ * client so that it only will receive certain commands in the future.
+ *
+ * @return  IPRT status code.
+ * @param   uClientId       The client id returned by VbglR3GuestCtrlConnect().
+ * @param   uFilterAdd      Filter mask to add.
+ * @param   uFilterRemove   Filter mask to remove.
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlMsgSetFilter(uint32_t uClientId,
+                                            uint32_t uFilterAdd, uint32_t uFilterRemove)
+{
+    HGCMMsgCmdSetFilter Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = uClientId;
+    Msg.hdr.u32Function = GUEST_MSG_FILTER; /* Tell the host we want to set a filter. */
+    Msg.hdr.cParms      = 2;
+
+    VbglHGCMParmUInt32Set(&Msg.add, uFilterAdd);
+    VbglHGCMParmUInt32Set(&Msg.remove, uFilterRemove);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+        rc = Msg.hdr.result;
+    return rc;
+}
+
+
+/**
  * Asks the host to cancel (release) all pending waits which were deferred.
  *
  * @returns VBox status code.
- * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
- */
-VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(uint32_t u32ClientId)
-{
-    VBoxGuestCtrlHGCMMsgCancelPendingWaits Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
+ * @param   uClientId     The client id returned by VbglR3GuestCtrlConnect().
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlCancelPendingWaits(uint32_t uClientId)
+{
+    HGCMMsgCancelPendingWaits Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = uClientId;
     Msg.hdr.u32Function = GUEST_CANCEL_PENDING_WAITS;
     Msg.hdr.cParms      = 0;
@@ -157 +186 @@
 
 
+VBGLR3DECL(int) VbglR3GuestCtrlSessionNotify(uint32_t uClientId, uint32_t uContext,
+                                             uint32_t uType, uint32_t uResult)
+{
+    HGCMMsgSessionNotify Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = uClientId;
+    Msg.hdr.u32Function = GUEST_SESSION_NOTIFY;
+    Msg.hdr.cParms      = 3;
+
+    VbglHGCMParmUInt32Set(&Msg.context, uContext);
+    VbglHGCMParmUInt32Set(&Msg.type, uType);
+    VbglHGCMParmUInt32Set(&Msg.result, uResult);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+            rc = rc2;
+    }
+    return rc;
+}
+
+
+/**
+ * Retrieves the request to create a new guest session.
+ *
+ * @return  IPRT status code.
+ * @param   pHostCtx                    Host context.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlSessionGetOpen(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                              uint32_t *puProtocol,
+                                              char     *pszUser,     uint32_t  cbUser,
+                                              char     *pszPassword, uint32_t  cbPassword,
+                                              char     *pszDomain,   uint32_t  cbDomain,
+                                              uint32_t *puFlags,     uint32_t *puSessionID)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+    AssertReturn(pHostCtx->uNumParms == 6, VERR_INVALID_PARAMETER);
+
+    AssertPtrReturn(puProtocol, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
+    AssertPtrReturn(pszDomain, VERR_INVALID_POINTER);
+    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
+
+    HGCMMsgSessionOpen Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
+    VbglHGCMParmUInt32Set(&Msg.protocol, 0);
+    VbglHGCMParmPtrSet(&Msg.username, pszUser, cbUser);
+    VbglHGCMParmPtrSet(&Msg.password, pszPassword, cbPassword);
+    VbglHGCMParmPtrSet(&Msg.domain, pszDomain, cbDomain);
+    VbglHGCMParmUInt32Set(&Msg.flags, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
+            Msg.protocol.GetUInt32(puProtocol);
+            Msg.flags.GetUInt32(puFlags);
+
+            if (puSessionID)
+                *puSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostCtx->uContextID);
+        }
+    }
+
+    return rc;
+}
+
+
+/**
+ * Retrieves the request to terminate an existing guest session.
+ *
+ * @return  IPRT status code.
+ * @param   pHostCtx                    Host context.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlSessionGetClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puFlags, uint32_t *puSessionID)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
+
+    AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
+
+    HGCMMsgSessionClose Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
+    VbglHGCMParmUInt32Set(&Msg.flags, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
+            Msg.flags.GetUInt32(puFlags);
+
+            if (puSessionID)
+                *puSessionID = VBOX_GUESTCTRL_CONTEXTID_GET_SESSION(pHostCtx->uContextID);
+        }
+    }
+
+    return rc;
+}
+
+
 /**
  * Allocates and gets host data, based on the message id.
@@ -163 +323 @@
  *
  * @returns VBox status code.
- * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
- * @param   uNumParms
  ** @todo Docs!
- */
-VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdExec(uint32_t  u32ClientId,    uint32_t  cParms,
-                                                  uint32_t *puContext,
-                                                  char     *pszCmd,         uint32_t  cbCmd,
-                                                  uint32_t *puFlags,
-                                                  char     *pszArgs,        uint32_t  cbArgs,   uint32_t *pcArgs,
-                                                  char     *pszEnv,         uint32_t *pcbEnv,   uint32_t *pcEnvVars,
-                                                  char     *pszUser,        uint32_t  cbUser,
-                                                  char     *pszPassword,    uint32_t  cbPassword,
-                                                  uint32_t *pcMsTimeLimit)
-{
-    AssertReturn(cParms == 11, VERR_INVALID_PARAMETER);
-
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+ ** @todo Move the parameters in an own struct!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlProcGetStart(PVBGLR3GUESTCTRLHOSTCTX   pHostCtx,
+                                            char     *pszCmd,         uint32_t  cbCmd,
+                                            uint32_t *puFlags,
+                                            char     *pszArgs,        uint32_t  cbArgs,     uint32_t *pcArgs,
+                                            char     *pszEnv,         uint32_t *pcbEnv,     uint32_t *pcEnvVars,
+                                            char     *pszUser,        uint32_t  cbUser,
+                                            char     *pszPassword,    uint32_t  cbPassword,
+                                            uint32_t *puTimeoutMS,
+                                            uint32_t *puPriority,
+                                            uint64_t *puAffinity,     uint32_t  cbAffinity, uint32_t *pcAffinity)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
     AssertPtrReturn(pszCmd, VERR_INVALID_POINTER);
     AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
@@ -187 +346 @@
     AssertPtrReturn(pcbEnv, VERR_INVALID_POINTER);
     AssertPtrReturn(pcEnvVars, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
-    AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
-    AssertPtrReturn(pcMsTimeLimit, VERR_INVALID_POINTER);
-
-    VBoxGuestCtrlHGCMMsgExecCmd Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 11;
+    AssertPtrReturn(puTimeoutMS, VERR_INVALID_POINTER);
+
+    HGCMMsgProcExec Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -206 +363 @@
     VbglHGCMParmUInt32Set(&Msg.cb_env, 0);
     VbglHGCMParmPtrSet(&Msg.env, pszEnv, *pcbEnv);
-    VbglHGCMParmPtrSet(&Msg.username, pszUser, cbUser);
-    VbglHGCMParmPtrSet(&Msg.password, pszPassword, cbPassword);
-    VbglHGCMParmUInt32Set(&Msg.timeout, 0);
-
-    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
-    if (RT_SUCCESS(rc))
-    {
-        int rc2 = Msg.hdr.result;
-        if (RT_FAILURE(rc2))
-        {
-            rc = rc2;
-        }
-        else
-        {
-            Msg.context.GetUInt32(puContext);
+    if (pHostCtx->uProtocol < 2)
+    {
+        AssertPtrReturn(pszUser, VERR_INVALID_POINTER);
+        AssertReturn(cbUser, VERR_INVALID_PARAMETER);
+        AssertPtrReturn(pszPassword, VERR_INVALID_POINTER);
+        AssertReturn(pszPassword, VERR_INVALID_PARAMETER);
+
+        VbglHGCMParmPtrSet(&Msg.u.v1.username, pszUser, cbUser);
+        VbglHGCMParmPtrSet(&Msg.u.v1.password, pszPassword, cbPassword);
+        VbglHGCMParmUInt32Set(&Msg.u.v1.timeout, 0);
+    }
+    else
+    {
+        AssertPtrReturn(puAffinity, VERR_INVALID_POINTER);
+        AssertReturn(cbAffinity, VERR_INVALID_PARAMETER);
+
+        VbglHGCMParmUInt32Set(&Msg.u.v2.timeout, 0);
+        VbglHGCMParmUInt32Set(&Msg.u.v2.priority, 0);
+        VbglHGCMParmUInt32Set(&Msg.u.v2.num_affinity, 0);
+        VbglHGCMParmPtrSet(&Msg.u.v2.affinity, puAffinity, cbAffinity);
+    }
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.flags.GetUInt32(puFlags);
             Msg.num_args.GetUInt32(pcArgs);
             Msg.num_env.GetUInt32(pcEnvVars);
             Msg.cb_env.GetUInt32(pcbEnv);
-            Msg.timeout.GetUInt32(pcMsTimeLimit);
+            if (pHostCtx->uProtocol < 2)
+            {
+                Msg.u.v1.timeout.GetUInt32(puTimeoutMS);
+            }
+            else
+            {
+                Msg.u.v2.timeout.GetUInt32(puTimeoutMS);
+                Msg.u.v2.priority.GetUInt32(puPriority);
+                Msg.u.v2.num_affinity.GetUInt32(pcAffinity);
+            }
         }
     }
@@ -238 +422 @@
  *
  * @returns VBox status code.
- * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
- * @param   cParms
  ** @todo Docs!
  */
-VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdOutput(uint32_t  u32ClientId,    uint32_t  cParms,
-                                                    uint32_t *puContext,      uint32_t *puPID,
-                                                    uint32_t *puHandle,       uint32_t *puFlags)
-{
-    AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
-
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlProcGetOutput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                             uint32_t *puPID, uint32_t *puHandle, uint32_t *puFlags)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
+
     AssertPtrReturn(puPID, VERR_INVALID_POINTER);
     AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgExecOut Msg;
+    HGCMMsgProcOutput Msg;
 
     Msg.hdr.result = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms = 4;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -275 +456 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.pid.GetUInt32(puPID);
             Msg.handle.GetUInt32(puHandle);
@@ -292 +473 @@
  *
  * @returns VBox status code.
- * @param   u32ClientId     The client id returned by VbglR3GuestCtrlConnect().
- * @param   cParms
  ** @todo Docs!
  */
-VBGLR3DECL(int) VbglR3GuestCtrlExecGetHostCmdInput(uint32_t  u32ClientId,    uint32_t   cParms,
-                                                   uint32_t *puContext,      uint32_t  *puPID,
-                                                   uint32_t *puFlags,
-                                                   void     *pvData,         uint32_t  cbData,
-                                                   uint32_t *pcbSize)
-{
-    AssertReturn(cParms == 5, VERR_INVALID_PARAMETER);
-
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlProcGetInput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                            uint32_t  *puPID,       uint32_t *puFlags,
+                                            void      *pvData,      uint32_t  cbData,
+                                            uint32_t  *pcbSize)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
+
     AssertPtrReturn(puPID, VERR_INVALID_POINTER);
     AssertPtrReturn(puFlags, VERR_INVALID_POINTER);
@@ -310 +488 @@
     AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgExecIn Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 5;
+    HGCMMsgProcInput Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -333 +511 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.pid.GetUInt32(puPID);
             Msg.flags.GetUInt32(puFlags);
@@ -343 +521 @@
 
 
-/**
- * Reports the process status (along with some other stuff) to the host.
- *
- * @returns VBox status code.
- ** @todo Docs!
- */
-VBGLR3DECL(int) VbglR3GuestCtrlExecReportStatus(uint32_t     u32ClientId,
-                                                uint32_t     u32Context,
-                                                uint32_t     u32PID,
-                                                uint32_t     u32Status,
-                                                uint32_t     u32Flags,
-                                                void        *pvData,
-                                                uint32_t     cbData)
-{
-    VBoxGuestCtrlHGCMMsgExecStatus Msg;
-
-    Msg.hdr.result = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_EXEC_SEND_STATUS;
-    Msg.hdr.cParms = 5;
-
-    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
-    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
-    VbglHGCMParmUInt32Set(&Msg.status, u32Status);
-    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
-    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
-
-    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
-    if (RT_SUCCESS(rc))
-    {
-        int rc2 = Msg.hdr.result;
-        if (RT_FAILURE(rc2))
-            rc = rc2;
-    }
-    return rc;
-}
-
-
-/**
- * Sends output (from stdout/stderr) from a running process.
- *
- * @returns VBox status code.
- ** @todo Docs!
- */
-VBGLR3DECL(int) VbglR3GuestCtrlExecSendOut(uint32_t     u32ClientId,
-                                           uint32_t     u32Context,
-                                           uint32_t     u32PID,
-                                           uint32_t     u32Handle,
-                                           uint32_t     u32Flags,
-                                           void        *pvData,
-                                           uint32_t     cbData)
-{
-    VBoxGuestCtrlHGCMMsgExecOut Msg;
-
-    Msg.hdr.result = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_EXEC_SEND_OUTPUT;
-    Msg.hdr.cParms = 5;
-
-    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
-    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
-    VbglHGCMParmUInt32Set(&Msg.handle, u32Handle);
-    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
-    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
-
-    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
-    if (RT_SUCCESS(rc))
-    {
-        int rc2 = Msg.hdr.result;
-        if (RT_FAILURE(rc2))
-            rc = rc2;
-    }
-    return rc;
-}
-
-
-/**
- * Reports back the input status to the host.
- *
- * @returns VBox status code.
- ** @todo Docs!
- */
-VBGLR3DECL(int) VbglR3GuestCtrlExecReportStatusIn(uint32_t     u32ClientId,
-                                                  uint32_t     u32Context,
-                                                  uint32_t     u32PID,
-                                                  uint32_t     u32Status,
-                                                  uint32_t     u32Flags,
-                                                  uint32_t     cbWritten)
-{
-    VBoxGuestCtrlHGCMMsgExecStatusIn Msg;
-
-    Msg.hdr.result = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = u32ClientId;
-    Msg.hdr.u32Function = GUEST_EXEC_SEND_INPUT_STATUS;
-    Msg.hdr.cParms = 5;
-
-    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
-    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
-    VbglHGCMParmUInt32Set(&Msg.status, u32Status);
-    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
-    VbglHGCMParmUInt32Set(&Msg.written, cbWritten);
-
-    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
-    if (RT_SUCCESS(rc))
-    {
-        int rc2 = Msg.hdr.result;
-        if (RT_FAILURE(rc2))
-            rc = rc2;
-    }
-    return rc;
-}
-
-
-VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdOpen(uint32_t     uClientId,           uint32_t cParms,
-                                                  uint32_t    *puContext,
-                                                  char        *pszFileName,         uint32_t cbFileName,
-                                                  char        *pszOpenMode,         uint32_t cbOpenMode,
-                                                  char        *pszDisposition,      uint32_t cbDisposition,
-                                                  uint32_t    *puCreationMode,
-                                                  uint64_t    *puOffset)
-{
-    AssertReturn(cParms == 6, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetOpen(PVBGLR3GUESTCTRLHOSTCTX      pHostCtx,
+                                           char     *pszFileName,       uint32_t cbFileName,
+                                           char     *pszOpenMode,       uint32_t cbOpenMode,
+                                           char     *pszDisposition,    uint32_t cbDisposition,
+                                           uint32_t *puCreationMode,
+                                           uint64_t *puOffset)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+    AssertReturn(pHostCtx->uNumParms == 6, VERR_INVALID_PARAMETER);
+
     AssertPtrReturn(pszFileName, VERR_INVALID_POINTER);
     AssertReturn(cbFileName, VERR_INVALID_PARAMETER);
@@ -475 +540 @@
     AssertPtrReturn(puOffset, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgFileOpen Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 6;
+    HGCMMsgFileOpen Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -499 +564 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.creationmode.GetUInt32(puCreationMode);
             Msg.offset.GetUInt64(puOffset);
@@ -508 +573 @@
 
 
-VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdClose(uint32_t     uClientId,           uint32_t cParms,
-                                                   uint32_t    *puContext,
-                                                   uint32_t    *puHandle)
-{
-    AssertReturn(cParms == 2, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgFileClose Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 2;
+    HGCMMsgFileClose Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -536 +600 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.handle.GetUInt32(puHandle);
         }
@@ -544 +608 @@
 
 
-VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdRead(uint32_t     uClientId,           uint32_t     cParms,
-                                                  uint32_t    *puContext,
-                                                  uint32_t    *puHandle,            uint32_t    *puToRead)
-{
-    AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetRead(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                           uint32_t *puHandle, uint32_t *puToRead)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     AssertPtrReturn(puToRead, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgFileRead Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 4;
+    HGCMMsgFileRead Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -574 +638 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.handle.GetUInt32(puHandle);
             Msg.size.GetUInt32(puToRead);
@@ -582 +646 @@
 }
 
-VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdWrite(uint32_t     uClientId,           uint32_t    cParms,
-                                                   uint32_t    *puContext,
-                                                   uint32_t    *puHandle,
-                                                   void        *pvData,              uint32_t    cbData,
-                                                   uint32_t    *pcbSize)
-{
-    AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetReadAt(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                             uint32_t *puHandle, uint32_t *puToRead, uint64_t *puOffset)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
+    AssertPtrReturn(puToRead, VERR_INVALID_POINTER);
+
+    HGCMMsgFileRead Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
+    VbglHGCMParmUInt32Set(&Msg.handle, 0);
+    VbglHGCMParmUInt32Set(&Msg.size, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
+            Msg.handle.GetUInt32(puHandle);
+            Msg.size.GetUInt32(puToRead);
+        }
+    }
+    return rc;
+}
+
+
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetWrite(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle,
+                                            void *pvData, uint32_t cbData, uint32_t *pcbSize)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     AssertPtrReturn(pvData, VERR_INVALID_POINTER);
@@ -595 +697 @@
     AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgFileWrite Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 4;
+    HGCMMsgFileWrite Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -617 +719 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.handle.GetUInt32(puHandle);
             Msg.size.GetUInt32(pcbSize);
@@ -626 +728 @@
 
 
-VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdSeek(uint32_t     uClientId,           uint32_t  cParms,
-                                                  uint32_t    *puContext,
-                                                  uint32_t    *puHandle,
-                                                  uint32_t    *puSeekMethod,        uint64_t *puOffset)
-{
-    AssertReturn(cParms == 4, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetWriteAt(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle,
+                                              void *pvData, uint32_t cbData, uint32_t *pcbSize, uint64_t *puOffset)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
+    AssertPtrReturn(pvData, VERR_INVALID_POINTER);
+    AssertReturn(cbData, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(pcbSize, VERR_INVALID_POINTER);
+
+    HGCMMsgFileWriteAt Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
+    VbglHGCMParmUInt32Set(&Msg.handle, 0);
+    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
+    VbglHGCMParmUInt32Set(&Msg.size, 0);
+    VbglHGCMParmUInt32Set(&Msg.offset, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
+            Msg.handle.GetUInt32(puHandle);
+            Msg.size.GetUInt32(pcbSize);
+        }
+    }
+    return rc;
+}
+
+
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetSeek(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                           uint32_t *puHandle, uint32_t *puSeekMethod, uint64_t *puOffset)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 4, VERR_INVALID_PARAMETER);
     AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
     AssertPtrReturn(puSeekMethod, VERR_INVALID_POINTER);
     AssertPtrReturn(puOffset, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgFileSeek Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 4;
+    HGCMMsgFileSeek Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -659 +803 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.handle.GetUInt32(puHandle);
             Msg.method.GetUInt32(puSeekMethod);
@@ -669 +813 @@
 
 
-VBGLR3DECL(int) VbglR3GuestCtrlFileGetHostCmdTell(uint32_t     uClientId,           uint32_t  cParms,
-                                                  uint32_t    *puContext,
-                                                  uint32_t    *puHandle)
-{
-    AssertReturn(cParms == 2, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(puContext, VERR_INVALID_POINTER);
+VBGLR3DECL(int) VbglR3GuestCtrlFileGetTell(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puHandle)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
     AssertPtrReturn(puHandle, VERR_INVALID_POINTER);
 
-    VBoxGuestCtrlHGCMMsgFileTell Msg;
-
-    Msg.hdr.result      = VERR_WRONG_ORDER;
-    Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_GET_HOST_MSG;
-    Msg.hdr.cParms      = 2;
+    HGCMMsgFileTell Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
 
     VbglHGCMParmUInt32Set(&Msg.context, 0);
@@ -697 +840 @@
         else
         {
-            Msg.context.GetUInt32(puContext);
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
             Msg.handle.GetUInt32(puHandle);
         }
@@ -705 +848 @@
 
 
-VBGLR3DECL(int) VbglR3GuestCtrlFileNotify(uint32_t     uClientId,
-                                          uint32_t     uContext,        uint32_t      uHandle,
+VBGLR3DECL(int) VbglR3GuestCtrlProcGetTerminate(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puPID)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 2, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puPID, VERR_INVALID_POINTER);
+
+    HGCMMsgProcTerminate Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
+    VbglHGCMParmUInt32Set(&Msg.pid, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
+            Msg.pid.GetUInt32(puPID);
+        }
+    }
+    return rc;
+}
+
+
+VBGLR3DECL(int) VbglR3GuestCtrlProcGetWaitFor(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, uint32_t *puPID, uint32_t *puWaitFlags, uint32_t *puTimeoutMS)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    AssertReturn(pHostCtx->uNumParms == 5, VERR_INVALID_PARAMETER);
+    AssertPtrReturn(puPID, VERR_INVALID_POINTER);
+
+    HGCMMsgProcWaitFor Msg;
+
+    Msg.hdr.result      = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = pHostCtx->uClientID;
+    Msg.hdr.u32Function = GUEST_MSG_WAIT;
+    Msg.hdr.cParms      = pHostCtx->uNumParms;
+
+    VbglHGCMParmUInt32Set(&Msg.context, 0);
+    VbglHGCMParmUInt32Set(&Msg.pid, 0);
+    VbglHGCMParmUInt32Set(&Msg.flags, 0);
+    VbglHGCMParmUInt32Set(&Msg.timeout, 0);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+        {
+            rc = rc2;
+        }
+        else
+        {
+            Msg.context.GetUInt32(&pHostCtx->uContextID);
+            Msg.pid.GetUInt32(puPID);
+            Msg.flags.GetUInt32(puWaitFlags);
+            Msg.timeout.GetUInt32(puTimeoutMS);
+        }
+    }
+    return rc;
+}
+
+
+VBGLR3DECL(int) VbglR3GuestCtrlFileNotify(uint32_t     uClientId,    uint32_t     uContext,
                                           uint32_t     uType,
-                                          void        *pvPayload,       uint32_t      cbPayload)
+                                          void        *pvPayload,    uint32_t     cbPayload)
 {
     AssertPtrReturn(uContext, VERR_INVALID_POINTER);
-    AssertPtrReturn(uHandle, VERR_INVALID_POINTER);
     AssertPtrReturn(pvPayload, VERR_INVALID_POINTER);
     AssertReturn(cbPayload, VERR_INVALID_PARAMETER);
 
-    VBoxGuestCtrlHGCMMsgFileNotify Msg;
+    HGCMMsgFileNotify Msg;
 
     Msg.hdr.result      = VERR_WRONG_ORDER;
     Msg.hdr.u32ClientID = uClientId;
-    Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
-    Msg.hdr.cParms      = 4;
+    //Msg.hdr.u32Function = GUEST_FILE_NOTIFY;
+    Msg.hdr.cParms      = 3;
 
     VbglHGCMParmUInt32Set(&Msg.context, uContext);
-    VbglHGCMParmUInt32Set(&Msg.handle, uHandle);
     VbglHGCMParmUInt32Set(&Msg.type, uType);
     VbglHGCMParmPtrSet(&Msg.payload, pvPayload, cbPayload);
@@ -737 +951 @@
 }
 
+
+/**
+ * Callback for reporting a guest process status (along with some other stuff) to the host.
+ *
+ * @returns VBox status code.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatus(uint32_t     u32ClientID,
+                                            uint32_t     u32Context,
+                                            uint32_t     u32PID,
+                                            uint32_t     u32Status,
+                                            uint32_t     u32Flags,
+                                            void        *pvData,
+                                            uint32_t     cbData)
+{
+    HGCMMsgProcStatus Msg;
+
+    Msg.hdr.result = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = u32ClientID;
+    Msg.hdr.u32Function = GUEST_EXEC_STATUS;
+    Msg.hdr.cParms = 5;
+
+    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
+    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
+    VbglHGCMParmUInt32Set(&Msg.status, u32Status);
+    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
+    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+            rc = rc2;
+    }
+    return rc;
+}
+
+
+/**
+ * Sends output (from stdout/stderr) from a running process.
+ *
+ * @returns VBox status code.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlProcCbOutput(uint32_t     u32ClientID,
+                                            uint32_t     u32Context,
+                                            uint32_t     u32PID,
+                                            uint32_t     u32Handle,
+                                            uint32_t     u32Flags,
+                                            void        *pvData,
+                                            uint32_t     cbData)
+{
+    HGCMMsgProcOutput Msg;
+
+    Msg.hdr.result = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = u32ClientID;
+    Msg.hdr.u32Function = GUEST_EXEC_OUTPUT;
+    Msg.hdr.cParms = 5;
+
+    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
+    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
+    VbglHGCMParmUInt32Set(&Msg.handle, u32Handle);
+    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
+    VbglHGCMParmPtrSet(&Msg.data, pvData, cbData);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+            rc = rc2;
+    }
+    return rc;
+}
+
+
+/**
+ * Callback for reporting back the input status of a guest process to the host.
+ *
+ * @returns VBox status code.
+ ** @todo Docs!
+ */
+VBGLR3DECL(int) VbglR3GuestCtrlProcCbStatusInput(uint32_t     u32ClientID,
+                                                 uint32_t     u32Context,
+                                                 uint32_t     u32PID,
+                                                 uint32_t     u32Status,
+                                                 uint32_t     u32Flags,
+                                                 uint32_t     cbWritten)
+{
+    HGCMMsgProcStatusInput Msg;
+
+    Msg.hdr.result = VERR_WRONG_ORDER;
+    Msg.hdr.u32ClientID = u32ClientID;
+    Msg.hdr.u32Function = GUEST_EXEC_INPUT_STATUS;
+    Msg.hdr.cParms = 5;
+
+    VbglHGCMParmUInt32Set(&Msg.context, u32Context);
+    VbglHGCMParmUInt32Set(&Msg.pid, u32PID);
+    VbglHGCMParmUInt32Set(&Msg.status, u32Status);
+    VbglHGCMParmUInt32Set(&Msg.flags, u32Flags);
+    VbglHGCMParmUInt32Set(&Msg.written, cbWritten);
+
+    int rc = vbglR3DoIOCtl(VBOXGUEST_IOCTL_HGCM_CALL(sizeof(Msg)), &Msg, sizeof(Msg));
+    if (RT_SUCCESS(rc))
+    {
+        int rc2 = Msg.hdr.result;
+        if (RT_FAILURE(rc2))
+            rc = rc2;
+    }
+    return rc;
+}
+

trunk/src/VBox/Additions/common/VBoxService/Makefile.kmk

@@ -5 +5 @@
 
 #
-# Copyright (C) 2007-2012 Oracle Corporation
+# Copyright (C) 2007-2013 Oracle Corporation
 #
 # This file is part of VirtualBox Open Source Edition (OSE), as
@@ -74 +74 @@
  VBoxService_SOURCES    += \
         VBoxServiceControl.cpp \
-        VBoxServiceControlThread.cpp
+        VBoxServiceControlThread.cpp \
+        VBoxServiceControlSession.cpp
 endif
 

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

@@ -57 +57 @@
 
 #include "VBoxServiceInternal.h"
+#ifdef VBOX_WITH_GUEST_CONTROL
+# include "VBoxServiceControl.h"
+#endif
 
 
@@ -66 +69 @@
 /** The current verbosity level. */
 int                  g_cVerbosity = 0;
+char                 g_szLogFile[RTPATH_MAX + 128] = "";
 /** Logging parameters. */
 /** @todo Make this configurable later. */
@@ -216 +220 @@
  * @param   pszLogFile              Filename for log output.  Optional.
  */
-static int VBoxServiceLogCreate(const char *pszLogFile)
+int VBoxServiceLogCreate(const char *pszLogFile)
 {
     /* Create release logger (stdout + file). */
@@ -242 +246 @@
 }
 
-static void VBoxServiceLogDestroy(void)
+
+void VBoxServiceLogDestroy(void)
 {
     RTLogDestroy(RTLogRelSetDefaultInstance(NULL));
@@ -634 +639 @@
         }
 
+    VBoxServiceVerbose(3, "All stop functions for services called\n");
+
     /*
      * Wait for all the service threads to complete.
@@ -792 +799 @@
      */
     if (    argc == 2
-        &&  !strcmp(argv[1], "--pagefusionfork"))
+        &&  !RTStrICmp(argv[1], "pagefusion"))
         return VBoxServicePageSharingInitFork();
 #endif
 
-    char szLogFile[RTPATH_MAX + 128] = "";
+    /*
+     * Check if we're the specially spawned VBoxService.exe process that
+     * handles a guest control session.
+     */
+    if (    argc >= 2
+        &&  !RTStrICmp(argv[1], "guestsession"))
+        return VBoxServiceControlSessionForkInit(argc, argv);
 
     /*
@@ -926 +939 @@
                 {
                     rc = VBoxServiceArgString(argc, argv, psz + 1, &i,
-                                              szLogFile, sizeof(szLogFile));
+                                              g_szLogFile, sizeof(g_szLogFile));
                     if (rc)
                         return rc;
@@ -961 +974 @@
         return RTMsgErrorExit(RTEXITCODE_SYNTAX, "At least one service must be enabled\n");
 
-    rc = VBoxServiceLogCreate(strlen(szLogFile) ? szLogFile : NULL);
+    rc = VBoxServiceLogCreate(strlen(g_szLogFile) ? g_szLogFile : NULL);
     if (RT_FAILURE(rc))
         return RTMsgErrorExit(RTEXITCODE_FAILURE, "Failed to create release log (%s, %Rrc)",
-                              strlen(szLogFile) ? szLogFile : "<None>", rc);
+                              strlen(g_szLogFile) ? g_szLogFile : "<None>", rc);
 
     /* Call pre-init if we didn't do it already. */

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

@@ -22 +22 @@
 #include <iprt/asm.h>
 #include <iprt/assert.h>
+#include <iprt/env.h>
 #include <iprt/file.h>
 #include <iprt/getopt.h>
 #include <iprt/mem.h>
 #include <iprt/path.h>
+#include <iprt/process.h>
 #include <iprt/semaphore.h>
 #include <iprt/thread.h>
@@ -31 +33 @@
 #include <VBox/HostServices/GuestControlSvc.h>
 #include "VBoxServiceInternal.h"
+#include "VBoxServiceControl.h"
 #include "VBoxServiceUtils.h"
 
@@ -42 +45 @@
 /** The semaphore we're blocking our main control thread on. */
 static RTSEMEVENTMULTI      g_hControlEvent = NIL_RTSEMEVENTMULTI;
+/** The VM session ID. Changes whenever the VM is restored or reset. */
+static uint64_t             g_idControlSession;
 /** The guest control service client ID. */
 static uint32_t             g_uControlSvcClientID = 0;
@@ -58 +63 @@
 /** Critical section protecting g_GuestControlExecThreads. */
 static RTCRITSECT           g_csControlThreads;
-/** List of guest control files (VBOXSERVICECTRLFILE).
- **@todo Use a map (later). */
-static RTLISTANCHOR         g_lstControlFiles;
-/** The internal file count for building our internal file handles.
- *  Should be enough for now. */
-static uint32_t             g_uControlFileCount = 0;
-
+/** List of guest control sessions (VBOXSERVICECTRLSESSION). */
+RTLISTANCHOR                g_lstControlSessions;
 
 /*******************************************************************************
 *   Internal Functions                                                         *
 *******************************************************************************/
-/** @todo Shorten "VBoxServiceControl" to "gstsvcCntl". */
-static int gstcntlReapThreads(void);
-static int gstcntlStartAllowed(bool *pbAllowed);
-static int gstcntlHandleCmdStartProc(uint32_t u32ClientId, uint32_t uNumParms);
-static int gstcntlHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, void *pvScratchBuf, size_t cbScratchBuf);
-static int gstcntlHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);
-static int gstcntlHandleFileOpen(uint32_t idClient, uint32_t cParms);
-static int gstcntlHandleFileClose(uint32_t idClient, uint32_t cParms);
-static int gstcntlHandleFileRead(uint32_t idClient, uint32_t cParms);
-static int gstcntlHandleFileWrite(uint32_t idClient, uint32_t cParms, void *pvScratchBuf, size_t cbScratchBuf);
-static int gstcntlHandleFileSeek(uint32_t idClient, uint32_t cParms);
-static int gstcntlHandleFileTell(uint32_t idClient, uint32_t cParms);
+static int  gstcntlHandleSessionOpen(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
+static int  gstcntlHandleSessionClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
+static int  gstcntlHandleProcExec(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
+static int  gstcntlHandleProcInput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx, void *pvScratchBuf, size_t cbScratchBuf);
+static int  gstcntlHandleProcOutput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
+static int  gstcntlHandleProcTerminate(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
+static int  gstcntlHandleProcWaitFor(PVBGLR3GUESTCTRLHOSTCTX pHostCtx);
+static int  gstcntlReapThreads(void);
+static void VBoxServiceControlShutdown(void);
+static int  vboxServiceControlProcessCloseAll(void);
+static int  gstcntlStartAllowed(bool *pbAllowed);
 
 #ifdef DEBUG
@@ -137 +136 @@
     else
     {
-        rc = VBoxServiceReadPropUInt32(uGuestPropSvcClientID, "/VirtualBox/GuestAdd/VBoxService/--control-procs-max-kept",
-                                       &g_uControlProcsMaxKept, 0, UINT32_MAX - 1);
-
         VbglR3GuestPropDisconnect(uGuestPropSvcClientID);
     }
@@ -162 +158 @@
         rc = VBoxServiceArgUInt32(argc, argv, "", pi,
                                   &g_uControlIntervalMS, 1, UINT32_MAX - 1);
-    else if (!strcmp(argv[*pi], "--control-procs-max-kept"))
-        rc = VBoxServiceArgUInt32(argc, argv, "", pi,
-                                  &g_uControlProcsMaxKept, 0, UINT32_MAX - 1);
 #ifdef DEBUG
     else if (!strcmp(argv[*pi], "--control-dump-stderr"))
@@ -194 +187 @@
     AssertRCReturn(rc, rc);
 
+    VbglR3GetSessionId(&g_idControlSession);
+    /* The status code is ignored as this information is not available with VBox < 3.2.10. */
+
     rc = VbglR3GuestCtrlConnect(&g_uControlSvcClientID);
     if (RT_SUCCESS(rc))
@@ -202 +198 @@
         RTListInit(&g_lstControlThreadsActive);
         RTListInit(&g_lstControlThreadsInactive);
-        RTListInit(&g_lstControlFiles);
+        RTListInit(&g_lstControlSessions);
 
         /* Init critical section for protecting the thread lists. */
@@ -245 +241 @@
     AssertPtrReturn(pvScratchBuf, VERR_NO_MEMORY);
 
-    /*
-     * Execution loop.
-     *
-     * @todo
-     */
+    VBGLR3GUESTCTRLHOSTCTX ctxHost = { g_uControlSvcClientID,
+                                       1 /* Default protocol version */ };
     for (;;)
     {
@@ -255 +248 @@
         uint32_t uMsg = 0;
         uint32_t cParms = 0;
-        rc = VbglR3GuestCtrlWaitForHostMsg(g_uControlSvcClientID, &uMsg, &cParms);
+        rc = VbglR3GuestCtrlMsgWaitFor(g_uControlSvcClientID, &uMsg, &cParms);
         if (rc == VERR_TOO_MUCH_DATA)
         {
@@ -266 +259 @@
         {
             VBoxServiceVerbose(3, "Msg=%u (%u parms) retrieved\n", uMsg, cParms);
+
+            /* Set number of parameters for current host context. */
+            ctxHost.uNumParms = cParms;
+
+            /* Check for VM session change. */
+            uint64_t idNewSession = g_idControlSession;
+            int rc2 = VbglR3GetSessionId(&idNewSession);
+            if (   RT_SUCCESS(rc2)
+                && (idNewSession != g_idControlSession))
+            {
+                VBoxServiceVerbose(1, "The VM session ID changed\n");
+                g_idControlSession = idNewSession;
+
+                /* Close all opened guest sessions -- all context IDs, sessions etc.
+                 * are now invalid. */
+                rc2 = vboxServiceControlProcessCloseAll();
+                AssertRC(rc2);
+            }
+
             switch (uMsg)
             {
                 case HOST_CANCEL_PENDING_WAITS:
-                    VBoxServiceVerbose(3, "Host asked us to quit ...\n");
+                    VBoxServiceVerbose(1, "We were asked to quit ...\n");
                     break;
 
+                case HOST_SESSION_CREATE:
+                    rc = gstcntlHandleSessionOpen(&ctxHost);
+                    break;
+
+                case HOST_SESSION_CLOSE:
+                    rc = gstcntlHandleSessionClose(&ctxHost);
+                    break;
+
                 case HOST_EXEC_CMD:
-                    rc = gstcntlHandleCmdStartProc(g_uControlSvcClientID, cParms);
+                    rc = gstcntlHandleProcExec(&ctxHost);
                     break;
 
                 case HOST_EXEC_SET_INPUT:
-                    rc = gstcntlHandleCmdSetInput(g_uControlSvcClientID, cParms,
-                                                             pvScratchBuf, cbScratchBuf);
+                    rc = gstcntlHandleProcInput(&ctxHost,
+                                                pvScratchBuf, cbScratchBuf);
                     break;
 
                 case HOST_EXEC_GET_OUTPUT:
-                    rc = gstcntlHandleCmdGetOutput(g_uControlSvcClientID, cParms);
+                    rc = gstcntlHandleProcOutput(&ctxHost);
                     break;
 
-               case HOST_FILE_OPEN:
-                    rc = gstcntlHandleFileOpen(g_uControlSvcClientID, cParms);
+                case HOST_EXEC_TERMINATE:
+                    rc = gstcntlHandleProcTerminate(&ctxHost);
                     break;
 
-                case HOST_FILE_CLOSE:
-                    rc = gstcntlHandleFileClose(g_uControlSvcClientID, cParms);
-                    break;
-
-                case HOST_FILE_READ:
-                    rc = gstcntlHandleFileRead(g_uControlSvcClientID, cParms);
-                    break;
-
-                case HOST_FILE_WRITE:
-                    rc = gstcntlHandleFileWrite(g_uControlSvcClientID, cParms,
-                                                           pvScratchBuf, cbScratchBuf);
-                    break;
-
-                case HOST_FILE_SEEK:
-                    rc = gstcntlHandleFileSeek(g_uControlSvcClientID, cParms);
-                    break;
-
-                case HOST_FILE_TELL:
-                    rc = gstcntlHandleFileTell(g_uControlSvcClientID, cParms);
+                case HOST_EXEC_WAIT_FOR:
+                    rc = gstcntlHandleProcWaitFor(&ctxHost);
                     break;
 
@@ -321 +324 @@
             || (RT_SUCCESS(rc) && uMsg == HOST_CANCEL_PENDING_WAITS))
         {
-            rc = VINF_SUCCESS;
             break;
         }
@@ -328 +330 @@
         RTThreadYield();
     }
+
+    VBoxServiceVerbose(0, "Guest control service stopped\n");
 
     /* Delete scratch buffer. */
@@ -333 +337 @@
         RTMemFree(pvScratchBuf);
 
+    VBoxServiceVerbose(0, "Guest control worker returned with rc=%Rrc\n", rc);
     return rc;
 }
@@ -344 +349 @@
  * @param   cParms          The number of parameters the host is offering.
  */
-static int gstcntlHandleCmdStartProc(uint32_t uClientID, uint32_t cParms)
-{
-    uint32_t uContextID = 0;
+static int gstcntlHandleProcExec(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
 
     int rc;
     bool fStartAllowed = false; /* Flag indicating whether starting a process is allowed or not. */
-    if (cParms == 11)
-    {
-        VBOXSERVICECTRLPROCESS proc;
+
+    if (   (pHostCtx->uProtocol < 2  && pHostCtx->uNumParms == 11)
+        || (pHostCtx->uProtocol >= 2 && pHostCtx->uNumParms == 12)
+       )
+    {
+        VBOXSERVICECTRLPROCSTARTUPINFO proc;
         RT_ZERO(proc);
 
@@ -360 +368 @@
         proc.cbEnv = sizeof(proc.szEnv);
 
-        rc = VbglR3GuestCtrlExecGetHostCmdExec(uClientID,
-                                               cParms,
-                                               &uContextID,
-                                               /* Command */
-                                               proc.szCmd,      sizeof(proc.szCmd),
-                                               /* Flags */
-                                               &proc.uFlags,
-                                               /* Arguments */
-                                               proc.szArgs,     sizeof(proc.szArgs), &proc.uNumArgs,
-                                               /* Environment */
-                                               proc.szEnv, &proc.cbEnv, &proc.uNumEnvVars,
-                                               /* Credentials */
-                                               proc.szUser,     sizeof(proc.szUser),
-                                               proc.szPassword, sizeof(proc.szPassword),
-                                               /* Timelimit */
-                                               &proc.uTimeLimitMS);
-        if (RT_SUCCESS(rc))
-        {
-            VBoxServiceVerbose(3, "Request to start process szCmd=%s, uFlags=0x%x, szArgs=%s, szEnv=%s, szUser=%s, szPassword=%s, uTimeout=%u\n",
+        rc = VbglR3GuestCtrlProcGetStart(pHostCtx,
+                                         /* Command */
+                                         proc.szCmd,      sizeof(proc.szCmd),
+                                         /* Flags */
+                                         &proc.uFlags,
+                                         /* Arguments */
+                                         proc.szArgs,     sizeof(proc.szArgs), &proc.uNumArgs,
+                                         /* Environment */
+                                         proc.szEnv, &proc.cbEnv, &proc.uNumEnvVars,
+                                         /* Credentials; for hosts with VBox < 4.3. */
+                                         proc.szUser,     sizeof(proc.szUser),
+                                         proc.szPassword, sizeof(proc.szPassword),
+                                         /* Timelimit */
+                                         &proc.uTimeLimitMS,
+                                         /* Process priority */
+                                         &proc.uPriority,
+                                         /* Process affinity */
+                                         proc.uAffinity,  sizeof(proc.uAffinity), &proc.uNumAffinity);
+        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",
                                proc.szCmd, proc.uFlags,
                                proc.uNumArgs ? proc.szArgs : "<None>",
@@ -400 +410 @@
                 if (fStartAllowed)
                 {
-                    rc = GstCntlProcessStart(uContextID, &proc);
+                    rc = GstCntlProcessStart(pHostCtx->uContextID, &proc);
                 }
                 else
@@ -408 +418 @@
     }
     else
-        rc = VERR_INVALID_PARAMETER; /* Incorrect number of parameters. */
+        rc = VERR_NOT_SUPPORTED; /* Unsupported number of parameters. */
 
     /* In case of an error we need to notify the host to not wait forever for our response. */
@@ -419 +429 @@
          *       from the host. The host in case has to deal with that!
          */
-        int rc2 = VbglR3GuestCtrlExecReportStatus(uClientID, uContextID /* Might be 0 */, 0 /* PID, invalid */,
-                                                  PROC_STS_ERROR, rc,
-                                                  NULL /* pvData */, 0 /* cbData */);
+        int rc2 = VbglR3GuestCtrlProcCbStatus(pHostCtx->uClientID, pHostCtx->uContextID,
+                                              0 /* PID, invalid */,
+                                              PROC_STS_ERROR, rc,
+                                              NULL /* pvData */, 0 /* cbData */);
         if (RT_FAILURE(rc2))
         {
@@ -427 +438 @@
             if (RT_SUCCESS(rc))
                 rc = rc2;
+        }
+    }
+
+    return rc;
+}
+
+
+static int gstcntlHandleProcTerminate(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    uint32_t uPID;
+    int rc = VbglR3GuestCtrlProcGetTerminate(pHostCtx, &uPID);
+    if (RT_SUCCESS(rc))
+    {
+        PVBOXSERVICECTRLREQUEST pRequest;
+        rc = GstCntlProcessRequestAllocEx(&pRequest, VBOXSERVICECTRLREQUEST_PROC_TERM,
+                                          NULL /* pvBuf */, NULL /* cbBuf */, pHostCtx->uContextID);
+        if (RT_SUCCESS(rc))
+        {
+            rc = GstCntlProcessPerform(uPID, pRequest);
+            GstCntlProcessRequestFree(pRequest);
+        }
+    }
+
+    return rc;
+}
+
+
+static int gstcntlHandleProcWaitFor(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    uint32_t uPID;
+    uint32_t uWaitFlags; uint32_t uTimeoutMS;
+
+    int rc = VbglR3GuestCtrlProcGetWaitFor(pHostCtx, &uPID, &uWaitFlags, &uTimeoutMS);
+    if (RT_SUCCESS(rc))
+    {
+        PVBOXSERVICECTRLREQUEST pRequest;
+        VBOXSERVICECTRLREQDATA_WAIT_FOR reqData = { uWaitFlags, uTimeoutMS };
+        rc = GstCntlProcessRequestAllocEx(&pRequest, VBOXSERVICECTRLREQUEST_WAIT_FOR,
+                                          &reqData, sizeof(reqData), pHostCtx->uContextID);
+        if (RT_SUCCESS(rc))
+        {
+            rc = GstCntlProcessPerform(uPID, pRequest);
+            GstCntlProcessRequestFree(pRequest);
         }
     }
@@ -439 +497 @@
  * @return  IPRT status code.
  * @param   uPID                    PID of process to retrieve the output from.
+ * @param   uCID                    Context ID.
  * @param   uHandleId               Stream ID (stdout = 0, stderr = 2) to get the output from.
  * @param   cMsTimeout              Timeout (in ms) to wait for output becoming
@@ -459 +518 @@
     {
         case OUTPUT_HANDLE_ID_STDERR:
-            reqType = VBOXSERVICECTRLREQUEST_STDERR_READ;
+            reqType = VBOXSERVICECTRLREQUEST_PROC_STDERR;
             break;
 
         case OUTPUT_HANDLE_ID_STDOUT:
         case OUTPUT_HANDLE_ID_STDOUT_DEPRECATED:
-            reqType = VBOXSERVICECTRLREQUEST_STDOUT_READ;
+            reqType = VBOXSERVICECTRLREQUEST_PROC_STDOUT;
             break;
 
@@ -505 +564 @@
     if (RT_SUCCESS(rc))
     {
-        VBoxServiceVerbose(3, "Setting thread (PID %u) to list %d\n",
+        VBoxServiceVerbose(3, "Setting thread (PID %RU32) to list %d\n",
                            pThread->uPID, enmList);
 
@@ -572 +631 @@
     int rc = GstCntlProcessRequestAllocEx(&pRequest,
                                           fPendingClose
-                                          ? VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF
-                                          : VBOXSERVICECTRLREQUEST_STDIN_WRITE,
+                                          ? VBOXSERVICECTRLREQUEST_PROC_STDIN_EOF
+                                          : VBOXSERVICECTRLREQUEST_PROC_STDIN,
                                           pvBuf, cbBuf, uCID);
     if (RT_SUCCESS(rc))
@@ -596 +655 @@
  *
  * @returns IPRT status code.
- * @param   idClient                    The HGCM client session ID.
- * @param   cParms                      The number of parameters the host is
- *                                      offering.
  * @param   pvScratchBuf                The scratch buffer.
  * @param   cbScratchBuf                The scratch buffer size for retrieving the input data.
  */
-static int gstcntlHandleCmdSetInput(uint32_t idClient, uint32_t cParms,
-                                    void *pvScratchBuf, size_t cbScratchBuf)
-{
+static int gstcntlHandleProcInput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx,
+                                  void *pvScratchBuf, size_t cbScratchBuf)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
     AssertPtrReturn(cbScratchBuf, VERR_INVALID_PARAMETER);
     AssertPtrReturn(pvScratchBuf, VERR_INVALID_POINTER);
 
-    uint32_t uContextID;
     uint32_t uPID;
     uint32_t uFlags;
@@ -619 +675 @@
      * Ask the host for the input data.
      */
-    int rc = VbglR3GuestCtrlExecGetHostCmdInput(idClient, cParms,
-                                                &uContextID, &uPID, &uFlags,
-                                                pvScratchBuf, cbScratchBuf, &cbSize);
+    int rc = VbglR3GuestCtrlProcGetInput(pHostCtx, &uPID, &uFlags,
+                                         pvScratchBuf, cbScratchBuf, &cbSize);
     if (RT_FAILURE(rc))
     {
-        VBoxServiceError("[PID %u]: Failed to retrieve exec input command! Error: %Rrc\n",
+        VBoxServiceError("[PID %RU32]: Failed to retrieve exec input command! Error: %Rrc\n",
                          uPID, rc);
     }
     else if (cbSize > cbScratchBuf)
     {
-        VBoxServiceError("[PID %u]: Too much input received! cbSize=%u, cbScratchBuf=%u\n",
+        VBoxServiceError("[PID %RU32]: Too much input received! cbSize=%u, cbScratchBuf=%u\n",
                          uPID, cbSize, cbScratchBuf);
         rc = VERR_INVALID_PARAMETER;
@@ -642 +697 @@
         {
             fPendingClose = true;
-            VBoxServiceVerbose(4, "[PID %u]: Got last input block of size %u ...\n",
+            VBoxServiceVerbose(4, "[PID %RU32]: Got last input block of size %u ...\n",
                                uPID, cbSize);
         }
 
-        rc = VBoxServiceControlSetInput(uPID, uContextID, fPendingClose, pvScratchBuf,
+        rc = VBoxServiceControlSetInput(uPID, pHostCtx->uContextID, fPendingClose, pvScratchBuf,
                                         cbSize, &cbWritten);
-        VBoxServiceVerbose(4, "[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);
+        VBoxServiceVerbose(4, "[PID %RU32]: Written input, CID=%u, rc=%Rrc, uFlags=0x%x, fPendingClose=%d, cbSize=%u, cbWritten=%u\n",
+                           uPID, pHostCtx->uContextID, rc, uFlags, fPendingClose, cbSize, cbWritten);
         if (RT_SUCCESS(rc))
         {
@@ -676 +731 @@
     Assert(uStatus > INPUT_STS_UNDEFINED);
 
-    VBoxServiceVerbose(3, "[PID %u]: Input processed, CID=%u, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
-                       uPID, uContextID, uStatus, uFlags, cbWritten);
+    VBoxServiceVerbose(3, "[PID %RU32]: Input processed, CID=%u, uStatus=%u, uFlags=0x%x, cbWritten=%u\n",
+                       uPID, pHostCtx->uContextID, uStatus, uFlags, cbWritten);
 
     /* Note: Since the context ID is unique the request *has* to be completed here,
      *       regardless whether we got data or not! Otherwise the progress object
      *       on the host never will get completed! */
-    rc = VbglR3GuestCtrlExecReportStatusIn(idClient, uContextID, uPID,
-                                           uStatus, uFlags, (uint32_t)cbWritten);
+    rc = VbglR3GuestCtrlProcCbStatusInput(pHostCtx->uClientID, pHostCtx->uContextID, uPID,
+                                          uStatus, uFlags, (uint32_t)cbWritten);
 
     if (RT_FAILURE(rc))
-        VBoxServiceError("[PID %u]: Failed to report input status! Error: %Rrc\n",
+        VBoxServiceError("[PID %RU32]: Failed to report input status! Error: %Rrc\n",
                          uPID, rc);
-    return rc;
-}
-
-
-static PVBOXSERVICECTRLFILE gstcntlGetFile(uint32_t uHandle)
-{
-    PVBOXSERVICECTRLFILE pFileCur = NULL;
-    /** @todo Use a map later! */
-    RTListForEach(&g_lstControlFiles, pFileCur, VBOXSERVICECTRLFILE, Node)
-    {
-        if (pFileCur->uHandle == uHandle)
-            return pFileCur;
-    }
-
-    return NULL;
-}
-
-
-static int gstcntlHandleFileOpen(uint32_t idClient, uint32_t cParms)
-{
-    uint32_t uContextID;
-
-    char szFile[RTPATH_MAX];
-    char szOpenMode[64];
-    char szDisposition[64];
-    uint32_t uCreationMode;
-    uint64_t uOffset;
-
-    int rc = VbglR3GuestCtrlFileGetHostCmdOpen(idClient, cParms, &uContextID,
-                                               /* File to open. */
-                                               szFile, sizeof(szFile),
-                                               /* Open mode. */
-                                               szOpenMode, sizeof(szOpenMode),
-                                               /* Disposition. */
-                                               szDisposition, sizeof(szDisposition),
-                                               /* Creation mode. */
-                                               &uCreationMode,
-                                               /* Offset. */
-                                               &uOffset);
-    if (RT_SUCCESS(rc))
-    {
-        PVBOXSERVICECTRLFILE pFile = (PVBOXSERVICECTRLFILE)RTMemAlloc(sizeof(VBOXSERVICECTRLFILE));
-        if (!pFile)
-            return VERR_NO_MEMORY;
-
-        if (!RTStrPrintf(pFile->szName, sizeof(pFile->szName), "%s", szFile))
-            rc = VERR_BUFFER_UNDERFLOW;
-
-        if (RT_SUCCESS(rc))
-        {
-            uint64_t fFlags = RTFILE_O_OPEN_CREATE | RTFILE_O_WRITE | RTFILE_O_DENY_WRITE; /** @todo Modes! */
-            rc = RTFileOpen(&pFile->hFile, pFile->szName, fFlags);
-            if (   RT_SUCCESS(rc)
-                && uOffset)
-            {
-                /* Seeking is optional. */
-                int rc2 = RTFileSeek(pFile->hFile, (int64_t)uOffset, RTFILE_SEEK_BEGIN, NULL /* Current offset */);
-                if (RT_FAILURE(rc2))
-                    VBoxServiceVerbose(3, "[File %s]: Seeking to offset %RU64 failed; rc=%Rrc\n",
-                                       pFile->szName, uOffset, rc);
-            }
-            else
-                VBoxServiceVerbose(3, "[File %s]: Opening failed; rc=%Rrc\n",
-                                   pFile->szName, rc);
-        }
-
-        uint32_t uHandle = 0;
-        if (RT_SUCCESS(rc))
-        {
-            VBoxServiceVerbose(3, "[File %s]: Opened.\n", pFile->szName);
-
-            uHandle = g_uControlFileCount++;
-            pFile->uHandle = uHandle;
-            /* rc = */ RTListAppend(&g_lstControlFiles, &pFile->Node);
-        }
-
-        if (RT_FAILURE(rc))
-            RTMemFree(pFile);
-
-        /* Report back in any case. */
-        int rc2 = VbglR3GuestCtrlFileNotify(idClient, uContextID, uHandle,
-                                            GUESTFILENOTIFYTYPE_OPEN, &rc, sizeof(rc));
-        if (RT_FAILURE(rc2))
-            VBoxServiceError("[File %s]: Failed to report open status, rc=%Rrc\n",
-                             szFile, rc2);
-        if (RT_SUCCESS(rc))
-            rc = rc2;
-    }
-    return rc;
-}
-
-
-static int gstcntlHandleFileClose(uint32_t idClient, uint32_t cParms)
-{
-    uint32_t uContextID;
-    uint32_t uHandle;
-
-    int rc = VbglR3GuestCtrlFileGetHostCmdClose(idClient, cParms, &uContextID,
-                                                /* File handle to close. */
-                                                &uHandle);
-    if (RT_SUCCESS(rc))
-    {
-        PVBOXSERVICECTRLFILE pFile = gstcntlGetFile(uHandle);
-        if (pFile)
-        {
-            rc = RTFileClose(pFile->hFile);
-        }
-        else
-            rc = VERR_NOT_FOUND;
-
-        /* Report back in any case. */
-        int rc2 = VbglR3GuestCtrlFileNotify(idClient, uContextID, uHandle,
-                                            GUESTFILENOTIFYTYPE_CLOSE, &rc, sizeof(rc));
-        if (RT_FAILURE(rc2))
-            VBoxServiceError("Failed to report close status, rc=%Rrc\n", rc2);
-        if (RT_SUCCESS(rc))
-            rc = rc2;
-    }
-    return rc;
-}
-
-
-static int gstcntlHandleFileRead(uint32_t idClient, uint32_t cParms)
-{
-    uint32_t uContextID;
-    uint32_t uHandle;
-    uint32_t cbToRead;
-
-    int rc = VbglR3GuestCtrlFileGetHostCmdRead(idClient, cParms, &uContextID,
-                                               &uHandle, &cbToRead);
-    if (RT_SUCCESS(rc))
-    {
-
-    }
-    return rc;
-}
-
-
-static int gstcntlHandleFileWrite(uint32_t idClient, uint32_t cParms,
-                                             void *pvScratchBuf, size_t cbScratchBuf)
-{
-    AssertPtrReturn(cbScratchBuf, VERR_INVALID_PARAMETER);
-    AssertPtrReturn(pvScratchBuf, VERR_INVALID_POINTER);
-
-    uint32_t uContextID;
-    uint32_t uHandle;
-    uint32_t cbToWrite;
-
-    int rc = VbglR3GuestCtrlFileGetHostCmdWrite(idClient, cParms, &uContextID,
-                                                &uHandle, pvScratchBuf, cbScratchBuf,
-                                                &cbToWrite);
-    if (RT_SUCCESS(rc))
-    {
-
-    }
-    return rc;
-}
-
-
-static int gstcntlHandleFileSeek(uint32_t idClient, uint32_t cParms)
-{
-    uint32_t uContextID;
-    uint32_t uHandle;
-    uint32_t uSeekMethod;
-    uint64_t uOffset; /* Will be converted to int64_t. */
-
-    int rc = VbglR3GuestCtrlFileGetHostCmdSeek(idClient, cParms, &uContextID,
-                                               &uHandle, &uSeekMethod, &uOffset);
-    if (RT_SUCCESS(rc))
-    {
-
-    }
-    return rc;
-}
-
-
-static int gstcntlHandleFileTell(uint32_t idClient, uint32_t cParms)
-{
-    uint32_t uContextID;
-    uint32_t uHandle;
-
-    int rc = VbglR3GuestCtrlFileGetHostCmdTell(idClient, cParms, &uContextID,
-                                               &uHandle);
-    if (RT_SUCCESS(rc))
-    {
-
-    }
     return rc;
 }
@@ -883 +751 @@
  *
  * @return  IPRT status code.
- * @param   idClient        The HGCM client session ID.
- * @param   cParms          The number of parameters the host is offering.
- */
-static int gstcntlHandleCmdGetOutput(uint32_t idClient, uint32_t cParms)
-{
-    uint32_t uContextID;
+ */
+static int gstcntlHandleProcOutput(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
     uint32_t uPID;
     uint32_t uHandleID;
     uint32_t uFlags;
 
-    int rc = VbglR3GuestCtrlExecGetHostCmdOutput(idClient, cParms,
-                                                 &uContextID, &uPID, &uHandleID, &uFlags);
+    int rc = VbglR3GuestCtrlProcGetOutput(pHostCtx, &uPID, &uHandleID, &uFlags);
     if (RT_SUCCESS(rc))
     {
@@ -901 +767 @@
         {
             uint32_t cbRead = 0;
-            rc = VBoxServiceControlExecGetOutput(uPID, uContextID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
+            rc = VBoxServiceControlExecGetOutput(uPID, pHostCtx->uContextID, uHandleID, RT_INDEFINITE_WAIT /* Timeout */,
                                                  pBuf, _64K /* cbSize */, &cbRead);
-            VBoxServiceVerbose(3, "[PID %u]: Got output, rc=%Rrc, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
-                               uPID, rc, uContextID, cbRead, uHandleID, uFlags);
+            VBoxServiceVerbose(3, "[PID %RU32]: Got output, rc=%Rrc, CID=%u, cbRead=%u, uHandle=%u, uFlags=%u\n",
+                               uPID, rc, pHostCtx->uContextID, cbRead, uHandleID, uFlags);
 
 #ifdef DEBUG
@@ -934 +800 @@
              *       regardless whether we got data or not! Otherwise the progress object
              *       on the host never will get completed! */
-            int rc2 = VbglR3GuestCtrlExecSendOut(idClient, uContextID, uPID, uHandleID, uFlags,
-                                                 pBuf, cbRead);
+            int rc2 = VbglR3GuestCtrlProcCbOutput(pHostCtx->uClientID, pHostCtx->uContextID, uPID, uHandleID, uFlags,
+                                                  pBuf, cbRead);
             if (RT_SUCCESS(rc))
                 rc = rc2;
@@ -948 +814 @@
 
     if (RT_FAILURE(rc))
-        VBoxServiceError("[PID %u]: Error handling output command! Error: %Rrc\n",
+        VBoxServiceError("[PID %RU32]: Error handling output command! Error: %Rrc\n",
                          uPID, rc);
+    return rc;
+}
+
+
+static int gstcntlHandleSessionOpen(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    VBOXSERVICECTRLSESSIONSTARTUPINFO ssInfo = { 0 };
+    int rc = VbglR3GuestCtrlSessionGetOpen(pHostCtx,
+                                           &ssInfo.uProtocol,
+                                           ssInfo.szUser,     sizeof(ssInfo.szUser),
+                                           ssInfo.szPassword, sizeof(ssInfo.szPassword),
+                                           ssInfo.szDomain,   sizeof(ssInfo.szDomain),
+                                           &ssInfo.uFlags,    &ssInfo.uSessionID);
+    if (RT_SUCCESS(rc))
+    {
+        /* The session open call has the protocol version the host
+         * wants to use. Store it in the host context for later calls. */
+        pHostCtx->uProtocol = ssInfo.uProtocol;
+
+        rc = GstCntlSessionOpen(&ssInfo, NULL /* Node */);
+    }
+
+    /* Report back session opening status in any case. */
+    int rc2 = VbglR3GuestCtrlSessionNotify(pHostCtx->uClientID, pHostCtx->uContextID,
+                                           GUEST_SESSION_NOTIFYTYPE_OPEN, rc /* uint32_t vs. int */);
+    if (RT_FAILURE(rc2))
+    {
+        VBoxServiceError("Reporting session opening status failed with rc=%Rrc\n", rc2);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+
+    VBoxServiceVerbose(3, "Opening a new guest session returned rc=%Rrc\n", rc);
+    return rc;
+}
+
+
+static int gstcntlHandleSessionClose(PVBGLR3GUESTCTRLHOSTCTX pHostCtx)
+{
+    AssertPtrReturn(pHostCtx, VERR_INVALID_POINTER);
+
+    uint32_t uSessionID, uFlags;
+
+    int rc = VbglR3GuestCtrlSessionGetClose(pHostCtx, &uFlags, &uSessionID);
+    if (RT_SUCCESS(rc))
+    {
+        rc = VERR_NOT_FOUND;
+
+        PVBOXSERVICECTRLSESSION pSession;
+        RTListForEach(&g_lstControlSessions, pSession, VBOXSERVICECTRLSESSION, Node)
+        {
+            if (pSession->StartupInfo.uSessionID == uSessionID)
+            {
+                rc = GstCntlSessionClose(pSession, uFlags);
+                break;
+            }
+        }
+    }
+
+    /* Report back session closing status in any case. */
+    int rc2 = VbglR3GuestCtrlSessionNotify(pHostCtx->uClientID, pHostCtx->uContextID,
+                                           GUEST_SESSION_NOTIFYTYPE_CLOSE, rc /* uint32_t vs. int */);
+    if (RT_FAILURE(rc2))
+    {
+        VBoxServiceError("Reporting session closing status failed with rc=%Rrc\n", rc2);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+
+    VBoxServiceVerbose(2, "Closing guest session %RU32 returned rc=%Rrc\n",
+                       uSessionID, rc);
     return rc;
 }
@@ -1030 +969 @@
 
 
-/**
- * Destroys all guest process threads which are still active.
- */
-static void VBoxServiceControlShutdown(void)
-{
-    VBoxServiceVerbose(2, "Shutting down ...\n");
+static int vboxServiceControlProcessClose()
+{
+    /** Note: This will be a guest tsession task later. */
 
     /* Signal all threads in the active list that we want to shutdown. */
@@ -1053 +989 @@
                                      NULL /* rc */);
         if (RT_FAILURE(rc2))
+        {
             VBoxServiceError("Guest process thread failed to stop; rc=%Rrc\n", rc2);
+            /* Keep going. */
+        }
 
         if (fLast)
@@ -1061 +1000 @@
     }
 
-    int rc2 = gstcntlReapThreads();
-    if (RT_FAILURE(rc2))
-        VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc2);
+    int rc = gstcntlReapThreads();
+    if (RT_FAILURE(rc))
+        VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc);
 
     AssertMsg(RTListIsEmpty(&g_lstControlThreadsActive),
@@ -1070 +1009 @@
               ("Guest process inactive thread list still contains entries when it should not\n"));
 
+    return rc;
+}
+
+
+static int vboxServiceControlProcessCloseAll(void)
+{
+    return vboxServiceControlProcessClose();
+}
+
+
+/**
+ * Destroys all guest process threads which are still active.
+ */
+static void VBoxServiceControlShutdown(void)
+{
+    VBoxServiceVerbose(2, "Shutting down ...\n");
+
+    int rc2 = vboxServiceControlProcessCloseAll();
+    AssertRC(rc2);
+
     /* Destroy critical section. */
     RTCritSectDelete(&g_csControlThreads);
-
-    /* Close all left guest files. */
-    PVBOXSERVICECTRLFILE pFile;
-    pFile = RTListGetFirst(&g_lstControlFiles, VBOXSERVICECTRLFILE, Node);
-    while (pFile)
-    {
-        PVBOXSERVICECTRLFILE pNext = RTListNodeGetNext(&pFile->Node, VBOXSERVICECTRLFILE, Node);
-        bool fLast = RTListNodeIsLast(&g_lstControlFiles, &pFile->Node);
-
-        rc2 = RTFileClose(pFile->hFile);
-        if (RT_FAILURE(rc2))
-        {
-            VBoxServiceError("Unable to close file \"%s\"; rc=%Rrc\n",
-                             pFile->szName, rc2);
-            /* Keep going. */
-        }
-
-        RTListNodeRemove(&pFile->Node);
-
-        if (fLast)
-            break;
-
-        pFile = pNext;
-    }
-
-    AssertMsg(RTListIsEmpty(&g_lstControlFiles),
-              ("Guest file list still contains entries when it should not\n"));
 
     VBoxServiceVerbose(2, "Shutting down complete\n");
@@ -1251 +1183 @@
                     uint32_t uTriedPID = uPID;
                     uPID += 391939;
-                    VBoxServiceVerbose(2, "PID %u was used before, trying again with %u ...\n",
+                    VBoxServiceVerbose(2, "PID %RU32 was used before, trying again with %u ...\n",
                                        uTriedPID, uPID);
                     fTryAgain = true;
@@ -1283 +1215 @@
     "              [--control-dump-stderr] [--control-dump-stdout]\n"
 #endif
-    "              [--control-interval <ms>] [--control-procs-max-kept <x>]\n"
+    "              [--control-interval <ms>]\n"
     "              [--control-procs-mem-std[in|out|err] <KB>]"
     ,
@@ -1295 +1227 @@
     "    --control-interval      Specifies the interval at which to check for\n"
     "                            new control commands. The default is 1000 ms.\n"
-    "    --control-procs-max-kept\n"
-    "                            Specifies how many started guest processes are\n"
-    "                            kept into memory to work with. Default is 256.\n"
     ,
     /* methods */

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

@@ -1 +1 @@
 /* $Id$ */
 /** @file
- * VBoxServiceControlExecThread - Thread for every started guest process.
+ * VBoxServiceControlThread - Guest process handling.
  */
 
@@ -39 +39 @@
 
 #include "VBoxServiceInternal.h"
+#include "VBoxServiceControl.h"
 
 using namespace guestControl;
@@ -423 +424 @@
 
 
+/**
+ * Signals the given request.
+ *
+ * @return  IPRT status code.
+ * @param   pRequest                Pointer to request to signal.
+ * @param   rc                      rc to set request result to.
+ */
+static int gstcntlProcessSignalRequest(PVBOXSERVICECTRLREQUEST pRequest, int rc)
+{
+    AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
+
+    /* Assign overall result. */
+    pRequest->rc = rc;
+
+#ifdef _DEBUG
+    VBoxServiceVerbose(4, "Handled req=%u, CID=%u, rc=%Rrc, cbData=%u, pvData=%p\n",
+                       pRequest->enmType, pRequest->uCID, pRequest->rc,
+                       pRequest->cbData, pRequest->pvData);
+#endif
+
+    /* In any case, regardless of the result, we notify
+     * the main guest control to unblock it. */
+    int rc2 = RTSemEventMultiSignal(pRequest->Event);
+    AssertRC(rc2);
+
+    return rc2;
+}
+
+
 static int gstcntlProcessHandleRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,
                                        PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR,
-                                       PVBOXSERVICECTRLTHREAD pThread)
-{
-    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+                                       PVBOXSERVICECTRLTHREAD pThread, PVBOXSERVICECTRLREQUEST pRequest)
+{
     AssertPtrReturn(phStdInW, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdOutR, VERR_INVALID_POINTER);
     AssertPtrReturn(phStdErrR, VERR_INVALID_POINTER);
+    AssertPtrReturn(pThread, VERR_INVALID_POINTER);
+    AssertPtrReturn(pRequest, VERR_INVALID_POINTER);
 
     /* Drain the notification pipe. */
@@ -439 +470 @@
         VBoxServiceError("Draining IPC notification pipe failed with rc=%Rrc\n", rc);
 
+    bool fDefer = false; /* Whether the request completion should be deferred or not. */
     int rcReq = VINF_SUCCESS; /* Actual request result. */
-
-    PVBOXSERVICECTRLREQUEST pRequest = pThread->pRequest;
-    if (!pRequest)
-    {
-        VBoxServiceError("IPC request is invalid\n");
-        return VERR_INVALID_POINTER;
-    }
 
     switch (pRequest->enmType)
@@ -459 +484 @@
         }
 
-        case VBOXSERVICECTRLREQUEST_STDIN_WRITE:
-        case VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF:
+        case VBOXSERVICECTRLREQUEST_PROC_STDIN:
+        case VBOXSERVICECTRLREQUEST_PROC_STDIN_EOF:
         {
             size_t cbWritten = 0;
@@ -480 +505 @@
              * the poll set.
              */
-            if (   pRequest->enmType == VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF
+            if (   pRequest->enmType == VBOXSERVICECTRLREQUEST_PROC_STDIN_EOF
                 && pRequest->cbData  == cbWritten)
             {
@@ -491 +516 @@
         }
 
-        case VBOXSERVICECTRLREQUEST_STDOUT_READ:
-        case VBOXSERVICECTRLREQUEST_STDERR_READ:
+        case VBOXSERVICECTRLREQUEST_PROC_STDOUT:
+        case VBOXSERVICECTRLREQUEST_PROC_STDERR:
         {
             AssertPtrReturn(pRequest->pvData, VERR_INVALID_POINTER);
             AssertReturn(pRequest->cbData, VERR_INVALID_PARAMETER);
 
-            PRTPIPE pPipeR = pRequest->enmType == VBOXSERVICECTRLREQUEST_STDERR_READ
+            PRTPIPE pPipeR = pRequest->enmType == VBOXSERVICECTRLREQUEST_PROC_STDERR
                            ? phStdErrR : phStdOutR;
             AssertPtr(pPipeR);
@@ -508 +533 @@
                 if (RT_FAILURE(rcReq))
                 {
-                    RTPollSetRemove(hPollSet, pRequest->enmType == VBOXSERVICECTRLREQUEST_STDERR_READ
+                    RTPollSetRemove(hPollSet, pRequest->enmType == VBOXSERVICECTRLREQUEST_PROC_STDERR
                                               ? VBOXSERVICECTRLPIPEID_STDERR : VBOXSERVICECTRLPIPEID_STDOUT);
                     RTPipeClose(*pPipeR);
@@ -524 +549 @@
         }
 
+        case VBOXSERVICECTRLREQUEST_PROC_TERM:
+            ASMAtomicXchgBool(&pThread->fShutdown, true);
+            fDefer = true;
+            break;
+
         default:
             rcReq = VERR_NOT_IMPLEMENTED;
@@ -529 +559 @@
     }
 
-    /* Assign overall result. */
-    pRequest->rc = RT_SUCCESS(rc)
-                 ? rcReq : rc;
-
-    VBoxServiceVerbose(2, "[PID %u]: Handled req=%u, CID=%u, rc=%Rrc, cbData=%u\n",
-                       pThread->uPID, pRequest->enmType, pRequest->uCID, pRequest->rc, pRequest->cbData);
-
-    /* In any case, regardless of the result, we notify
-     * the main guest control to unblock it. */
-    int rc2 = RTSemEventMultiSignal(pRequest->Event);
-    AssertRC(rc2);
-
-    /* No access to pRequest here anymore -- could be out of scope
-     * or modified already! */
-    pThread->pRequest = pRequest = NULL;
+    if (   RT_FAILURE(rc)
+        || !fDefer)
+    {
+        rc = gstcntlProcessSignalRequest(pRequest,
+                                         RT_SUCCESS(rc) ? rcReq : rc);
+
+        /* No access to pRequest here anymore -- could be out of scope
+         * or modified already! */
+        pThread->pRequest = pRequest = NULL;
+    }
+    else /* Completing the request defered. */
+        rc = VINF_AIO_TASK_PENDING; /** @todo Find an own rc! */
 
     return rc;
@@ -601 +628 @@
     VBoxServiceVerbose(2, "[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 */,
-                                         NULL /* pvData */, 0 /* cbData */);
+    rc = VbglR3GuestCtrlProcCbStatus(pThread->uClientID, pThread->uContextID,
+                                     pThread->uPID, PROC_STS_STARTED, 0 /* u32Flags */,
+                                     NULL /* pvData */, 0 /* cbData */);
 
     /*
      * Process input, output, the test pipe and client requests.
      */
+    PVBOXSERVICECTRLREQUEST pReq = NULL;
     while (   RT_SUCCESS(rc)
            && RT_UNLIKELY(!pThread->fShutdown))
@@ -642 +670 @@
 
                 case VBOXSERVICECTRLPIPEID_IPC_NOTIFY:
+                    pReq = pThread->pRequest; /** @todo Implement request queue. */
                     rc = gstcntlProcessHandleRequest(hPollSet, fPollEvt,
-                                                     phStdInW, phStdOutR, phStdErrR, pThread);
+                                                     phStdInW, phStdOutR, phStdErrR,
+                                                     pThread, pReq);
+                    if (rc != VINF_AIO_TASK_PENDING)
+                        pReq = NULL;
                     break;
 
@@ -707 +739 @@
             if (cMsElapsed >= cMsTimeout)
             {
-                VBoxServiceVerbose(3, "[PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...",
+                VBoxServiceVerbose(3, "[PID %u]: Timed out (%ums elapsed > %ums timeout), killing ...\n",
                                    pThread->uPID, cMsElapsed, cMsTimeout);
 
@@ -787 +819 @@
         if (fProcessAlive)
             VBoxServiceVerbose(3, "[PID %u]: Could not be killed\n", pThread->uPID);
+
+        if (   pReq /* Handle deferred termination request. */
+            && pReq->enmType == VBOXSERVICECTRLREQUEST_PROC_TERM)
+        {
+            rc2 = gstcntlProcessSignalRequest(pReq,
+                                              fProcessAlive ? VINF_SUCCESS : VERR_PROCESS_RUNNING);
+            pReq = NULL;
+        }
+        else if (pReq)
+            AssertMsgFailed(("Unable to handle unknown deferred request (type: %RU32)\n", pReq->enmType));
     }
 
@@ -861 +903 @@
         if (!(pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_START))
         {
-            rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID,
-                                                 pThread->uPID, uStatus, uFlags,
-                                                 NULL /* pvData */, 0 /* cbData */);
+            rc2 = VbglR3GuestCtrlProcCbStatus(pThread->uClientID, pThread->uContextID,
+                                              pThread->uPID, uStatus, uFlags,
+                                              NULL /* pvData */, 0 /* cbData */);
             if (RT_FAILURE(rc2))
                 VBoxServiceError("[PID %u]: Error reporting final status to host; rc=%Rrc\n",
@@ -1050 +1092 @@
  *                              should service.
  */
-static int gstcntlProcessSetupPipe(const char *pszHowTo, int fd,
-                                   PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
+int GstcntlProcessSetupPipe(const char *pszHowTo, int fd,
+                            PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe)
 {
     AssertPtrReturn(ph, VERR_INVALID_POINTER);
@@ -1486 +1528 @@
             RTHANDLE    hStdIn;
             PRTHANDLE   phStdIn;
-            rc = gstcntlProcessSetupPipe("|", 0 /*STDIN_FILENO*/,
+            rc = GstcntlProcessSetupPipe("|", 0 /*STDIN_FILENO*/,
                                          &hStdIn, &phStdIn, &pThread->pipeStdInW);
             if (RT_SUCCESS(rc))
@@ -1493 +1535 @@
                 PRTHANDLE   phStdOut;
                 RTPIPE      pipeStdOutR;
-                rc = gstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)
+                rc = GstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)
                                              ? "|" : "/dev/null",
                                              1 /*STDOUT_FILENO*/,
@@ -1502 +1544 @@
                     PRTHANDLE   phStdErr;
                     RTPIPE      pipeStdErrR;
-                    rc = gstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)
+                    rc = GstcntlProcessSetupPipe(  (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)
                                                  ? "|" : "/dev/null",
                                                  2 /*STDERR_FILENO*/,
@@ -1627 +1669 @@
         if (RT_FAILURE(rc))
         {
-            rc2 = VbglR3GuestCtrlExecReportStatus(pThread->uClientID, pThread->uContextID, pThread->uPID,
-                                                  PROC_STS_ERROR, rc,
-                                                  NULL /* pvData */, 0 /* cbData */);
+            rc2 = VbglR3GuestCtrlProcCbStatus(pThread->uClientID, pThread->uContextID, pThread->uPID,
+                                              PROC_STS_ERROR, rc,
+                                              NULL /* pvData */, 0 /* cbData */);
             if (RT_FAILURE(rc2))
                 VBoxServiceError("Could not report process failure error; rc=%Rrc (process error %Rrc)\n",
@@ -1635 +1677 @@
         }
 
-        VBoxServiceVerbose(3, "[PID %u]: Cancelling pending host requests (client ID=%u)\n",
-                           pThread->uPID, pThread->uClientID);
-        rc2 = VbglR3GuestCtrlCancelPendingWaits(pThread->uClientID);
-        if (RT_FAILURE(rc2))
-        {
-            VBoxServiceError("[PID %u]: Cancelling pending host requests failed; rc=%Rrc\n",
-                             pThread->uPID, rc2);
-            if (RT_SUCCESS(rc))
-                rc = rc2;
-        }
-
-        /* Disconnect from guest control service. */
+        /* Disconnect this client from the guest control service. This also cancels all
+         * outstanding host requests. */
         VBoxServiceVerbose(3, "[PID %u]: Disconnecting (client ID=%u) ...\n",
                            pThread->uPID, pThread->uClientID);

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

@@ -108 +108 @@
 #endif /* RT_OS_WINDOWS */
 
-#ifdef VBOX_WITH_GUEST_CONTROL
-/**
- * Pipe IDs for handling the guest process poll set.
- */
-typedef enum VBOXSERVICECTRLPIPEID
-{
-    VBOXSERVICECTRLPIPEID_UNKNOWN           = 0,
-    VBOXSERVICECTRLPIPEID_STDIN             = 10,
-    VBOXSERVICECTRLPIPEID_STDIN_WRITABLE    = 11,
-    /** Pipe for reading from guest process' stdout. */
-    VBOXSERVICECTRLPIPEID_STDOUT            = 40,
-    /** Pipe for reading from guest process' stderr. */
-    VBOXSERVICECTRLPIPEID_STDERR            = 50,
-    /** Notification pipe for waking up the guest process
-     *  control thread. */
-    VBOXSERVICECTRLPIPEID_IPC_NOTIFY        = 100
-} VBOXSERVICECTRLPIPEID;
-
-/**
- * Request types to perform on a started guest process.
- */
-typedef enum VBOXSERVICECTRLREQUESTTYPE
-{
-    /** Unknown request. */
-    VBOXSERVICECTRLREQUEST_UNKNOWN          = 0,
-    /** Main control thread asked used to quit. */
-    VBOXSERVICECTRLREQUEST_QUIT             = 1,
-    /** Performs reading from stdout. */
-    VBOXSERVICECTRLREQUEST_STDOUT_READ      = 50,
-    /** Performs reading from stderr. */
-    VBOXSERVICECTRLREQUEST_STDERR_READ      = 60,
-    /** Performs writing to stdin. */
-    VBOXSERVICECTRLREQUEST_STDIN_WRITE      = 70,
-    /** Same as VBOXSERVICECTRLREQUEST_STDIN_WRITE, but
-     *  marks the end of input. */
-    VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF  = 71,
-    /** Kill/terminate process.
-     *  @todo Implement this! */
-    VBOXSERVICECTRLREQUEST_KILL             = 90,
-    /** Gently ask process to terminate.
-     *  @todo Implement this! */
-    VBOXSERVICECTRLREQUEST_HANGUP           = 91,
-    /** Ask the process in which status it
-     *  currently is.
-     *  @todo Implement this! */
-    VBOXSERVICECTRLREQUEST_STATUS           = 100
-} VBOXSERVICECTRLREQUESTTYPE;
-
-/**
- * Thread list types.
- */
-typedef enum VBOXSERVICECTRLTHREADLISTTYPE
-{
-    /** Unknown list -- uncool to use. */
-    VBOXSERVICECTRLTHREADLIST_UNKNOWN       = 0,
-    /** Stopped list: Here all guest threads end up
-     *  when they reached the stopped state and can
-     *  be shut down / free'd safely. */
-    VBOXSERVICECTRLTHREADLIST_STOPPED       = 1,
-    /**
-     * Started list: Here all threads are registered
-     * when they're up and running (that is, accepting
-     * commands).
-     */
-    VBOXSERVICECTRLTHREADLIST_RUNNING       = 2
-} VBOXSERVICECTRLTHREADLISTTYPE;
-
-/**
- * Structure to perform a request on a started guest
- * process. Needed for letting the main guest control thread
- * to communicate (and wait) for a certain operation which
- * will be done in context of the started guest process thread.
- */
-typedef struct VBOXSERVICECTRLREQUEST
-{
-    /** Event semaphore to serialize access. */
-    RTSEMEVENTMULTI            Event;
-    /** The request type to handle. */
-    VBOXSERVICECTRLREQUESTTYPE enmType;
-    /** Payload size; on input, this contains the (maximum) amount
-     *  of data the caller  wants to write or to read. On output,
-     *  this show the actual amount of data read/written. */
-    size_t                     cbData;
-    /** Payload data; a pre-allocated data buffer for input/output. */
-    void                      *pvData;
-    /** The context ID which is required to complete the
-     *  request. Not used at the moment. */
-    uint32_t                   uCID;
-    /** The overall result of the operation. */
-    int                        rc;
-} VBOXSERVICECTRLREQUEST;
-/** Pointer to request. */
-typedef VBOXSERVICECTRLREQUEST *PVBOXSERVICECTRLREQUEST;
-
-/**
- * Structure holding information for starting a guest
- * process.
- */
-typedef struct VBOXSERVICECTRLPROCESS
-{
-    /** Full qualified path of process to start (without arguments). */
-    char szCmd[GUESTPROCESS_MAX_CMD_LEN];
-    /** Process execution flags. @sa */
-    uint32_t uFlags;
-    /** Command line arguments. */
-    char szArgs[GUESTPROCESS_MAX_ARGS_LEN];
-    /** Number of arguments specified in pszArgs. */
-    uint32_t uNumArgs;
-    /** String of environment variables ("FOO=BAR") to pass to the process
-      * to start. */
-    char szEnv[GUESTPROCESS_MAX_ENV_LEN];
-    /** Size (in bytes) of environment variables block. */
-    uint32_t cbEnv;
-    /** Number of environment variables specified in pszEnv. */
-    uint32_t uNumEnvVars;
-    /** User name (account) to start the process under. */
-    char szUser[GUESTPROCESS_MAX_USER_LEN];
-    /** Password of specified user name (account). */
-    char szPassword[GUESTPROCESS_MAX_PASSWORD_LEN];
-    /** Time limit (in ms) of the process' life time. */
-    uint32_t uTimeLimitMS;
-} VBOXSERVICECTRLPROCESS;
-/** Pointer to a guest process block. */
-typedef VBOXSERVICECTRLPROCESS *PVBOXSERVICECTRLPROCESS;
-
-/**
- * Structure for holding data for one (started) guest process.
- */
-typedef struct VBOXSERVICECTRLTHREAD
-{
-    /** Pointer to list archor of following
-     *  list node.
-     *  @todo Would be nice to have a RTListGetAnchor(). */
-    PRTLISTANCHOR                   pAnchor;
-    /** Node. */
-    RTLISTNODE                      Node;
-    /** The worker thread. */
-    RTTHREAD                        Thread;
-    /** Shutdown indicator; will be set when the thread
-      * needs (or is asked) to shutdown. */
-    bool volatile                   fShutdown;
-    /** Indicator set by the service thread exiting. */
-    bool volatile                   fStopped;
-    /** Whether the service was started or not. */
-    bool                            fStarted;
-    /** Client ID. */
-    uint32_t                        uClientID;
-    /** Context ID. */
-    uint32_t                        uContextID;
-    /** Critical section for thread-safe use. */
-    RTCRITSECT                      CritSect;
-    /** @todo Document me! */
-    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. */
-    PVBOXSERVICECTRLREQUEST         pRequest;
-    /** StdIn pipe for addressing writes to the
-     *  guest process' stdin.*/
-    RTPIPE                          pipeStdInW;
-    /** The notification pipe associated with this guest process.
-     *  This is NIL_RTPIPE for output pipes. */
-    RTPIPE                          hNotificationPipeW;
-    /** The other end of hNotificationPipeW. */
-    RTPIPE                          hNotificationPipeR;
-} VBOXSERVICECTRLTHREAD;
-/** Pointer to thread data. */
-typedef VBOXSERVICECTRLTHREAD *PVBOXSERVICECTRLTHREAD;
-
-/**
- * Structure for one (opened) guest file.
- */
-typedef struct VBOXSERVICECTRLFILE
-{
-    /** Pointer to list archor of following
-     *  list node.
-     *  @todo Would be nice to have a RTListGetAnchor(). */
-    PRTLISTANCHOR                   pAnchor;
-    /** Node. */
-    RTLISTNODE                      Node;
-    /** The file name. */
-    char                            szName[RTPATH_MAX];
-    /** The file handle on the guest. */
-    RTFILE                          hFile;
-    /** File handle to identify this file. */
-    uint32_t                        uHandle;
-    /** Context ID. */
-    uint32_t                        uContextID;
-} VBOXSERVICECTRLFILE;
-/** Pointer to thread data. */
-typedef VBOXSERVICECTRLFILE *PVBOXSERVICECTRLFILE;
-#endif /* VBOX_WITH_GUEST_CONTROL */
 #ifdef VBOX_WITH_GUEST_PROPS
-
 /**
  * A guest property cache.
@@ -359 +153 @@
 extern char        *g_pszProgName;
 extern int          g_cVerbosity;
+extern char         g_szLogFile[RTPATH_MAX + 128];
 extern uint32_t     g_DefaultInterval;
 extern VBOXSERVICE  g_TimeSync;
@@ -406 +201 @@
 #endif /* RT_OS_WINDOWS */
 
-#ifdef VBOX_WITH_GUEST_CONTROL
-/* Guest control main thread functions. */
-extern int                      GstCntlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID);
-extern int                      GstCntlListSet(VBOXSERVICECTRLTHREADLISTTYPE enmList,
-                                                          PVBOXSERVICECTRLTHREAD pThread);
-extern PVBOXSERVICECTRLTHREAD   GstCntlLockThread(uint32_t uPID);
-extern void                     GstCntlUnlockThread(const PVBOXSERVICECTRLTHREAD pThread);
-extern int                      GstCntlSetInactive(PVBOXSERVICECTRLTHREAD pThread);
-/* Per-thread guest process functions. */
-extern int                      GstCntlProcessStart(uint32_t uContext,
-                                                              PVBOXSERVICECTRLPROCESS pProcess);
-extern int                      GstCntlProcessPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest);
-extern int                      GstCntlProcessStop(const PVBOXSERVICECTRLTHREAD pThread);
-extern int                      GstCntlProcessWait(const PVBOXSERVICECTRLTHREAD pThread,
-                                                   RTMSINTERVAL msTimeout, int *prc);
-extern int                      GstCntlProcessFree(PVBOXSERVICECTRLTHREAD pThread);
-/* Request handling. */
-extern int                      GstCntlProcessRequestAlloc(PVBOXSERVICECTRLREQUEST   *ppReq,
-                                                           VBOXSERVICECTRLREQUESTTYPE enmType);
-extern int                      GstCntlProcessRequestAllocEx(PVBOXSERVICECTRLREQUEST    *ppReq,
-                                                             VBOXSERVICECTRLREQUESTTYPE  enmType,
-                                                             void                       *pvData,
-                                                             size_t                      cbData,
-                                                             uint32_t                    uCID);
-extern void                     GstCntlProcessRequestFree(PVBOXSERVICECTRLREQUEST pReq);
-#endif /* VBOX_WITH_GUEST_CONTROL */
-
 #ifdef VBOXSERVICE_MANAGEMENT
 extern uint32_t                 VBoxServiceBalloonQueryPages(uint32_t cbPage);

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

@@ -696 +696 @@
                 char const *papszArgs[3];
                 papszArgs[0] = pszExeName;
-                papszArgs[1] = "--pagefusionfork";
+                papszArgs[1] = "pagefusion";
                 papszArgs[2] = NULL;
                 rc = RTProcCreate(pszExeName, papszArgs, RTENV_DEFAULT, 0 /* normal child */, &hProcess);

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

@@ -1526 +1526 @@
 
     while (   (ch = RTGetOpt(&GetState, &ValueUnion))
-              && RT_SUCCESS(rc))
+           && RT_SUCCESS(rc))
     {
         /* For options that require an argument, ValueUnion has received the value. */