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;
}
