- Timestamp:
- Jan 8, 2013 10:10:22 AM (12 years ago)
- svn:sync-xref-src-repo-rev:
- 83108
- Location:
- trunk/src/VBox/Additions/common/VBoxService
- Files:
-
- 3 edited
-
VBoxServiceControl.cpp (modified) (30 diffs)
-
VBoxServiceControlThread.cpp (modified) (59 diffs)
-
VBoxServiceInternal.h (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControl.cpp
r44045 r44248 5 5 6 6 /* 7 * Copyright (C) 2012 Oracle Corporation7 * Copyright (C) 2012-2013 Oracle Corporation 8 8 * 9 9 * This file is part of VirtualBox Open Source Edition (OSE), as … … 70 70 *******************************************************************************/ 71 71 /** @todo Shorten "VBoxServiceControl" to "gstsvcCntl". */ 72 static int VBoxServiceControlReapThreads(void);73 static int VBoxServiceControlStartAllowed(bool *pbAllowed);74 static int VBoxServiceControlHandleCmdStartProc(uint32_t u32ClientId, uint32_t uNumParms);75 static int VBoxServiceControlHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, void *pvScratchBuf, size_t cbScratchBuf);76 static int VBoxServiceControlHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms);77 static int VBoxServiceControlHandleFileOpen(uint32_t idClient, uint32_t cParms);78 static int VBoxServiceControlHandleFileClose(uint32_t idClient, uint32_t cParms);79 static int VBoxServiceControlHandleFileRead(uint32_t idClient, uint32_t cParms);80 static int VBoxServiceControlHandleFileWrite(uint32_t idClient, uint32_t cParms, void *pvScratchBuf, size_t cbScratchBuf);81 static int VBoxServiceControlHandleFileSeek(uint32_t idClient, uint32_t cParms);82 static int VBoxServiceControlHandleFileTell(uint32_t idClient, uint32_t cParms);72 static int gstcntlReapThreads(void); 73 static int gstcntlStartAllowed(bool *pbAllowed); 74 static int gstcntlHandleCmdStartProc(uint32_t u32ClientId, uint32_t uNumParms); 75 static int gstcntlHandleCmdSetInput(uint32_t u32ClientId, uint32_t uNumParms, void *pvScratchBuf, size_t cbScratchBuf); 76 static int gstcntlHandleCmdGetOutput(uint32_t u32ClientId, uint32_t uNumParms); 77 static int gstcntlHandleFileOpen(uint32_t idClient, uint32_t cParms); 78 static int gstcntlHandleFileClose(uint32_t idClient, uint32_t cParms); 79 static int gstcntlHandleFileRead(uint32_t idClient, uint32_t cParms); 80 static int gstcntlHandleFileWrite(uint32_t idClient, uint32_t cParms, void *pvScratchBuf, size_t cbScratchBuf); 81 static int gstcntlHandleFileSeek(uint32_t idClient, uint32_t cParms); 82 static int gstcntlHandleFileTell(uint32_t idClient, uint32_t cParms); 83 83 84 84 #ifdef DEBUG 85 static int vboxServiceControlDump(const char *pszFileName, void *pvBuf, size_t cbBuf)85 static int gstcntlDumpToFile(const char *pszFileName, void *pvBuf, size_t cbBuf) 86 86 { 87 87 AssertPtrReturn(pszFileName, VERR_INVALID_POINTER); … … 273 273 274 274 case HOST_EXEC_CMD: 275 rc = VBoxServiceControlHandleCmdStartProc(g_uControlSvcClientID, cParms);275 rc = gstcntlHandleCmdStartProc(g_uControlSvcClientID, cParms); 276 276 break; 277 277 278 278 case HOST_EXEC_SET_INPUT: 279 rc = VBoxServiceControlHandleCmdSetInput(g_uControlSvcClientID, cParms,279 rc = gstcntlHandleCmdSetInput(g_uControlSvcClientID, cParms, 280 280 pvScratchBuf, cbScratchBuf); 281 281 break; 282 282 283 283 case HOST_EXEC_GET_OUTPUT: 284 rc = VBoxServiceControlHandleCmdGetOutput(g_uControlSvcClientID, cParms);284 rc = gstcntlHandleCmdGetOutput(g_uControlSvcClientID, cParms); 285 285 break; 286 286 287 287 case HOST_FILE_OPEN: 288 rc = VBoxServiceControlHandleFileOpen(g_uControlSvcClientID, cParms);288 rc = gstcntlHandleFileOpen(g_uControlSvcClientID, cParms); 289 289 break; 290 290 291 291 case HOST_FILE_CLOSE: 292 rc = VBoxServiceControlHandleFileClose(g_uControlSvcClientID, cParms);292 rc = gstcntlHandleFileClose(g_uControlSvcClientID, cParms); 293 293 break; 294 294 295 295 case HOST_FILE_READ: 296 rc = VBoxServiceControlHandleFileRead(g_uControlSvcClientID, cParms);296 rc = gstcntlHandleFileRead(g_uControlSvcClientID, cParms); 297 297 break; 298 298 299 299 case HOST_FILE_WRITE: 300 rc = VBoxServiceControlHandleFileWrite(g_uControlSvcClientID, cParms,300 rc = gstcntlHandleFileWrite(g_uControlSvcClientID, cParms, 301 301 pvScratchBuf, cbScratchBuf); 302 302 break; 303 303 304 304 case HOST_FILE_SEEK: 305 rc = VBoxServiceControlHandleFileSeek(g_uControlSvcClientID, cParms);305 rc = gstcntlHandleFileSeek(g_uControlSvcClientID, cParms); 306 306 break; 307 307 308 308 case HOST_FILE_TELL: 309 rc = VBoxServiceControlHandleFileTell(g_uControlSvcClientID, cParms);309 rc = gstcntlHandleFileTell(g_uControlSvcClientID, cParms); 310 310 break; 311 311 … … 344 344 * @param cParms The number of parameters the host is offering. 345 345 */ 346 static int VBoxServiceControlHandleCmdStartProc(uint32_t uClientID, uint32_t cParms)346 static int gstcntlHandleCmdStartProc(uint32_t uClientID, uint32_t cParms) 347 347 { 348 348 uint32_t uContextID = 0; … … 390 390 proc.uTimeLimitMS); 391 391 392 rc = VBoxServiceControlReapThreads();392 rc = gstcntlReapThreads(); 393 393 if (RT_FAILURE(rc)) 394 394 VBoxServiceError("Reaping stopped processes failed with rc=%Rrc\n", rc); 395 395 /* Keep going. */ 396 396 397 rc = VBoxServiceControlStartAllowed(&fStartAllowed);397 rc = gstcntlStartAllowed(&fStartAllowed); 398 398 if (RT_SUCCESS(rc)) 399 399 { 400 400 if (fStartAllowed) 401 401 { 402 rc = VBoxServiceControlThreadStart(uContextID, &proc);402 rc = GstCntlProcessStart(uContextID, &proc); 403 403 } 404 404 else … … 475 475 { 476 476 PVBOXSERVICECTRLREQUEST pRequest; 477 rc = VBoxServiceControlThreadRequestAllocEx(&pRequest, reqType, pvBuf, cbBuf, uCID);478 if (RT_SUCCESS(rc)) 479 { 480 rc = VBoxServiceControlThreadPerform(uPID, pRequest);477 rc = GstCntlProcessRequestAllocEx(&pRequest, reqType, pvBuf, cbBuf, uCID); 478 if (RT_SUCCESS(rc)) 479 { 480 rc = GstCntlProcessPerform(uPID, pRequest); 481 481 if (RT_SUCCESS(rc) && pcbRead) 482 482 *pcbRead = pRequest->cbData; 483 VBoxServiceControlThreadRequestFree(pRequest);483 GstCntlProcessRequestFree(pRequest); 484 484 } 485 485 } … … 496 496 * @param pThread Thread to set inactive. 497 497 */ 498 int VBoxServiceControlListSet(VBOXSERVICECTRLTHREADLISTTYPE enmList,499 498 int GstCntlListSet(VBOXSERVICECTRLTHREADLISTTYPE enmList, 499 PVBOXSERVICECTRLTHREAD pThread) 500 500 { 501 501 AssertReturn(enmList > VBOXSERVICECTRLTHREADLIST_UNKNOWN, VERR_INVALID_PARAMETER); … … 570 570 571 571 PVBOXSERVICECTRLREQUEST pRequest; 572 int rc = VBoxServiceControlThreadRequestAllocEx(&pRequest,573 574 575 576 577 if (RT_SUCCESS(rc)) 578 { 579 rc = VBoxServiceControlThreadPerform(uPID, pRequest);572 int rc = GstCntlProcessRequestAllocEx(&pRequest, 573 fPendingClose 574 ? VBOXSERVICECTRLREQUEST_STDIN_WRITE_EOF 575 : VBOXSERVICECTRLREQUEST_STDIN_WRITE, 576 pvBuf, cbBuf, uCID); 577 if (RT_SUCCESS(rc)) 578 { 579 rc = GstCntlProcessPerform(uPID, pRequest); 580 580 if (RT_SUCCESS(rc)) 581 581 { … … 584 584 } 585 585 586 VBoxServiceControlThreadRequestFree(pRequest);586 GstCntlProcessRequestFree(pRequest); 587 587 } 588 588 … … 602 602 * @param cbScratchBuf The scratch buffer size for retrieving the input data. 603 603 */ 604 static int VBoxServiceControlHandleCmdSetInput(uint32_t idClient, uint32_t cParms,605 604 static int gstcntlHandleCmdSetInput(uint32_t idClient, uint32_t cParms, 605 void *pvScratchBuf, size_t cbScratchBuf) 606 606 { 607 607 AssertPtrReturn(cbScratchBuf, VERR_INVALID_PARAMETER); … … 692 692 693 693 694 static PVBOXSERVICECTRLFILE VBoxControlGetFile(uint32_t uHandle)694 static PVBOXSERVICECTRLFILE gstcntlGetFile(uint32_t uHandle) 695 695 { 696 696 PVBOXSERVICECTRLFILE pFileCur = NULL; … … 706 706 707 707 708 static int VBoxServiceControlHandleFileOpen(uint32_t idClient, uint32_t cParms)708 static int gstcntlHandleFileOpen(uint32_t idClient, uint32_t cParms) 709 709 { 710 710 uint32_t uContextID; … … 780 780 781 781 782 static int VBoxServiceControlHandleFileClose(uint32_t idClient, uint32_t cParms)782 static int gstcntlHandleFileClose(uint32_t idClient, uint32_t cParms) 783 783 { 784 784 uint32_t uContextID; … … 790 790 if (RT_SUCCESS(rc)) 791 791 { 792 PVBOXSERVICECTRLFILE pFile = VBoxControlGetFile(uHandle);792 PVBOXSERVICECTRLFILE pFile = gstcntlGetFile(uHandle); 793 793 if (pFile) 794 794 { … … 810 810 811 811 812 static int VBoxServiceControlHandleFileRead(uint32_t idClient, uint32_t cParms)812 static int gstcntlHandleFileRead(uint32_t idClient, uint32_t cParms) 813 813 { 814 814 uint32_t uContextID; … … 826 826 827 827 828 static int VBoxServiceControlHandleFileWrite(uint32_t idClient, uint32_t cParms,828 static int gstcntlHandleFileWrite(uint32_t idClient, uint32_t cParms, 829 829 void *pvScratchBuf, size_t cbScratchBuf) 830 830 { … … 847 847 848 848 849 static int VBoxServiceControlHandleFileSeek(uint32_t idClient, uint32_t cParms)849 static int gstcntlHandleFileSeek(uint32_t idClient, uint32_t cParms) 850 850 { 851 851 uint32_t uContextID; … … 864 864 865 865 866 static int VBoxServiceControlHandleFileTell(uint32_t idClient, uint32_t cParms)866 static int gstcntlHandleFileTell(uint32_t idClient, uint32_t cParms) 867 867 { 868 868 uint32_t uContextID; … … 886 886 * @param cParms The number of parameters the host is offering. 887 887 */ 888 static int VBoxServiceControlHandleCmdGetOutput(uint32_t idClient, uint32_t cParms)888 static int gstcntlHandleCmdGetOutput(uint32_t idClient, uint32_t cParms) 889 889 { 890 890 uint32_t uContextID; … … 914 914 rc = VERR_BUFFER_UNDERFLOW; 915 915 if (RT_SUCCESS(rc)) 916 rc = vboxServiceControlDump(szPID, pBuf, cbRead);916 rc = gstcntlDumpToFile(szPID, pBuf, cbRead); 917 917 } 918 918 else if ( g_fControlDumpStdOut … … 924 924 rc = VERR_BUFFER_UNDERFLOW; 925 925 if (RT_SUCCESS(rc)) 926 rc = vboxServiceControlDump(szPID, pBuf, cbRead);926 rc = gstcntlDumpToFile(szPID, pBuf, cbRead); 927 927 AssertRC(rc); 928 928 } … … 985 985 * @return IPRT status code. 986 986 */ 987 static int VBoxServiceControlReapThreads(void)987 static int gstcntlReapThreads(void) 988 988 { 989 989 int rc = RTCritSectEnter(&g_csControlThreads); … … 996 996 PVBOXSERVICECTRLTHREAD pNext = RTListNodeGetNext(&pThread->Node, VBOXSERVICECTRLTHREAD, Node); 997 997 bool fLast = RTListNodeIsLast(&g_lstControlThreadsInactive, &pThread->Node); 998 int rc2 = VBoxServiceControlThreadWait(pThread, 30 * 1000 /* 30 seconds max. */,999 998 int rc2 = GstCntlProcessWait(pThread, 30 * 1000 /* 30 seconds max. */, 999 NULL /* rc */); 1000 1000 if (RT_SUCCESS(rc2)) 1001 1001 { 1002 1002 RTListNodeRemove(&pThread->Node); 1003 1003 1004 rc2 = VBoxServiceControlThreadFree(pThread);1004 rc2 = GstCntlProcessFree(pThread); 1005 1005 if (RT_FAILURE(rc2)) 1006 1006 { … … 1040 1040 PVBOXSERVICECTRLTHREAD pThread; 1041 1041 RTListForEach(&g_lstControlThreadsActive, pThread, VBOXSERVICECTRLTHREAD, Node) 1042 VBoxServiceControlThreadStop(pThread);1042 GstCntlProcessStop(pThread); 1043 1043 1044 1044 /* Wait for all active threads to shutdown and destroy the active thread list. */ … … 1049 1049 bool fLast = RTListNodeIsLast(&g_lstControlThreadsActive, &pThread->Node); 1050 1050 1051 int rc2 = VBoxServiceControlThreadWait(pThread,1052 1053 1051 int rc2 = GstCntlProcessWait(pThread, 1052 30 * 1000 /* Wait 30 seconds max. */, 1053 NULL /* rc */); 1054 1054 if (RT_FAILURE(rc2)) 1055 1055 VBoxServiceError("Guest process thread failed to stop; rc=%Rrc\n", rc2); … … 1061 1061 } 1062 1062 1063 int rc2 = VBoxServiceControlReapThreads();1063 int rc2 = gstcntlReapThreads(); 1064 1064 if (RT_FAILURE(rc2)) 1065 1065 VBoxServiceError("Reaping inactive threads failed with rc=%Rrc\n", rc2); … … 1132 1132 * is allowed, false if not. 1133 1133 */ 1134 static int VBoxServiceControlStartAllowed(bool *pbAllowed)1134 static int gstcntlStartAllowed(bool *pbAllowed) 1135 1135 { 1136 1136 AssertPtrReturn(pbAllowed, VERR_INVALID_POINTER); … … 1181 1181 * @param uPID PID to search for. 1182 1182 */ 1183 PVBOXSERVICECTRLTHREAD VBoxServiceControlLockThread(uint32_t uPID)1183 PVBOXSERVICECTRLTHREAD GstCntlLockThread(uint32_t uPID) 1184 1184 { 1185 1185 PVBOXSERVICECTRLTHREAD pThread = NULL; … … 1213 1213 * @param pThread Thread to unlock. 1214 1214 */ 1215 void VBoxServiceControlUnlockThread(const PVBOXSERVICECTRLTHREAD pThread)1215 void GstCntlUnlockThread(const PVBOXSERVICECTRLTHREAD pThread) 1216 1216 { 1217 1217 AssertPtr(pThread); … … 1230 1230 * @param uPID PID to assign to the specified guest control execution thread. 1231 1231 */ 1232 int VBoxServiceControlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID)1232 int GstCntlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID) 1233 1233 { 1234 1234 AssertPtrReturn(pThread, VERR_INVALID_POINTER); -
trunk/src/VBox/Additions/common/VBoxService/VBoxServiceControlThread.cpp
r44046 r44248 5 5 6 6 /* 7 * Copyright (C) 2012 Oracle Corporation7 * Copyright (C) 2012-2013 Oracle Corporation 8 8 * 9 9 * This file is part of VirtualBox Open Source Edition (OSE), as … … 43 43 44 44 /* Internal functions. */ 45 static int vboxServiceControlThreadRequestCancel(PVBOXSERVICECTRLREQUEST pThread);45 static int gstcntlProcessRequestCancel(PVBOXSERVICECTRLREQUEST pThread); 46 46 47 47 /** … … 53 53 @ @param pProcess Process information. 54 54 */ 55 static int gst svcCntlExecThreadInit(PVBOXSERVICECTRLTHREAD pThread,56 57 55 static int gstcntlProcessInit(PVBOXSERVICECTRLTHREAD pThread, 56 PVBOXSERVICECTRLPROCESS pProcess, 57 uint32_t u32ContextID) 58 58 { 59 59 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 137 137 138 138 if (RT_FAILURE(rc)) /* Clean up on failure. */ 139 VBoxServiceControlThreadFree(pThread);139 GstCntlProcessFree(pThread); 140 140 return rc; 141 141 } … … 148 148 * @param pThread Thread to shut down. 149 149 */ 150 int VBoxServiceControlThreadFree(PVBOXSERVICECTRLTHREAD pThread)150 int GstCntlProcessFree(PVBOXSERVICECTRLTHREAD pThread) 151 151 { 152 152 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 200 200 * @param pThread Thread to shut down. 201 201 */ 202 int VBoxServiceControlThreadStop(const PVBOXSERVICECTRLTHREAD pThread)202 int GstCntlProcessStop(const PVBOXSERVICECTRLTHREAD pThread) 203 203 { 204 204 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 207 207 pThread->uPID); 208 208 209 int rc = vboxServiceControlThreadRequestCancel(pThread->pRequest);209 int rc = gstcntlProcessRequestCancel(pThread->pRequest); 210 210 if (RT_FAILURE(rc)) 211 211 VBoxServiceError("[PID %u]: Signalling request event failed, rc=%Rrc\n", … … 216 216 217 217 PVBOXSERVICECTRLREQUEST pRequest; 218 rc = VBoxServiceControlThreadRequestAlloc(&pRequest, VBOXSERVICECTRLREQUEST_QUIT);218 rc = GstCntlProcessRequestAlloc(&pRequest, VBOXSERVICECTRLREQUEST_QUIT); 219 219 if (RT_SUCCESS(rc)) 220 220 { 221 rc = VBoxServiceControlThreadPerform(pThread->uPID, pRequest);221 rc = GstCntlProcessPerform(pThread->uPID, pRequest); 222 222 if (RT_FAILURE(rc)) 223 223 VBoxServiceVerbose(3, "[PID %u]: Sending quit request failed with rc=%Rrc\n", 224 224 pThread->uPID, rc); 225 225 226 VBoxServiceControlThreadRequestFree(pRequest);226 GstCntlProcessRequestFree(pRequest); 227 227 } 228 228 return rc; … … 238 238 * @param prc Where to store the thread's return code. Optional. 239 239 */ 240 int VBoxServiceControlThreadWait(const PVBOXSERVICECTRLTHREAD pThread,241 240 int GstCntlProcessWait(const PVBOXSERVICECTRLTHREAD pThread, 241 RTMSINTERVAL msTimeout, int *prc) 242 242 { 243 243 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 278 278 * @param phStdInW The standard input pipe handle. 279 279 */ 280 static int VBoxServiceControlThreadCloseStdIn(RTPOLLSET hPollSet, PRTPIPE phStdInW)280 static int gstcntlProcessCloseStdIn(RTPOLLSET hPollSet, PRTPIPE phStdInW) 281 281 { 282 282 AssertPtrReturn(phStdInW, VERR_INVALID_POINTER); … … 305 305 * @param phStdInW The standard input pipe handle. 306 306 */ 307 static int VBoxServiceControlThreadHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW)307 static int gstcntlProcessHandleStdInErrorEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, PRTPIPE phStdInW) 308 308 { 309 309 NOREF(fPollEvt); 310 310 311 return VBoxServiceControlThreadCloseStdIn(hPollSet, phStdInW);311 return gstcntlProcessCloseStdIn(hPollSet, phStdInW); 312 312 } 313 313 … … 323 323 * 324 324 */ 325 static int VBoxServiceControlThreadHandleOutputError(RTPOLLSET hPollSet, uint32_t fPollEvt,326 325 static int gstcntlProcessHandleOutputError(RTPOLLSET hPollSet, uint32_t fPollEvt, 326 PRTPIPE phPipeR, uint32_t idPollHnd) 327 327 { 328 328 AssertPtrReturn(phPipeR, VERR_INVALID_POINTER); 329 329 330 330 #ifdef DEBUG 331 VBoxServiceVerbose(4, " VBoxServiceControlThreadHandleOutputError: fPollEvt=0x%x, idPollHnd=%u\n",331 VBoxServiceVerbose(4, "gstcntlProcessHandleOutputError: fPollEvt=0x%x, idPollHnd=%u\n", 332 332 fPollEvt, idPollHnd); 333 333 #endif … … 345 345 && cbReadable) 346 346 { 347 VBoxServiceVerbose(3, " VBoxServiceControlThreadHandleOutputError: idPollHnd=%u has %ld bytes left, vetoing close\n",347 VBoxServiceVerbose(3, "gstcntlProcessHandleOutputError: idPollHnd=%u has %ld bytes left, vetoing close\n", 348 348 idPollHnd, cbReadable); 349 349 … … 354 354 } 355 355 else 356 VBoxServiceVerbose(3, " VBoxServiceControlThreadHandleOutputError: idPollHnd=%u will be closed\n",356 VBoxServiceVerbose(3, "gstcntlProcessHandleOutputError: idPollHnd=%u will be closed\n", 357 357 idPollHnd); 358 358 … … 379 379 * 380 380 */ 381 static int VBoxServiceControlThreadHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt,382 381 static int gstcntlProcessHandleOutputEvent(RTPOLLSET hPollSet, uint32_t fPollEvt, 382 PRTPIPE phPipeR, uint32_t idPollHnd) 383 383 { 384 384 #if 0 385 VBoxServiceVerbose(4, " VBoxServiceControlThreadHandleOutputEvent: fPollEvt=0x%x, idPollHnd=%u\n",385 VBoxServiceVerbose(4, "GstCntlProcessHandleOutputEvent: fPollEvt=0x%x, idPollHnd=%u\n", 386 386 fPollEvt, idPollHnd); 387 387 #endif … … 395 395 && cbReadable) 396 396 { 397 VBoxServiceVerbose(4, " VBoxServiceControlThreadHandleOutputEvent: cbReadable=%ld\n",397 VBoxServiceVerbose(4, "gstcntlProcessHandleOutputEvent: cbReadable=%ld\n", 398 398 cbReadable); 399 399 } … … 407 407 rc = RTPipeRead(*phPipeR, 408 408 byData, sizeof(byData), &cbRead); 409 VBoxServiceVerbose(4, " VBoxServiceControlThreadHandleOutputEvent cbRead=%u, rc=%Rrc\n",409 VBoxServiceVerbose(4, "GstCntlProcessHandleOutputEvent cbRead=%u, rc=%Rrc\n", 410 410 cbRead, rc); 411 411 … … 417 417 418 418 if (fPollEvt & RTPOLL_EVT_ERROR) 419 rc = VBoxServiceControlThreadHandleOutputError(hPollSet, fPollEvt,420 419 rc = gstcntlProcessHandleOutputError(hPollSet, fPollEvt, 420 phPipeR, idPollHnd); 421 421 return rc; 422 422 } 423 423 424 424 425 static int VBoxServiceControlThreadHandleRequest(RTPOLLSET hPollSet, uint32_t fPollEvt,426 427 425 static int gstcntlProcessHandleRequest(RTPOLLSET hPollSet, uint32_t fPollEvt, 426 PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR, 427 PVBOXSERVICECTRLTHREAD pThread) 428 428 { 429 429 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 483 483 && pRequest->cbData == cbWritten) 484 484 { 485 rc = VBoxServiceControlThreadCloseStdIn(hPollSet, phStdInW);485 rc = gstcntlProcessCloseStdIn(hPollSet, phStdInW); 486 486 } 487 487 … … 562 562 * @param hStdErrR Handle to the process' stderr read end. 563 563 */ 564 static int VBoxServiceControlThreadProcLoop(PVBOXSERVICECTRLTHREAD pThread,565 566 564 static int gstcntlProcessProcLoop(PVBOXSERVICECTRLTHREAD pThread, 565 RTPROCESS hProcess, RTMSINTERVAL cMsTimeout, RTPOLLSET hPollSet, 566 PRTPIPE phStdInW, PRTPIPE phStdOutR, PRTPIPE phStdErrR) 567 567 { 568 568 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 587 587 * the first (stale) entry will be found and we get really weird results! 588 588 */ 589 rc = VBoxServiceControlAssignPID(pThread, hProcess);589 rc = GstCntlAssignPID(pThread, hProcess); 590 590 if (RT_FAILURE(rc)) 591 591 { … … 629 629 { 630 630 case VBOXSERVICECTRLPIPEID_STDIN: 631 rc = VBoxServiceControlThreadHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW);631 rc = gstcntlProcessHandleStdInErrorEvent(hPollSet, fPollEvt, phStdInW); 632 632 break; 633 633 634 634 case VBOXSERVICECTRLPIPEID_STDOUT: 635 rc = VBoxServiceControlThreadHandleOutputEvent(hPollSet, fPollEvt,636 635 rc = gstcntlProcessHandleOutputEvent(hPollSet, fPollEvt, 636 phStdOutR, idPollHnd); 637 637 break; 638 639 638 case VBOXSERVICECTRLPIPEID_STDERR: 640 rc = VBoxServiceControlThreadHandleOutputEvent(hPollSet, fPollEvt,641 639 rc = gstcntlProcessHandleOutputEvent(hPollSet, fPollEvt, 640 phStdErrR, idPollHnd); 642 641 break; 643 642 644 643 case VBOXSERVICECTRLPIPEID_IPC_NOTIFY: 645 rc = VBoxServiceControlThreadHandleRequest(hPollSet, fPollEvt,646 644 rc = gstcntlProcessHandleRequest(hPollSet, fPollEvt, 645 phStdInW, phStdOutR, phStdErrR, pThread); 647 646 break; 648 647 … … 892 891 * @param phPipe The pipe's object to initialize. 893 892 */ 894 static int vboxServiceControlThreadInitPipe(PRTHANDLE ph, PRTPIPE phPipe)893 static int gstcntlProcessInitPipe(PRTHANDLE ph, PRTPIPE phPipe) 895 894 { 896 895 AssertPtrReturn(ph, VERR_INVALID_PARAMETER); … … 910 909 * @return IPRT status code. 911 910 * @param ppReq Pointer that will receive the newly allocated request. 912 * Must be freed later with VBoxServiceControlThreadRequestFree().911 * Must be freed later with GstCntlProcessRequestFree(). 913 912 * @param enmType Request type. 914 913 * @param pvData Payload data, based on request type. … … 916 915 * @param uCID Context ID to which this request belongs to. 917 916 */ 918 int VBoxServiceControlThreadRequestAllocEx(PVBOXSERVICECTRLREQUEST *ppReq,919 920 921 922 917 int GstCntlProcessRequestAllocEx(PVBOXSERVICECTRLREQUEST *ppReq, 918 VBOXSERVICECTRLREQUESTTYPE enmType, 919 void *pvData, 920 size_t cbData, 921 uint32_t uCID) 923 922 { 924 923 AssertPtrReturn(ppReq, VERR_INVALID_POINTER); … … 956 955 * @return IPRT status code. 957 956 * @param ppReq Pointer that will receive the newly allocated request. 958 * Must be freed later with VBoxServiceControlThreadRequestFree().957 * Must be freed later with GstCntlProcessRequestFree(). 959 958 * @param enmType Request type. 960 959 */ 961 int VBoxServiceControlThreadRequestAlloc(PVBOXSERVICECTRLREQUEST *ppReq,962 963 { 964 return VBoxServiceControlThreadRequestAllocEx(ppReq, enmType,965 966 960 int GstCntlProcessRequestAlloc(PVBOXSERVICECTRLREQUEST *ppReq, 961 VBOXSERVICECTRLREQUESTTYPE enmType) 962 { 963 return GstCntlProcessRequestAllocEx(ppReq, enmType, 964 NULL /* pvData */, 0 /* cbData */, 965 0 /* ContextID */); 967 966 } 968 967 … … 971 970 * Cancels a previously fired off guest thread request. 972 971 * 973 * Note: Does *not* do locking since VBoxServiceControlThreadRequestWait()972 * Note: Does *not* do locking since GstCntlProcessRequestWait() 974 973 * holds the lock (critsect); so only trigger the signal; the owner 975 974 * needs to clean up afterwards. … … 978 977 * @param pReq Request to cancel. 979 978 */ 980 static int vboxServiceControlThreadRequestCancel(PVBOXSERVICECTRLREQUEST pReq)979 static int gstcntlProcessRequestCancel(PVBOXSERVICECTRLREQUEST pReq) 981 980 { 982 981 if (!pReq) /* Silently skip non-initialized requests. */ … … 995 994 * @param pReq Request to free. 996 995 */ 997 void VBoxServiceControlThreadRequestFree(PVBOXSERVICECTRLREQUEST pReq)996 void GstCntlProcessRequestFree(PVBOXSERVICECTRLREQUEST pReq) 998 997 { 999 998 AssertPtrReturnVoid(pReq); … … 1016 1015 * @param pReq Request to wait for. 1017 1016 */ 1018 int VBoxServiceControlThreadRequestWait(PVBOXSERVICECTRLREQUEST pReq)1017 int GstCntlProcessRequestWait(PVBOXSERVICECTRLREQUEST pReq) 1019 1018 { 1020 1019 AssertPtrReturn(pReq, VERR_INVALID_POINTER); … … 1051 1050 * should service. 1052 1051 */ 1053 static int VBoxServiceControlThreadSetupPipe(const char *pszHowTo, int fd,1054 1052 static int gstcntlProcessSetupPipe(const char *pszHowTo, int fd, 1053 PRTHANDLE ph, PRTHANDLE *pph, PRTPIPE phPipe) 1055 1054 { 1056 1055 AssertPtrReturn(ph, VERR_INVALID_POINTER); … … 1120 1119 * @param cbExpanded Size (in bytes) of string to store the resolved path. 1121 1120 */ 1122 static int VBoxServiceControlThreadMakeFullPath(const char *pszPath, char *pszExpanded, size_t cbExpanded)1121 static int gstcntlProcessMakeFullPath(const char *pszPath, char *pszExpanded, size_t cbExpanded) 1123 1122 { 1124 1123 int rc = VINF_SUCCESS; … … 1148 1147 * @param cbResolved Size (in bytes) of resolved file name string. 1149 1148 */ 1150 static int VBoxServiceControlThreadResolveExecutable(const char *pszFileName,1151 1149 static int gstcntlProcessResolveExecutable(const char *pszFileName, 1150 char *pszResolved, size_t cbResolved) 1152 1151 { 1153 1152 AssertPtrReturn(pszFileName, VERR_INVALID_POINTER); … … 1173 1172 if (RT_SUCCESS(rc)) 1174 1173 { 1175 rc = VBoxServiceControlThreadMakeFullPath(szPathToResolve, pszResolved, cbResolved);1174 rc = gstcntlProcessMakeFullPath(szPathToResolve, pszResolved, cbResolved); 1176 1175 if (RT_SUCCESS(rc)) 1177 1176 VBoxServiceVerbose(3, "Looked up executable: %s -> %s\n", … … 1196 1195 * Needs to be freed with RTGetOptArgvFree. 1197 1196 */ 1198 static int VBoxServiceControlThreadAllocateArgv(const char *pszArgv0,1199 1200 1197 static int gstcntlProcessAllocateArgv(const char *pszArgv0, 1198 const char * const *papszArgs, 1199 bool fExpandArgs, char ***ppapszArgv) 1201 1200 { 1202 1201 AssertPtrReturn(ppapszArgv, VERR_INVALID_POINTER); 1203 1202 1204 VBoxServiceVerbose(3, " VBoxServiceControlThreadPrepareArgv: pszArgv0=%p, papszArgs=%p, fExpandArgs=%RTbool, ppapszArgv=%p\n",1203 VBoxServiceVerbose(3, "GstCntlProcessPrepareArgv: pszArgv0=%p, papszArgs=%p, fExpandArgs=%RTbool, ppapszArgv=%p\n", 1205 1204 pszArgv0, papszArgs, fExpandArgs, ppapszArgv); 1206 1205 … … 1220 1219 1221 1220 #ifdef DEBUG 1222 VBoxServiceVerbose(3, " VBoxServiceControlThreadPrepareArgv: cbSize=%RU32, cArgs=%RU32\n",1221 VBoxServiceVerbose(3, "GstCntlProcessAllocateArgv: cbSize=%RU32, cArgs=%RU32\n", 1223 1222 cbSize, cArgs); 1224 1223 #endif … … 1278 1277 1279 1278 1280 void VBoxServiceControlThreadFreeArgv(char **papszArgv)1279 void gstcntlProcessFreeArgv(char **papszArgv) 1281 1280 { 1282 1281 if (papszArgv) … … 1306 1305 * successful process start. 1307 1306 */ 1308 static int VBoxServiceControlThreadCreateProcess(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags,1309 1310 1307 static int gstcntlProcessCreateProcess(const char *pszExec, const char * const *papszArgs, RTENV hEnv, uint32_t fFlags, 1308 PCRTHANDLE phStdIn, PCRTHANDLE phStdOut, PCRTHANDLE phStdErr, const char *pszAsUser, 1309 const char *pszPassword, PRTPROCESS phProcess) 1311 1310 { 1312 1311 AssertPtrReturn(pszExec, VERR_INVALID_PARAMETER); … … 1350 1349 { 1351 1350 char **papszArgsExp; 1352 rc = VBoxServiceControlThreadAllocateArgv(szSysprepCmd /* argv0 */, papszArgs,1353 1351 rc = gstcntlProcessAllocateArgv(szSysprepCmd /* argv0 */, papszArgs, 1352 fExpandArgs, &papszArgsExp); 1354 1353 if (RT_SUCCESS(rc)) 1355 1354 { … … 1357 1356 phStdIn, phStdOut, phStdErr, NULL /* pszAsUser */, 1358 1357 NULL /* pszPassword */, phProcess); 1359 VBoxServiceControlThreadFreeArgv(papszArgsExp);1358 gstcntlProcessFreeArgv(papszArgsExp); 1360 1359 } 1361 1360 } … … 1373 1372 /* We want to use the internal toolbox (all internal 1374 1373 * tools are starting with "vbox_" (e.g. "vbox_cat"). */ 1375 rc = VBoxServiceControlThreadResolveExecutable(VBOXSERVICE_NAME, szExecExp, sizeof(szExecExp));1374 rc = gstcntlProcessResolveExecutable(VBOXSERVICE_NAME, szExecExp, sizeof(szExecExp)); 1376 1375 } 1377 1376 else … … 1381 1380 * Do the environment variables expansion on executable and arguments. 1382 1381 */ 1383 rc = VBoxServiceControlThreadResolveExecutable(pszExec, szExecExp, sizeof(szExecExp));1382 rc = gstcntlProcessResolveExecutable(pszExec, szExecExp, sizeof(szExecExp)); 1384 1383 #ifdef VBOXSERVICE_TOOLBOX 1385 1384 } … … 1388 1387 { 1389 1388 char **papszArgsExp; 1390 rc = VBoxServiceControlThreadAllocateArgv(pszExec /* Always use the unmodified executable name as argv0. */,1391 1392 1389 rc = gstcntlProcessAllocateArgv(pszExec /* Always use the unmodified executable name as argv0. */, 1390 papszArgs /* Append the rest of the argument vector (if any). */, 1391 fExpandArgs, &papszArgsExp); 1393 1392 if (RT_FAILURE(rc)) 1394 1393 { … … 1432 1431 szExecExp, rc); 1433 1432 1434 VBoxServiceControlThreadFreeArgv(papszArgsExp);1433 gstcntlProcessFreeArgv(papszArgsExp); 1435 1434 } 1436 1435 } … … 1444 1443 * @param PVBOXSERVICECTRLTHREAD Thread data associated with a started process. 1445 1444 */ 1446 static int VBoxServiceControlThreadProcessWorker(PVBOXSERVICECTRLTHREAD pThread)1445 static int gstcntlProcessProcessWorker(PVBOXSERVICECTRLTHREAD pThread) 1447 1446 { 1448 1447 AssertPtrReturn(pThread, VERR_INVALID_POINTER); … … 1450 1449 pThread, pThread->pszCmd); 1451 1450 1452 int rc = VBoxServiceControlListSet(VBOXSERVICECTRLTHREADLIST_RUNNING, pThread);1451 int rc = GstCntlListSet(VBOXSERVICECTRLTHREADLIST_RUNNING, pThread); 1453 1452 AssertRC(rc); 1454 1453 … … 1487 1486 RTHANDLE hStdIn; 1488 1487 PRTHANDLE phStdIn; 1489 rc = VBoxServiceControlThreadSetupPipe("|", 0 /*STDIN_FILENO*/,1490 1488 rc = gstcntlProcessSetupPipe("|", 0 /*STDIN_FILENO*/, 1489 &hStdIn, &phStdIn, &pThread->pipeStdInW); 1491 1490 if (RT_SUCCESS(rc)) 1492 1491 { … … 1494 1493 PRTHANDLE phStdOut; 1495 1494 RTPIPE pipeStdOutR; 1496 rc = VBoxServiceControlThreadSetupPipe( (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT)1497 1498 1499 1495 rc = gstcntlProcessSetupPipe( (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDOUT) 1496 ? "|" : "/dev/null", 1497 1 /*STDOUT_FILENO*/, 1498 &hStdOut, &phStdOut, &pipeStdOutR); 1500 1499 if (RT_SUCCESS(rc)) 1501 1500 { … … 1503 1502 PRTHANDLE phStdErr; 1504 1503 RTPIPE pipeStdErrR; 1505 rc = VBoxServiceControlThreadSetupPipe( (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR)1506 1507 1508 1504 rc = gstcntlProcessSetupPipe( (pThread->uFlags & EXECUTEPROCESSFLAG_WAIT_STDERR) 1505 ? "|" : "/dev/null", 1506 2 /*STDERR_FILENO*/, 1507 &hStdErr, &phStdErr, &pipeStdErrR); 1509 1508 if (RT_SUCCESS(rc)) 1510 1509 { … … 1540 1539 { 1541 1540 RTPROCESS hProcess; 1542 rc = VBoxServiceControlThreadCreateProcess(pThread->pszCmd, pThread->papszArgs, hEnv, pThread->uFlags,1543 1544 1545 1541 rc = gstcntlProcessCreateProcess(pThread->pszCmd, pThread->papszArgs, hEnv, pThread->uFlags, 1542 phStdIn, phStdOut, phStdErr, 1543 pThread->pszUser, pThread->pszPassword, 1544 &hProcess); 1546 1545 if (RT_FAILURE(rc)) 1547 1546 VBoxServiceError("Error starting process, rc=%Rrc\n", rc); … … 1570 1569 1571 1570 /* Enter the process loop. */ 1572 rc = VBoxServiceControlThreadProcLoop(pThread,1573 1574 1571 rc = gstcntlProcessProcLoop(pThread, 1572 hProcess, pThread->uTimeLimitMS, hPollSet, 1573 &pThread->pipeStdInW, &pipeStdOutR, &pipeStdErrR); 1575 1574 1576 1575 /* … … 1621 1620 1622 1621 /* Move thread to stopped thread list. */ 1623 int rc2 = VBoxServiceControlListSet(VBOXSERVICECTRLTHREADLIST_STOPPED, pThread);1622 int rc2 = GstCntlListSet(VBOXSERVICECTRLTHREADLIST_STOPPED, pThread); 1624 1623 AssertRC(rc2); 1625 1624 … … 1680 1679 * 1681 1680 */ 1682 static DECLCALLBACK(int) VBoxServiceControlThread(RTTHREAD ThreadSelf, void *pvUser)1681 static DECLCALLBACK(int) gstcntlProcessThread(RTTHREAD ThreadSelf, void *pvUser) 1683 1682 { 1684 1683 PVBOXSERVICECTRLTHREAD pThread = (VBOXSERVICECTRLTHREAD*)pvUser; 1685 1684 AssertPtrReturn(pThread, VERR_INVALID_POINTER); 1686 return VBoxServiceControlThreadProcessWorker(pThread);1685 return gstcntlProcessProcessWorker(pThread); 1687 1686 } 1688 1687 … … 1696 1695 * @param pProcess Process info. 1697 1696 */ 1698 int VBoxServiceControlThreadStart(uint32_t uContextID,1699 1697 int GstCntlProcessStart(uint32_t uContextID, 1698 PVBOXSERVICECTRLPROCESS pProcess) 1700 1699 { 1701 1700 AssertPtrReturn(pProcess, VERR_INVALID_POINTER); … … 1708 1707 return VERR_NO_MEMORY; 1709 1708 1710 int rc = gst svcCntlExecThreadInit(pThread, pProcess, uContextID);1709 int rc = gstcntlProcessInit(pThread, pProcess, uContextID); 1711 1710 if (RT_SUCCESS(rc)) 1712 1711 { … … 1714 1713 if (s_uCtrlExecThread++ == UINT32_MAX) 1715 1714 s_uCtrlExecThread = 0; /* Wrap around to not let IPRT freak out. */ 1716 rc = RTThreadCreateF(&pThread->Thread, VBoxServiceControlThread,1715 rc = RTThreadCreateF(&pThread->Thread, gstcntlProcessThread, 1717 1716 pThread /*pvUser*/, 0 /*cbStack*/, 1718 1717 RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "gctl%u", s_uCtrlExecThread); … … 1757 1756 * @param pRequest Pointer to request to perform. 1758 1757 */ 1759 int VBoxServiceControlThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest)1758 int GstCntlProcessPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest) 1760 1759 { 1761 1760 AssertPtrReturn(pRequest, VERR_INVALID_POINTER); … … 1764 1763 1765 1764 int rc = VINF_SUCCESS; 1766 PVBOXSERVICECTRLTHREAD pThread = VBoxServiceControlLockThread(uPID);1765 PVBOXSERVICECTRLTHREAD pThread = GstCntlLockThread(uPID); 1767 1766 if (pThread) 1768 1767 { … … 1791 1790 uPID, pRequest->enmType, pRequest->pvData, pRequest->cbData); 1792 1791 1793 rc = VBoxServiceControlThreadRequestWait(pRequest);1792 rc = GstCntlProcessRequestWait(pRequest); 1794 1793 } 1795 1794 } 1796 1795 1797 VBoxServiceControlUnlockThread(pThread);1796 GstCntlUnlockThread(pThread); 1798 1797 } 1799 1798 else /* PID not found! */ -
trunk/src/VBox/Additions/common/VBoxService/VBoxServiceInternal.h
r44046 r44248 408 408 #ifdef VBOX_WITH_GUEST_CONTROL 409 409 /* Guest control main thread functions. */ 410 extern int VBoxServiceControlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID);411 extern int VBoxServiceControlListSet(VBOXSERVICECTRLTHREADLISTTYPE enmList,410 extern int GstCntlAssignPID(PVBOXSERVICECTRLTHREAD pThread, uint32_t uPID); 411 extern int GstCntlListSet(VBOXSERVICECTRLTHREADLISTTYPE enmList, 412 412 PVBOXSERVICECTRLTHREAD pThread); 413 extern PVBOXSERVICECTRLTHREAD VBoxServiceControlLockThread(uint32_t uPID);414 extern void VBoxServiceControlUnlockThread(const PVBOXSERVICECTRLTHREAD pThread);415 extern int VBoxServiceControlSetInactive(PVBOXSERVICECTRLTHREAD pThread);413 extern PVBOXSERVICECTRLTHREAD GstCntlLockThread(uint32_t uPID); 414 extern void GstCntlUnlockThread(const PVBOXSERVICECTRLTHREAD pThread); 415 extern int GstCntlSetInactive(PVBOXSERVICECTRLTHREAD pThread); 416 416 /* Per-thread guest process functions. */ 417 extern int VBoxServiceControlThreadStart(uint32_t uContext,417 extern int GstCntlProcessStart(uint32_t uContext, 418 418 PVBOXSERVICECTRLPROCESS pProcess); 419 extern int VBoxServiceControlThreadPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest);420 extern int VBoxServiceControlThreadStop(const PVBOXSERVICECTRLTHREAD pThread);421 extern int VBoxServiceControlThreadWait(const PVBOXSERVICECTRLTHREAD pThread,422 423 extern int VBoxServiceControlThreadFree(PVBOXSERVICECTRLTHREAD pThread);419 extern int GstCntlProcessPerform(uint32_t uPID, PVBOXSERVICECTRLREQUEST pRequest); 420 extern int GstCntlProcessStop(const PVBOXSERVICECTRLTHREAD pThread); 421 extern int GstCntlProcessWait(const PVBOXSERVICECTRLTHREAD pThread, 422 RTMSINTERVAL msTimeout, int *prc); 423 extern int GstCntlProcessFree(PVBOXSERVICECTRLTHREAD pThread); 424 424 /* Request handling. */ 425 extern int VBoxServiceControlThreadRequestAlloc(PVBOXSERVICECTRLREQUEST *ppReq,426 427 extern int VBoxServiceControlThreadRequestAllocEx(PVBOXSERVICECTRLREQUEST *ppReq,428 429 430 431 432 extern void VBoxServiceControlThreadRequestFree(PVBOXSERVICECTRLREQUEST pReq);425 extern int GstCntlProcessRequestAlloc(PVBOXSERVICECTRLREQUEST *ppReq, 426 VBOXSERVICECTRLREQUESTTYPE enmType); 427 extern int GstCntlProcessRequestAllocEx(PVBOXSERVICECTRLREQUEST *ppReq, 428 VBOXSERVICECTRLREQUESTTYPE enmType, 429 void *pvData, 430 size_t cbData, 431 uint32_t uCID); 432 extern void GstCntlProcessRequestFree(PVBOXSERVICECTRLREQUEST pReq); 433 433 #endif /* VBOX_WITH_GUEST_CONTROL */ 434 434
Note:
See TracChangeset
for help on using the changeset viewer.
