static void test1(void) { RTTestISub("Three threads"); /* * Create the threads and let them block on the event multi semaphore. */ RTSEMEVENTMULTI hSem; RTTESTI_CHECK_RC_RETV(RTSemEventMultiCreate(&hSem), VINF_SUCCESS); RTTHREAD hThread2; RTTESTI_CHECK_RC_RETV(RTThreadCreate(&hThread2, test1Thread2, &hSem, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2"), VINF_SUCCESS); RTThreadSleep(100); RTTHREAD hThread1; RTTESTI_CHECK_RC_RETV(RTThreadCreate(&hThread1, test1Thread1, &hSem, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test1"), VINF_SUCCESS); /* Force first thread (which has a timeout of 1 second) to timeout in the * first wait, and the second wait will succeed. */ RTTESTI_CHECK_RC(RTThreadSleep(1500), VINF_SUCCESS); RTTESTI_CHECK_RC(RTSemEventMultiSignal(hSem), VINF_SUCCESS); RTTESTI_CHECK_RC(RTThreadWait(hThread1, 5000, NULL), VINF_SUCCESS); RTTESTI_CHECK_RC(RTThreadWait(hThread2, 5000, NULL), VINF_SUCCESS); RTTESTI_CHECK_RC(RTSemEventMultiDestroy(hSem), VINF_SUCCESS); }
bool VBoxCredPoller::Initialize(VBoxCredProv *pProvider) { Log(("VBoxCredPoller::Initialize\n")); if (m_pProv != NULL) m_pProv->Release(); m_pProv = pProvider; AssertPtr(m_pProv); m_pProv->AddRef(); /* Don't create more than one of them. */ if (m_hThreadPoller != NIL_RTTHREAD) { Log(("VBoxCredPoller::Initialize: Thread already running, returning!\n")); return false; } int rc = RTCritSectInit(&m_csCredUpate); if (RT_FAILURE(rc)) Log(("VBoxCredPoller: Could not init critical section! rc = %Rrc\n", rc)); /* Create the poller thread. */ rc = RTThreadCreate(&m_hThreadPoller, VBoxCredPoller::threadPoller, this, 0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "creds"); if (RT_FAILURE(rc)) { Log(("VBoxCredPoller::Initialize: Failed to create thread, rc = %Rrc\n", rc)); return false; } return true; }
HRESULT vboxDispMpTstStart() { HRESULT hr = E_FAIL; g_hVBoxDispMpModule = GetModuleHandleW(L"VBoxDispD3D.dll"); Assert(g_hVBoxDispMpModule); if (g_hVBoxDispMpModule) { g_pfnVBoxDispMpGetCallbacks = (PFNVBOXDISPMP_GETCALLBACKS)GetProcAddress(g_hVBoxDispMpModule, "VBoxDispMpGetCallbacks"); Assert(g_pfnVBoxDispMpGetCallbacks); if (g_pfnVBoxDispMpGetCallbacks) { hr = g_pfnVBoxDispMpGetCallbacks(VBOXDISPMP_VERSION, &g_VBoxDispMpTstCallbacks); Assert(hr == S_OK); if (hr == S_OK) { int rc = RTThreadCreate(&g_VBoxDispMpTstThread, vboxDispMpTstThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "VBoxDispMpTst"); AssertRC(rc); if (RT_SUCCESS(rc)) return S_OK; hr = E_FAIL; } } FreeLibrary(g_hVBoxDispMpModule); } return hr; }
/** * Create a new thread. * * Same as RTThreadCreate except the name is given in the RTStrPrintfV form. * * @returns iprt status code. * @param pThread See RTThreadCreate. * @param pfnThread See RTThreadCreate. * @param pvUser See RTThreadCreate. * @param cbStack See RTThreadCreate. * @param enmType See RTThreadCreate. * @param fFlags See RTThreadCreate. * @param pszNameFmt Thread name format. * @param va Format arguments. */ RTDECL(int) RTThreadCreateV(PRTTHREAD pThread, PFNRTTHREAD pfnThread, void *pvUser, size_t cbStack, RTTHREADTYPE enmType, uint32_t fFlags, const char *pszNameFmt, va_list va) { char szName[RTTHREAD_NAME_LEN * 2]; RTStrPrintfV(szName, sizeof(szName), pszNameFmt, va); return RTThreadCreate(pThread, pfnThread, pvUser, cbStack, enmType, fFlags, szName); }
VirtualBox::ClientWatcher::ClientWatcher(const ComObjPtr<VirtualBox> &pVirtualBox) : mVirtualBox(pVirtualBox), mThread(NIL_RTTHREAD), mUpdateReq(CWUPDATEREQARG), mLock(LOCKCLASS_OBJECTSTATE) { #if defined(RT_OS_WINDOWS) mUpdateReq = ::CreateEvent(NULL, FALSE, FALSE, NULL); #elif defined(RT_OS_OS2) RTSemEventCreate(&mUpdateReq); #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER) RTSemEventCreate(&mUpdateReq); /* start with high timeouts, nothing to do */ ASMAtomicUoWriteU8(&mUpdateAdaptCtr, 0); #else # error "Port me!" #endif int vrc = RTThreadCreate(&mThread, worker, (void *)this, 0, RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE, "Watcher"); AssertRC(vrc); }
/** * Waits for credentials to arrive by creating and waiting for a thread. * * @return IPRT status code. * @param hPAM PAM handle. * @param uClientID Guest property service client ID. * @param uTimeoutMS Timeout (in ms) to wait for the change. Specify * RT_INDEFINITE_WAIT to wait indefinitly. */ static int pam_vbox_wait_for_creds(pam_handle_t *hPAM, uint32_t uClientID, uint32_t uTimeoutMS) { RT_NOREF1(uClientID); PAMVBOXTHREAD threadData; threadData.hPAM = hPAM; threadData.uTimeoutMS = uTimeoutMS; RTTHREAD threadWait; int rc = RTThreadCreate(&threadWait, pam_vbox_wait_thread, (void *)&threadData, 0, RTTHREADTYPE_DEFAULT, 0 /* Flags */, "pam_vbox"); if (RT_SUCCESS(rc)) { pam_vbox_log(hPAM, "pam_vbox_wait_for_creds: Waiting for credentials (%dms) ...\n", uTimeoutMS); /* Wait for thread to initialize. */ /** @todo We can do something else here in the meantime later. */ rc = RTThreadUserWait(threadWait, RT_INDEFINITE_WAIT); if (RT_SUCCESS(rc)) rc = threadData.rc; /* Get back thread result to take further actions. */ } else pam_vbox_error(hPAM, "pam_vbox_wait_for_creds: Creating thread failed with rc=%Rrc\n", rc); pam_vbox_log(hPAM, "pam_vbox_wait_for_creds: Waiting for credentials returned with rc=%Rrc\n", rc); return rc; }
/** * Starts the service. * * @returns VBox status. */ int USBProxyService::start(void) { int rc = VINF_SUCCESS; if (mThread == NIL_RTTHREAD) { /* * Force update before starting the poller thread. */ rc = wait(0); if (rc == VERR_TIMEOUT || rc == VERR_INTERRUPTED || RT_SUCCESS(rc)) { processChanges(); /* * Create the poller thread which will look for changes. */ mTerminate = false; rc = RTThreadCreate(&mThread, USBProxyService::serviceThread, this, 0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "USBPROXY"); AssertRC(rc); if (RT_SUCCESS(rc)) LogFlowThisFunc(("started mThread=%RTthrd\n", mThread)); else mThread = NIL_RTTHREAD; } mLastError = rc; } else LogFlowThisFunc(("already running, mThread=%RTthrd\n", mThread)); return rc; }
int VBoxNetBaseService::startReceiveThreadAndEnterEventLoop() { AssertMsgReturn(isMainNeeded(), ("It's expected that we need Main"), VERR_INTERNAL_ERROR); /* start receiving thread */ int rc = RTThreadCreate(&m->m_hThrRecv, /* thread handle*/ &VBoxNetBaseService::Data::recvLoop, /* routine */ this, /* user data */ 128 * _1K, /* stack size */ RTTHREADTYPE_IO, /* type */ RTTHREADFLAGS_WAITABLE, /* flags */ "RECV"); AssertRCReturn(rc, rc); m->m_EventQ = com::NativeEventQueue::getMainEventQueue(); AssertPtrReturn(m->m_EventQ, VERR_INTERNAL_ERROR); while (!m->fShutdown) { rc = m->m_EventQ->processEventQueue(RT_INDEFINITE_WAIT); if (rc == VERR_INTERRUPTED) { LogFlow(("Event queue processing ended with rc=%Rrc\n", rc)); break; } } return VINF_SUCCESS; }
int VBoxCredProvPoller::Initialize(VBoxCredProvProvider *pProvider) { AssertPtrReturn(pProvider, VERR_INVALID_POINTER); VBoxCredProvVerbose(0, "VBoxCredProvPoller: Initializing\n"); /* Don't create more than one of them. */ if (m_hThreadPoller != NIL_RTTHREAD) { VBoxCredProvVerbose(0, "VBoxCredProvPoller: Thread already running, returning\n"); return VINF_SUCCESS; } if (m_pProv != NULL) m_pProv->Release(); m_pProv = pProvider; /* * We must not add a reference via AddRef() here, otherwise * the credential provider does not get destructed properly. * In order to get this thread terminated normally the credential * provider has to call Shutdown(). */ /* Create the poller thread. */ int rc = RTThreadCreate(&m_hThreadPoller, VBoxCredProvPoller::threadPoller, this, 0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "credpoll"); if (RT_FAILURE(rc)) VBoxCredProvVerbose(0, "VBoxCredProvPoller::Initialize: Failed to create thread, rc=%Rrc\n", rc); return rc; }
/** * Entry point. */ extern "C" DECLEXPORT(int) TrustedMain(int argc, char **argv) { /* * Instantiate the DHCP server and hand it the options. */ VBoxNetDhcp *pDhcp = new VBoxNetDhcp(); if (!pDhcp) { RTStrmPrintf(g_pStdErr, "VBoxNetDHCP: new VBoxNetDhcp failed!\n"); return 1; } RTEXITCODE rcExit = (RTEXITCODE)pDhcp->parseArgs(argc - 1, argv + 1); if (rcExit != RTEXITCODE_SUCCESS) return rcExit; #ifdef RT_OS_WINDOWS /* DIFx hack. */ RTTHREAD hMakeUseKillableThread = NIL_RTTHREAD; int rc2 = RTThreadCreate(&hMakeUseKillableThread, DIFxKillableProcessThreadProc, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "DIFxKill"); if (RT_FAILURE(rc2)) hMakeUseKillableThread = NIL_RTTHREAD; #endif pDhcp->init(); /* * Try connect the server to the network. */ int rc = pDhcp->tryGoOnline(); if (RT_SUCCESS(rc)) { /* * Process requests. */ g_pDhcp = pDhcp; rc = pDhcp->run(); pDhcp->done(); g_pDhcp = NULL; } delete pDhcp; #ifdef RT_OS_WINDOWS /* Kill DIFx hack. */ if (hMakeUseKillableThread != NIL_RTTHREAD) { g_fExitProcessOnQuit = false; PostThreadMessage((DWORD)RTThreadGetNative(hMakeUseKillableThread), WM_QUIT, 0, 0); RTThreadWait(hMakeUseKillableThread, RT_MS_1SEC * 5U, NULL); } #endif return RT_SUCCESS(rc) ? RTEXITCODE_SUCCESS : RTEXITCODE_FAILURE; }
static void test1(void) { RTTestSub(g_hTest, "Interrupt RTThreadSleep"); RTTHREAD hThread; RTTESTI_CHECK_RC_RETV(RTThreadCreate(&hThread, test1Thread, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test1"), VINF_SUCCESS); RTThreadSleep(500); RTThreadSleep(1500); /* fudge */ RTTESTI_CHECK_RC(RTThreadPoke(hThread), VINF_SUCCESS); RTTESTI_CHECK_RC(RTThreadWait(hThread, RT_INDEFINITE_WAIT, NULL), VINF_SUCCESS); }
HRESULT HostDnsServiceDarwin::start() { int rc = RTThreadCreate(&g_DnsMonitoringThread, hostMonitoringRoutine, this, 128 * _1K, RTTHREADTYPE_IO, 0, "dns-monitor"); AssertRCReturn(rc, E_FAIL); RTSemEventWait(g_DnsInitEvent, RT_INDEFINITE_WAIT); return S_OK; }
int VFSExplorer::TaskVFSExplorer::startThread() { int vrc = RTThreadCreate(NULL, VFSExplorer::TaskVFSExplorer::taskThread, this, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0, "Explorer::Task"); if (RT_FAILURE(vrc)) return VFSExplorer::setErrorStatic(E_FAIL, Utf8StrFmt("Could not create taskThreadVFS (%Rrc)\n", vrc)); return vrc; }
/** * Creates the XPCOM event thread * * @returns VBOX status code * @param eqFD XPCOM event queue file descriptor */ int startXPCOMEventQueueThread(int eqFD) { int rc = RTSemEventCreate(&g_EventSemXPCOMQueueThread); if (RT_SUCCESS(rc)) { RTTHREAD Thread; rc = RTThreadCreate(&Thread, xpcomEventThread, (void *)(intptr_t)eqFD, 0, RTTHREADTYPE_MSG_PUMP, 0, "XPCOMEvent"); } AssertRC(rc); return rc; }
HostPowerServiceWin::HostPowerServiceWin(VirtualBox *aVirtualBox) : HostPowerService(aVirtualBox), mThread(NIL_RTTHREAD) { mHwnd = 0; int rc = RTThreadCreate(&mThread, HostPowerServiceWin::NotificationThread, this, 65536, RTTHREADTYPE_GUI, RTTHREADFLAGS_WAITABLE, "MainPower"); if (RT_FAILURE(rc)) { Log(("HostPowerServiceWin::HostPowerServiceWin: RTThreadCreate failed with %Rrc\n", rc)); return; } }
static int testSessionWait(RTTEST hTest, const char *pszExecPath) { RTTestSub(hTest, "testSessionWait"); RTLOCALIPCSERVER ipcServer; int rc = RTLocalIpcServerCreate(&ipcServer, "tstRTLocalIpcSessionWait", RTLOCALIPC_FLAGS_MULTI_SESSION); if (RT_SUCCESS(rc)) { LOCALIPCTHREADCTX threadCtx = { ipcServer, hTest }; /* Spawn a simple worker thread and let it listen for incoming connections. * In the meanwhile we try to cancel the server and see what happens. */ RTTHREAD hThread; rc = RTThreadCreate(&hThread, testSessionWaitThread, &threadCtx, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc3"); if (RT_SUCCESS(rc)) { do { RTPROCESS hProc; const char *apszArgs[4] = { pszExecPath, "child", "tstRTLocalIpcSessionWaitFork", NULL }; RTTEST_CHECK_RC_BREAK(hTest, RTProcCreate(pszExecPath, apszArgs, RTENV_DEFAULT, 0 /* fFlags*/, &hProc), VINF_SUCCESS); RTThreadSleep(5000); /* Let the server run for some time ... */ RTTestPrintf(hTest, RTTESTLVL_INFO, "Cancelling server listening\n"); RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS); /* Wait for the server thread to terminate. */ int threadRc; RTTEST_CHECK_RC(hTest, RTThreadWait(hThread, 30 * 1000 /* 30s timeout */, &threadRc), VINF_SUCCESS); RTTEST_CHECK_RC_BREAK(hTest, threadRc, VERR_CANCELLED); RTTEST_CHECK_RC(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS); RTTestPrintf(hTest, RTTESTLVL_INFO, "Server thread terminated successfully\n"); /* Check if the child ran successfully. */ RTPROCSTATUS stsChild; RTTEST_CHECK_RC_BREAK(hTest, RTProcWait(hProc, RTPROCWAIT_FLAGS_BLOCK, &stsChild), VINF_SUCCESS); RTTestPrintf(hTest, RTTESTLVL_INFO, "Child terminated\n"); RTTEST_CHECK_BREAK(hTest, stsChild.enmReason == RTPROCEXITREASON_NORMAL); RTTEST_CHECK_BREAK(hTest, stsChild.iStatus == 0); } while (0); } else RTTestFailed(hTest, "Unable to create thread for cancelling server, rc=%Rrc\n", rc); } else RTTestFailed(hTest, "Unable to create IPC server, rc=%Rrc\n", rc); return VINF_SUCCESS; }
/** * Start the X11 window configuration change monitor thread. */ int SeamlessMain::startX11MonitorThread(void) { int rc; mX11MonitorThreadStopping = false; if (isX11MonitorThreadRunning()) return VINF_SUCCESS; rc = RTThreadCreate(&mX11MonitorThread, x11MonitorThread, this, 0, RTTHREADTYPE_MSG_PUMP, RTTHREADFLAGS_WAITABLE, "X11 events"); if (RT_FAILURE(rc)) LogRelFunc(("Warning: failed to start X11 monitor thread (VBoxClient).\n")); return rc; }
int SessionTaskCopyFrom::RunAsync(const Utf8Str &strDesc, ComObjPtr<Progress> &pProgress) { LogFlowThisFunc(("strDesc=%s, strSource=%s, strDest=%s, uFlags=%x\n", strDesc.c_str(), mSource.c_str(), mDest.c_str(), mFlags)); mDesc = strDesc; mProgress = pProgress; int rc = RTThreadCreate(NULL, SessionTaskCopyFrom::taskThread, this, 0, RTTHREADTYPE_MAIN_HEAVY_WORKER, 0, "gctlCpyFrom"); LogFlowFuncLeaveRC(rc); return rc; }
HostPowerServiceDarwin::HostPowerServiceDarwin(VirtualBox *aVirtualBox) : HostPowerService(aVirtualBox) , mThread(NULL) , mRootPort(MACH_PORT_NULL) , mNotifyPort(nil) , mRunLoop(nil) , mCritical(false) { /* Create the new worker thread. */ int rc = RTThreadCreate(&mThread, HostPowerServiceDarwin::powerChangeNotificationThread, this, 65536, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "MainPower"); if (RT_FAILURE(rc)) LogFlow(("RTThreadCreate failed with %Rrc\n", rc)); }
/* * Public platform dependent functions. */ int vboxClipboardInit (void) { int rc = VINF_SUCCESS; g_ctx.hRenderEvent = CreateEvent(NULL, TRUE, FALSE, NULL); rc = RTThreadCreate (&g_ctx.thread, VBoxClipboardThread, NULL, 65536, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP"); if (RT_FAILURE (rc)) { CloseHandle (g_ctx.hRenderEvent); } return rc; }
int main(int argc, char **argv) { RTR3InitExe(argc, &argv, 0); if (argc == 2 && !strcmp(argv[1], "child")) return 42; RTPrintf("tstRTWait: spawning a child in a separate thread and waits for it in the main thread...\n"); RTTHREAD Thread; SPAWNERARGS Args = { NIL_RTPROCESS, argv[0] }; int rc = RTThreadCreate(&Thread, SpawnerThread, &Args, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "SPAWNER"); if (RT_SUCCESS(rc)) { /* Wait for it to complete. */ int rc2; rc = RTThreadWait(Thread, RT_INDEFINITE_WAIT, &rc2); if (RT_SUCCESS(rc)) rc = rc2; if (RT_SUCCESS(rc)) { /* wait for the process to complete */ RTPROCSTATUS Status; rc = RTProcWait(Args.Process, 0, &Status); if (RT_SUCCESS(rc)) { if ( Status.enmReason == RTPROCEXITREASON_NORMAL && Status.iStatus == 42) RTPrintf("tstRTWait: Success!\n"); else { rc = VERR_GENERAL_FAILURE; if (Status.enmReason != RTPROCEXITREASON_NORMAL) RTPrintf("tstRTWait: Expected exit reason RTPROCEXITREASON_NORMAL, got %d.\n", Status.enmReason); else RTPrintf("tstRTWait: Expected exit status 42, got %d.\n", Status.iStatus); } } else RTPrintf("tstRTWait: RTProcWait failed with rc=%Rrc!\n", rc); } else RTPrintf("tstRTWait: RTThreadWait or SpawnerThread failed with rc=%Rrc!\n", rc); } else RTPrintf("tstRTWait: RTThreadCreate failed with rc=%Rrc!\n", rc); return RT_SUCCESS(rc) ? 0 : 1; }
/** * Initializes the VirtualBoxClient object. * * @returns COM result indicator */ HRESULT VirtualBoxClient::init() { LogFlowThisFunc(("\n")); HRESULT rc; /* Enclose the state transition NotReady->InInit->Ready */ AutoInitSpan autoInitSpan(this); AssertReturn(autoInitSpan.isOk(), E_FAIL); mData.m_ThreadWatcher = NIL_RTTHREAD; mData.m_SemEvWatcher = NIL_RTSEMEVENT; if (ASMAtomicIncU32(&g_cInstances) != 1) AssertFailedReturn(E_FAIL); rc = mData.m_pVirtualBox.createLocalObject(CLSID_VirtualBox); AssertComRCReturnRC(rc); rc = unconst(mData.m_pEventSource).createObject(); AssertComRCReturnRC(rc); rc = mData.m_pEventSource->init(static_cast<IVirtualBoxClient *>(this)); AssertComRCReturnRC(rc); /* Setting up the VBoxSVC watcher thread. If anything goes wrong here it * is not considered important enough to cause any sort of visible * failure. The monitoring will not be done, but that's all. */ int vrc = RTSemEventCreate(&mData.m_SemEvWatcher); AssertRC(vrc); if (RT_SUCCESS(vrc)) { vrc = RTThreadCreate(&mData.m_ThreadWatcher, SVCWatcherThread, this, 0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "VBoxSVCWatcher"); AssertRC(vrc); } else { RTSemEventDestroy(mData.m_SemEvWatcher); mData.m_SemEvWatcher = NIL_RTSEMEVENT; } /* Confirm a successful initialization */ autoInitSpan.setSucceeded(); return rc; }
static void test1(void) { RTTestSub(g_hTest, "Interrupt RTThreadSleep"); RTTHREAD hThread[16]; RTMSINTERVAL msWait = 1000; for (unsigned i = 0; i < RT_ELEMENTS(hThread); i++) { RTTESTI_CHECK_RC_RETV(RTThreadCreate(&hThread[i], testThread, NULL, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test"), VINF_SUCCESS); } RTThreadSleep(500); RTPrintf("Waiting for %dms ...\n", msWait); RTThreadSleep(msWait); for (unsigned i = 0; i < RT_ELEMENTS(hThread); i++) RTTESTI_CHECK_RC(RTThreadWait(hThread[i], RT_INDEFINITE_WAIT, NULL), VINF_SUCCESS); RTPrintf("sum kernel = %lldms, sum user = %lldms\n", g_kernel, g_user); }
VirtualBox::ClientWatcher::ClientWatcher(const ComObjPtr<VirtualBox> &pVirtualBox) : mVirtualBox(pVirtualBox), mThread(NIL_RTTHREAD), mUpdateReq(CWUPDATEREQARG), mLock(LOCKCLASS_OBJECTSTATE) { #if defined(RT_OS_WINDOWS) /* Misc state. */ mfTerminate = false; mcMsWait = INFINITE; mcActiveSubworkers = 0; /* Update request. The UpdateReq event is also used to wake up subthreads. */ mfUpdateReq = false; mUpdateReq = ::CreateEvent(NULL /*pSecAttr*/, TRUE /*fManualReset*/, FALSE /*fInitialState*/, NULL /*pszName*/); AssertRelease(mUpdateReq != NULL); /* Initialize the handle array. */ for (uint32_t i = 0; i < RT_ELEMENTS(mahWaitHandles); i++) mahWaitHandles[i] = NULL; for (uint32_t i = 0; i < RT_ELEMENTS(mahWaitHandles); i += CW_MAX_HANDLES_PER_THREAD) mahWaitHandles[i] = mUpdateReq; mcWaitHandles = 1; #elif defined(RT_OS_OS2) RTSemEventCreate(&mUpdateReq); #elif defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER) RTSemEventCreate(&mUpdateReq); /* start with high timeouts, nothing to do */ ASMAtomicUoWriteU8(&mUpdateAdaptCtr, 0); #else # error "Port me!" #endif int vrc = RTThreadCreate(&mThread, worker, (void *)this, 0, RTTHREADTYPE_MAIN_WORKER, RTTHREADFLAGS_WAITABLE, "Watcher"); AssertRC(vrc); }
/** Initialise the host side of the shared clipboard - called by the hgcm layer. */ int vboxClipboardInit(void) { Log(("vboxClipboardInit\n")); g_ctx.fTerminate = false; int rc = initPasteboard(&g_ctx.pasteboard); AssertRCReturn(rc, rc); rc = RTThreadCreate(&g_ctx.thread, vboxClipboardThread, &g_ctx, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP"); if (RT_FAILURE(rc)) { g_ctx.thread = NIL_RTTHREAD; destroyPasteboard(&g_ctx.pasteboard); } return rc; }
/** * Internal worker for ThreadTask::createThread, * ThreadTask::createThreadWithType. * * @note Always consumes @a this! */ HRESULT ThreadTask::createThreadInternal(RTTHREADTYPE enmType) { LogThisFunc(("Created \"%s\"\n", m_strTaskName.c_str())); mAsync = true; int vrc = RTThreadCreate(NULL, taskHandlerThreadProc, (void *)this, 0, enmType, 0, m_strTaskName.c_str()); if (RT_SUCCESS(vrc)) return S_OK; mAsync = false; delete this; return E_FAIL; }
static void Test2(void) { RTTestSub(g_hTest, "Timeout"); RTSEMRW hSemRW = NIL_RTSEMRW; RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWCreate(&hSemRW), VINF_SUCCESS); /* Lock it for writing and let the thread do the remainder of the test. */ RTTEST_CHECK_RC_RETV(g_hTest, RTSemRWRequestWrite(hSemRW, RT_INDEFINITE_WAIT), VINF_SUCCESS); RTTHREAD hThread; RTTEST_CHECK_RC_RETV(g_hTest, RTThreadCreate(&hThread, Test2Thread, hSemRW, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "test2"), VINF_SUCCESS); RTTEST_CHECK_RC(g_hTest, RTThreadWait(hThread, 15000, NULL), VINF_SUCCESS); RTTEST_CHECK_RC(g_hTest, RTSemRWReleaseWrite(hSemRW), VINF_SUCCESS); RTTEST_CHECK_RC(g_hTest, RTSemRWDestroy(hSemRW), VINF_SUCCESS); }
/* * Public platform dependent functions. */ int vboxClipboardInit (void) { int rc = VINF_SUCCESS; RT_ZERO(g_ctx); /* Check that new Clipboard API is available */ vboxClipboardInitNewAPI(&g_ctx); g_ctx.hRenderEvent = CreateEvent(NULL, TRUE, FALSE, NULL); rc = RTThreadCreate (&g_ctx.thread, VBoxClipboardThread, NULL, 65536, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "SHCLIP"); if (RT_FAILURE (rc)) { CloseHandle (g_ctx.hRenderEvent); } return rc; }
int VBoxGINACredentialsPollerCreate(void) { if (!VBoxGINAHandleCurrentSession()) return VINF_SUCCESS; VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerCreate\n"); /* don't create more than one of them */ if (gThreadPoller != NIL_RTTHREAD) { VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerCreate: thread already running, returning!\n"); return VINF_SUCCESS; } /* create the poller thread */ int rc = RTThreadCreate(&gThreadPoller, credentialsPoller, NULL, 0, RTTHREADTYPE_INFREQUENT_POLLER, RTTHREADFLAGS_WAITABLE, "creds"); if (RT_FAILURE(rc)) VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerCreate: failed to create thread, rc = %Rrc\n", rc); return rc; }
int VDIoBackendMemCreate(PPVDIOBACKENDMEM ppIoBackend) { int rc = VINF_SUCCESS; PVDIOBACKENDMEM pIoBackend = NULL; pIoBackend = (PVDIOBACKENDMEM)RTMemAllocZ(sizeof(VDIOBACKENDMEM)); if (pIoBackend) { rc = RTCircBufCreate(&pIoBackend->pRequestRing, VDMEMIOBACKEND_REQS * sizeof(PVDIOBACKENDREQ)); if (RT_SUCCESS(rc)) { pIoBackend->cReqsRing = VDMEMIOBACKEND_REQS * sizeof(VDIOBACKENDREQ); pIoBackend->fRunning = true; rc = RTSemEventCreate(&pIoBackend->EventSem); if (RT_SUCCESS(rc)) { rc = RTThreadCreate(&pIoBackend->hThreadIo, vdIoBackendMemThread, pIoBackend, 0, RTTHREADTYPE_IO, RTTHREADFLAGS_WAITABLE, "MemIo"); if (RT_SUCCESS(rc)) { *ppIoBackend = pIoBackend; LogFlowFunc(("returns success\n")); return VINF_SUCCESS; } RTSemEventDestroy(pIoBackend->EventSem); } RTCircBufDestroy(pIoBackend->pRequestRing); } RTMemFree(pIoBackend); } else rc = VERR_NO_MEMORY; return rc; }