Changeset 38180 in vbox

Timestamp:

Jul 26, 2011 12:26:34 PM (13 years ago)

Author:

vboxsync

Message:

VBoxService/GuestCtrl: Updated policy handling for controlling the maximum number of served guest processes.

Location:

trunk/src/VBox/Additions/common/VBoxService

Files:

• VBoxServiceControlExec.cpp (modified) (4 diffs)
• VBoxServiceControlExecThread.cpp (modified) (7 diffs)
• VBoxServiceControlExecThread.h (modified) (2 diffs)
• VBoxServiceInternal.h (modified) (1 diff)

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

@@ -521 +521 @@
     if (RT_SUCCESS(rc))
     {
-        VBoxServicePipeBufSetStatus(&pData->stdIn, false /* Disabled */);
-        VBoxServicePipeBufSetStatus(&pData->stdOut, false /* Disabled */);
-        VBoxServicePipeBufSetStatus(&pData->stdErr, false /* Disabled */);
-
-        /* Since the process is not alive anymore, destroy its local
-         * stdin pipe buffer - it's not used anymore and can eat up quite
-         * a bit of memory. */
-        VBoxServicePipeBufDestroy(&pData->stdIn);
+        /* Mark this thread as stopped and do some action required for stopping ... */
+        VBoxServiceControlExecThreadStop(pThread);
 
         uint32_t uStatus = PROC_STS_UNDEFINED;
@@ -1117 +1111 @@
  *
  * @return  IPRT status code.
+ * @param   uClientID                   Client ID for accessing host service.
  * @param   uContextID                  Context ID to associate the process to start with.
  * @param   pszCmd                      Full qualified path of process to start (without arguments).
@@ -1130 +1125 @@
  * @param   uTimeLimitMS                Time limit (in ms) of the process' life time.
  */
-int VBoxServiceControlExecProcess(uint32_t uContextID, const char *pszCmd, uint32_t uFlags,
+int VBoxServiceControlExecProcess(uint32_t uClientID, uint32_t uContextID,
+                                  const char *pszCmd, uint32_t uFlags,
                                   const char *pszArgs, uint32_t uNumArgs,
                                   const char *pszEnv, uint32_t cbEnv, uint32_t uNumEnvVars,
                                   const char *pszUser, const char *pszPassword, uint32_t uTimeLimitMS)
 {
-    int rc = VBoxServiceControlExecThreadsApplyPolicies();
+    bool fAllowed = false;
+    int rc = VBoxServiceControlExecThreadStartAllowed(&fAllowed);
     if (RT_FAILURE(rc))
-        return rc;
-
-    /*
-     * Allocate new thread data and assign it to our thread list.
-     */
-    PVBOXSERVICECTRLTHREAD pThread = (PVBOXSERVICECTRLTHREAD)RTMemAlloc(sizeof(VBOXSERVICECTRLTHREAD));
-    if (pThread)
-    {
-        rc = VBoxServiceControlExecThreadAlloc(pThread,
-                                               uContextID,
-                                               pszCmd, uFlags,
-                                               pszArgs, uNumArgs,
-                                               pszEnv, cbEnv, uNumEnvVars,
-                                               pszUser, pszPassword,
-                                               uTimeLimitMS);
-        if (RT_SUCCESS(rc))
-        {
-            static uint32_t uCtrlExecThread = 0;
-            char szThreadName[32];
-            if (!RTStrPrintf(szThreadName, sizeof(szThreadName), "controlexec%ld", uCtrlExecThread++))
-                AssertMsgFailed(("Unable to create unique control exec thread name!\n"));
-
-            rc = RTThreadCreate(&pThread->Thread, VBoxServiceControlExecThread,
-                                (void *)(PVBOXSERVICECTRLTHREAD*)pThread, 0,
-                                RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, szThreadName);
-            if (RT_FAILURE(rc))
+        VBoxServiceError("ControlExec: Error determining whether process can be started or not, rc=%Rrc\n", rc);
+
+    if (fAllowed)
+    {
+        /*
+         * Allocate new thread data and assign it to our thread list.
+         */
+        PVBOXSERVICECTRLTHREAD pThread = (PVBOXSERVICECTRLTHREAD)RTMemAlloc(sizeof(VBOXSERVICECTRLTHREAD));
+        if (pThread)
+        {
+            rc = VBoxServiceControlExecThreadAlloc(pThread,
+                                                   uContextID,
+                                                   pszCmd, uFlags,
+                                                   pszArgs, uNumArgs,
+                                                   pszEnv, cbEnv, uNumEnvVars,
+                                                   pszUser, pszPassword,
+                                                   uTimeLimitMS);
+            if (RT_SUCCESS(rc))
             {
-                VBoxServiceError("ControlExec: RTThreadCreate failed, rc=%Rrc\n, pThread=%p\n",
-                                 rc, pThread);
-            }
-            else
-            {
-                VBoxServiceVerbose(4, "ControlExec: Waiting for thread to initialize ...\n");
-
-                /* Wait for the thread to initialize. */
-                RTThreadUserWait(pThread->Thread, 60 * 1000 /* 60 seconds max. */);
-                if (pThread->fShutdown)
+                static uint32_t uCtrlExecThread = 0;
+                char szThreadName[32];
+                if (!RTStrPrintf(szThreadName, sizeof(szThreadName), "controlexec%ld", uCtrlExecThread++))
+                    AssertMsgFailed(("Unable to create unique control exec thread name!\n"));
+
+                rc = RTThreadCreate(&pThread->Thread, VBoxServiceControlExecThread,
+                                    (void *)(PVBOXSERVICECTRLTHREAD*)pThread, 0,
+                                    RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, szThreadName);
+                if (RT_FAILURE(rc))
                 {
-                    VBoxServiceError("ControlExec: Thread for process \"%s\" failed to start!\n", pszCmd);
-                    rc = VERR_GENERAL_FAILURE;
+                    VBoxServiceError("ControlExec: RTThreadCreate failed, rc=%Rrc\n, pThread=%p\n",
+                                     rc, pThread);
                 }
                 else
                 {
-                    pThread->fStarted = true;
-                    /*rc =*/ RTListAppend(&g_GuestControlThreads, &pThread->Node);
+                    VBoxServiceVerbose(4, "ControlExec: Waiting for thread to initialize ...\n");
+
+                    /* Wait for the thread to initialize. */
+                    RTThreadUserWait(pThread->Thread, 60 * 1000 /* 60 seconds max. */);
+                    if (pThread->fShutdown)
+                    {
+                        VBoxServiceError("ControlExec: Thread for process \"%s\" failed to start!\n", pszCmd);
+                        rc = VERR_GENERAL_FAILURE;
+                    }
+                    else
+                    {
+                        pThread->fStarted = true;
+                        /*rc =*/ RTListAppend(&g_GuestControlThreads, &pThread->Node);
+                    }
                 }
+
+                if (RT_FAILURE(rc))
+                    VBoxServiceControlExecThreadDataDestroy((PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData);
             }
-
             if (RT_FAILURE(rc))
-                VBoxServiceControlExecThreadDataDestroy((PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData);
-        }
-        if (RT_FAILURE(rc))
-            RTMemFree(pThread);
-    }
-    else
-        rc = VERR_NO_MEMORY;
+                RTMemFree(pThread);
+        }
+        else
+            rc = VERR_NO_MEMORY;
+    }
+    else /* Process start is not allowed due to policy settings. */
+    {
+        VBoxServiceVerbose(3, "ControlExec: Guest process limit is reached!\n");
+
+        /* Tell the host. */
+        rc = VbglR3GuestCtrlExecReportStatus(uClientID, uContextID, 0 /* PID */,
+                                             PROC_STS_ERROR, VERR_MAX_PROCS_REACHED,
+                                             NULL /* pvData */, 0 /* cbData */);
+    }
     return rc;
 }
@@ -1251 +1260 @@
     if (RT_SUCCESS(rc))
     {
-        rc = VBoxServiceControlExecProcess(uContextID, szCmd, uFlags, szArgs, uNumArgs,
+        /** @todo Put the following params into a struct! */
+        rc = VBoxServiceControlExecProcess(u32ClientId, uContextID,
+                                           szCmd, uFlags, szArgs, uNumArgs,
                                            szEnv, cbEnv, uNumEnvVars,
                                            szUser, szPassword, uTimeLimitMS);

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

@@ -20 +20 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/getopt.h>
@@ -161 +162 @@
 
 /**
- * Applies the policies to all guest execution threads.
- *
- * @return  IPRT status code.
- */
-int VBoxServiceControlExecThreadsApplyPolicies(void)
-{
-    int rc = RTCritSectEnter(&g_GuestControlThreadsCritSect);
-    if (RT_SUCCESS(rc))
-    {
-        VBoxServiceVerbose(2, "Control: Applying policies ...\n");
-
-        /*
-         * Check if we're respecting our memory policy by checking
-         * how many guest processes are started and served already.
-         */
-        if (g_GuestControlProcsMaxKept) /* If we allow unlimited processes, take a shortcut. */
-        {
-            uint32_t uNumProcs = 0;
-            PVBOXSERVICECTRLTHREAD pNode;
-            RTListForEach(&g_GuestControlThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
-            {
-                if (pNode->enmType == kVBoxServiceCtrlThreadDataExec)
-                    uNumProcs++;
-            }
-
-            /*
-             * Do we serve more guest processes than we should? Kill the oldest n ones (=beginning
-             * at the list).
-             */
-            uint32_t uProcsToKill = 0;
-            if (uNumProcs > g_GuestControlProcsMaxKept)
-                uProcsToKill = uNumProcs - g_GuestControlProcsMaxKept;
-            if (uProcsToKill)
-            {
-                VBoxServiceVerbose(2, "Control: Maximum guest processes set to %u, running %u, killing %u oldest one(s) ...\n",
-                                   g_GuestControlProcsMaxKept, uNumProcs, uProcsToKill);
-
-                RTListForEach(&g_GuestControlThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
-                {
-                    PVBOXSERVICECTRLTHREAD pNext = RTListNodeGetNext(&pNode->Node, VBOXSERVICECTRLTHREAD, Node);
-
-                    rc = VBoxServiceControlExecThreadShutdown(pNode);
-                    if (RT_FAILURE(rc))
-                    {
-                        VBoxServiceError("Control: Unable to shut down thread due to policy, rc=%Rrc", rc);
-                        /* Keep going. */
-                    }
-
-                    RTListNodeRemove(&pNode->Node);
-                    RTMemFree(pNode);
-                    pNode = pNext;
-
-                    /* Did we fullfill our rate? Then stop killing innocent guest processes. */
-                    if (--uProcsToKill == 0)
-                        break;
-                }
-            }
-        }
-
-        int rc2 = RTCritSectLeave(&g_GuestControlThreadsCritSect);
-        if (RT_SUCCESS(rc))
-            rc = rc2;
-    }
-
-    return rc;
-}
-
-
-/**
  * Assigns a valid PID to a guest control thread and also checks if there already was
  * another (stale) guest process which was using that PID before and destroys it.
@@ -327 +259 @@
     RTListForEach(&g_GuestControlThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
     {
-        if (   pNode->fStarted
-            && pNode->enmType == kVBoxServiceCtrlThreadDataExec)
+        if (pNode->enmType == kVBoxServiceCtrlThreadDataExec)
         {
             PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pNode->pvData;
@@ -429 +360 @@
                     break;
             }
-            if (!pPipeBuf)
-                return VERR_INVALID_PARAMETER;
+            AssertPtr(pPipeBuf);
 
 #ifdef DEBUG_andy
@@ -475 +405 @@
 }
 
+
 int VBoxServiceControlExecThreadShutdown(const PVBOXSERVICECTRLTHREAD pThread)
 {
@@ -482 +413 @@
     {
         PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
-        if (!pData)
+        if (!pData) /* Already destroyed execution data. */
             return VINF_SUCCESS;
-        VBoxServiceVerbose(2, "Control: [PID %u]: Will not be served anymore\n",
+        if (pThread->fStarted)
+        {
+            VBoxServiceVerbose(2, "ControlExec: [PID %u]: Shutting down a still running thread without stopping is not possible!\n",
+                               pData->uPID);
+            return VERR_INVALID_PARAMETER;
+        }
+
+        VBoxServiceVerbose(2, "ControlExec: [PID %u]: Shutting down, will not be served anymore\n",
                            pData->uPID);
         VBoxServiceControlExecThreadDataDestroy(pData);
@@ -492 +430 @@
     return VBoxServiceControlThreadWaitForShutdown(pThread);
 }
+
+
+int VBoxServiceControlExecThreadStartAllowed(bool *pbAllowed)
+{
+    int rc = RTCritSectEnter(&g_GuestControlThreadsCritSect);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Check if we're respecting our memory policy by checking
+         * how many guest processes are started and served already.
+         */
+        bool fLimitReached = false;
+        if (g_GuestControlProcsMaxKept) /* If we allow unlimited processes, take a shortcut. */
+        {
+            /** @todo Put running/stopped (+ memory alloc) stats into global struct! */
+            uint32_t uProcsRunning = 0;
+            uint32_t uProcsStopped = 0;
+            PVBOXSERVICECTRLTHREAD pNode;
+            RTListForEach(&g_GuestControlThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
+            {
+                if (pNode->enmType == kVBoxServiceCtrlThreadDataExec)
+                {
+                    Assert(pNode->fStarted != pNode->fStopped);
+                    if (pNode->fStarted)
+                        uProcsRunning++;
+                    else if (pNode->fStopped)
+                        uProcsStopped++;
+                    else
+                        AssertMsgFailed(("Process neither started nor stopped!?\n"));
+                }
+            }
+
+            VBoxServiceVerbose(2, "ControlExec: Maximum served guest processes set to %u, running=%u, stopped=%u\n",
+                               g_GuestControlProcsMaxKept, uProcsRunning, uProcsStopped);
+
+            int32_t iProcsLeft = (g_GuestControlProcsMaxKept - uProcsRunning - 1);
+            if (iProcsLeft < 0)
+            {
+                VBoxServiceVerbose(3, "ControlExec: Maximum running guest processes reached\n");
+                fLimitReached = true;
+            }
+            else if (uProcsStopped > iProcsLeft)
+            {
+                uint32_t uProcsToKill = uProcsStopped - iProcsLeft;
+                Assert(uProcsToKill);
+                VBoxServiceVerbose(3, "ControlExec: Shutting down %ld stopped guest processes\n", uProcsToKill);
+
+                RTListForEach(&g_GuestControlThreads, pNode, VBOXSERVICECTRLTHREAD, Node)
+                {
+                    if (   pNode->enmType == kVBoxServiceCtrlThreadDataExec
+                        && pNode->fStopped)
+                    {
+                        PVBOXSERVICECTRLTHREAD pNext = RTListNodeGetNext(&pNode->Node, VBOXSERVICECTRLTHREAD, Node);
+
+                        int rc2 = VBoxServiceControlExecThreadShutdown(pNode);
+                        if (RT_FAILURE(rc2))
+                        {
+                            VBoxServiceError("ControlExec: Unable to shut down thread due to policy, rc=%Rrc", rc2);
+                            if (RT_SUCCESS(rc))
+                                rc = rc2;
+                            /* Keep going. */
+                        }
+
+                        RTListNodeRemove(&pNode->Node);
+                        RTMemFree(pNode);
+                        pNode = pNext;
+
+                        uProcsToKill--;
+                        if (!uProcsToKill)
+                            break;
+
+                    }
+                }
+                Assert(uProcsToKill == 0);
+            }
+        }
+
+        *pbAllowed = !fLimitReached;
+
+        int rc2 = RTCritSectLeave(&g_GuestControlThreadsCritSect);
+        if (RT_SUCCESS(rc))
+            rc = rc2;
+    }
+
+    return rc;
+}
+
+
+/**
+ * Marks an guest execution thread as stopped and cleans up its internal pipe buffers.
+ *
+ * @param   pThread                 Pointer to guest execution thread.
+ */
+void VBoxServiceControlExecThreadStop(const PVBOXSERVICECTRLTHREAD pThread)
+{
+    AssertPtr(pThread);
+
+    int rc = RTCritSectEnter(&g_GuestControlThreadsCritSect);
+    if (RT_SUCCESS(rc))
+    {
+        if (pThread->fStarted)
+        {
+            const PVBOXSERVICECTRLTHREADDATAEXEC pData = (PVBOXSERVICECTRLTHREADDATAEXEC)pThread->pvData;
+            if (pData)
+            {
+                VBoxServiceVerbose(3, "ControlExec: [PID %u]: Marking as stopped\n", pData->uPID);
+
+                VBoxServicePipeBufSetStatus(&pData->stdIn, false /* Disabled */);
+                VBoxServicePipeBufSetStatus(&pData->stdOut, false /* Disabled */);
+                VBoxServicePipeBufSetStatus(&pData->stdErr, false /* Disabled */);
+
+                /* Since the process is not alive anymore, destroy its local
+                 * stdin pipe buffer - it's not used anymore and can eat up quite
+                 * a bit of memory. */
+                VBoxServicePipeBufDestroy(&pData->stdIn);
+            }
+
+            /* Mark as stopped. */
+            ASMAtomicXchgBool(&pThread->fStarted, false);
+            ASMAtomicXchgBool(&pThread->fStopped, true);
+        }
+
+        RTCritSectLeave(&g_GuestControlThreadsCritSect);
+    }
+}
+

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

@@ -27 +27 @@
                                       const char *pszEnv, uint32_t cbEnv, uint32_t uNumEnvVars,
                                       const char *pszUser, const char *pszPassword, uint32_t uTimeLimitMS);
-int VBoxServiceControlExecThreadsApplyPolicies();
 int VBoxServiceControlExecThreadAssignPID(PVBOXSERVICECTRLTHREADDATAEXEC pData, uint32_t uPID);
 void VBoxServiceControlExecThreadDataDestroy(PVBOXSERVICECTRLTHREADDATAEXEC pData);
@@ -34 +33 @@
 int VBoxServiceControlExecThreadSetInput(uint32_t uPID, bool fPendingClose, uint8_t *pBuf,
                                          uint32_t cbSize, uint32_t *pcbWritten);
+int VBoxServiceControlExecThreadStartAllowed(bool *pbAllowed);
+void VBoxServiceControlExecThreadStop(const PVBOXSERVICECTRLTHREAD pThread);
 #endif  /* !___VBoxServiceControlExecThread_h */
 

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

@@ -311 +311 @@
 extern int          VBoxServiceControlExecHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, size_t cbMaxBufSize);
 extern int          VBoxServiceControlExecHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);
-extern int          VBoxServiceControlExecProcess(uint32_t uContext, const char *pszCmd, uint32_t uFlags,
+extern int          VBoxServiceControlExecProcess(uint32_t uClientID, uint32_t uContext,
+                                                  const char *pszCmd, uint32_t uFlags,
                                                   const char *pszArgs, uint32_t uNumArgs,
                                                   const char *pszEnv, uint32_t cbEnv, uint32_t uNumEnvVars,