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);
}
/**
* Wait on the threads to complete.
*
* @returns Thread status (if collected), otherwise VINF_SUCCESS.
* @param cMillies The period to wait on each thread.
*/
static int txsTcpConnectWaitOnThreads(RTMSINTERVAL cMillies)
{
int rcRet = VINF_SUCCESS;
if (g_hThreadTcpConnect != NIL_RTTHREAD)
{
int rcThread;
int rc2 = RTThreadWait(g_hThreadTcpConnect, cMillies, &rcThread);
if (RT_SUCCESS(rc2))
{
g_hThreadTcpConnect = NIL_RTTHREAD;
rcRet = rcThread;
}
}
if (g_hThreadTcpServer != NIL_RTTHREAD)
{
int rcThread;
int rc2 = RTThreadWait(g_hThreadTcpServer, cMillies, &rcThread);
if (RT_SUCCESS(rc2))
{
g_hThreadTcpServer = NIL_RTTHREAD;
if (RT_SUCCESS(rc2))
rcRet = rcThread;
}
}
return rcRet;
}
void VBoxNetBaseService::shutdown(void)
{
syncEnter();
if (!m->fShutdown)
{
m->fShutdown = true;
if (m->m_hThrRecv != NIL_RTTHREAD)
{
int rc = abortWait();
AssertRC(rc == VINF_SUCCESS || rc == VERR_SEM_DESTROYED);
rc = m->m_EventQ->interruptEventQueueProcessing();
if (RT_SUCCESS(rc))
{
rc = RTThreadWait(m->m_hThrRecv, 60000, NULL);
if (RT_FAILURE(rc))
Log1WarningFunc(("RTThreadWait(%RTthrd) -> %Rrc\n", m->m_hThrRecv, rc));
}
else
{
AssertMsgFailed(("interruptEventQueueProcessing() failed\n"));
RTThreadWait(m->m_hThrRecv , 0, NULL);
}
}
}
syncLeave();
}
/**
* Does a multi-threading list test. Several list additions, reading, replacing
* and erasing are done simultaneous.
*
*/
static void test2()
{
RTTestISubF("MT test with 6 threads (%u tests per thread).", MTTESTITEMS);
int rc;
MTTESTLISTTYPE<MTTESTTYPE> testList;
RTTHREAD ahThreads[6];
static PFNRTTHREAD apfnThreads[6] =
{
MtTest1ThreadProc, MtTest2ThreadProc, MtTest3ThreadProc, MtTest4ThreadProc, MtTest5ThreadProc, MtTest6ThreadProc
};
for (unsigned i = 0; i < RT_ELEMENTS(ahThreads); i++)
{
RTTESTI_CHECK_RC_RETV(RTThreadCreateF(&ahThreads[i], apfnThreads[i], &testList, 0,
RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest%u", i), VINF_SUCCESS);
}
uint64_t tsMsDeadline = RTTimeMilliTS() + 60000;
for (unsigned i = 0; i < RT_ELEMENTS(ahThreads); i++)
{
uint64_t tsNow = RTTimeMilliTS();
uint32_t cWait = tsNow > tsMsDeadline ? 5000 : tsMsDeadline - tsNow;
RTTESTI_CHECK_RC(RTThreadWait(ahThreads[i], tsNow, NULL), VINF_SUCCESS);
}
RTTESTI_CHECK_RETV(testList.size() == MTTESTITEMS * 2);
for (size_t i = 0; i < testList.size(); ++i)
{
uint32_t a = testList.at(i);
RTTESTI_CHECK(a == 0x0 || a == 0xFFFFFFFF || a == 0xF0F0F0F0 || a == 0xFF00FF00);
}
}
VirtualBox::ClientWatcher::~ClientWatcher()
{
if (mThread != NIL_RTTHREAD)
{
/* signal the client watcher thread, should be exiting now */
update();
/* wait for termination */
RTThreadWait(mThread, RT_INDEFINITE_WAIT, NULL);
mThread = NIL_RTTHREAD;
}
mProcesses.clear();
#if defined(RT_OS_WINDOWS)
if (mUpdateReq != NULL)
{
::CloseHandle(mUpdateReq);
mUpdateReq = NULL;
}
#elif defined(RT_OS_OS2) || defined(VBOX_WITH_SYS_V_IPC_SESSION_WATCHER) || defined(VBOX_WITH_GENERIC_SESSION_WATCHER)
if (mUpdateReq != NIL_RTSEMEVENT)
{
RTSemEventDestroy(mUpdateReq);
mUpdateReq = NIL_RTSEMEVENT;
}
#else
# error "Port me!"
#endif
}
/**
* Shutdowns all the watchers.
*/
void VirtualBoxSDS::i_shutdownAllWatchers(void)
{
LogRel(("i_shutdownAllWatchers: %u watchers\n", m_cWatchers));
/* Notify them all. */
uint32_t i = m_cWatchers;
while (i-- > 0)
{
ASMAtomicWriteBool(&m_papWatchers[i]->fShutdown, true);
SetEvent(m_papWatchers[i]->aHandles[0]);
}
/* Wait for them to complete and destroy their data. */
i = m_cWatchers;
m_cWatchers = 0;
while (i-- > 0)
{
VBoxSDSWatcher *pWatcher = m_papWatchers[i];
if (pWatcher)
{
m_papWatchers[i] = NULL;
int rc = RTThreadWait(pWatcher->hThread, RT_MS_1MIN / 2, NULL);
if (RT_SUCCESS(rc))
pWatcher->hThread = NIL_RTTHREAD;
else
LogRel(("i_shutdownAllWatchers: RTThreadWait failed on #%u: %Rrc\n", i, rc));
if (ASMAtomicDecU32(&pWatcher->cRefs) == 0)
RTMemFree(pWatcher);
}
}
}
int
VBoxCredProvPoller::Shutdown(void)
{
VBoxCredProvVerbose(0, "VBoxCredProvPoller: Shutdown\n");
if (m_hThreadPoller == NIL_RTTHREAD)
return VINF_SUCCESS;
/* Post termination event semaphore. */
int rc = RTThreadUserSignal(m_hThreadPoller);
if (RT_SUCCESS(rc))
{
VBoxCredProvVerbose(0, "VBoxCredProvPoller: Waiting for thread to terminate\n");
/* Wait until the thread has terminated. */
rc = RTThreadWait(m_hThreadPoller, RT_INDEFINITE_WAIT, NULL);
if (RT_FAILURE(rc))
VBoxCredProvVerbose(0, "VBoxCredProvPoller: Wait returned error rc=%Rrc\n", rc);
}
else
VBoxCredProvVerbose(0, "VBoxCredProvPoller: Error waiting for thread shutdown, rc=%Rrc\n", rc);
m_pProv = NULL;
m_hThreadPoller = NIL_RTTHREAD;
VBoxCredProvVerbose(0, "VBoxCredProvPoller: Shutdown returned with rc=%Rrc\n", rc);
return rc;
}
/**
* Stops the service.
*
* @returns VBox status.
*/
int USBProxyService::stop(void)
{
int rc = VINF_SUCCESS;
if (mThread != NIL_RTTHREAD)
{
/*
* Mark the thread for termination and kick it.
*/
ASMAtomicXchgSize(&mTerminate, true);
rc = interruptWait();
AssertRC(rc);
/*
* Wait for the thread to finish and then update the state.
*/
rc = RTThreadWait(mThread, 60000, NULL);
if (rc == VERR_INVALID_HANDLE)
rc = VINF_SUCCESS;
if (RT_SUCCESS(rc))
{
LogFlowThisFunc(("stopped mThread=%RTthrd\n", mThread));
mThread = NIL_RTTHREAD;
mTerminate = false;
}
else
{
AssertRC(rc);
mLastError = rc;
}
}
else
LogFlowThisFunc(("not active\n"));
return rc;
}
/**
* Uninitializes the instance and sets the ready flag to FALSE.
* Called either from FinalRelease() or by the parent when it gets destroyed.
*/
void VirtualBoxClient::uninit()
{
LogFlowThisFunc(("\n"));
/* Enclose the state transition Ready->InUninit->NotReady */
AutoUninitSpan autoUninitSpan(this);
if (autoUninitSpan.uninitDone())
return;
if (mData.m_ThreadWatcher != NIL_RTTHREAD)
{
/* Signal the event semaphore and wait for the thread to terminate.
* if it hangs for some reason exit anyway, this can cause a crash
* though as the object will no longer be available. */
RTSemEventSignal(mData.m_SemEvWatcher);
RTThreadWait(mData.m_ThreadWatcher, 30000, NULL);
mData.m_ThreadWatcher = NIL_RTTHREAD;
RTSemEventDestroy(mData.m_SemEvWatcher);
mData.m_SemEvWatcher = NIL_RTSEMEVENT;
}
mData.m_pVirtualBox.setNull();
ASMAtomicDecU32(&g_cInstances);
}
int VBoxGINACredentialsPollerTerminate(void)
{
if (gThreadPoller == NIL_RTTHREAD)
return VINF_SUCCESS;
VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerTerminate\n");
/* post termination event semaphore */
int rc = RTThreadUserSignal(gThreadPoller);
if (RT_SUCCESS(rc))
{
VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerTerminate: waiting for thread to terminate\n");
rc = RTThreadWait(gThreadPoller, RT_INDEFINITE_WAIT, NULL);
}
else
VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerTerminate: thread has terminated? wait rc = %Rrc\n", rc);
if (RT_SUCCESS(rc))
{
gThreadPoller = NIL_RTTHREAD;
}
VBoxGINAVerbose(0, "VBoxGINA::credentialsPollerTerminate: returned with rc=%Rrc)\n", rc);
return rc;
}
/**
* Time constrained test with and unlimited N threads.
*/
static void tst3(uint32_t cThreads, uint32_t cbObject, int iMethod, uint32_t cSecs)
{
RTTestISubF("Benchmark - %u threads, %u bytes, %u secs, %s", cThreads, cbObject, cSecs,
iMethod == 0 ? "RTMemCache"
: "RTMemAlloc");
/*
* Create a cache with unlimited space, a start semaphore and line up
* the threads.
*/
RTTESTI_CHECK_RC_RETV(RTMemCacheCreate(&g_hMemCache, cbObject, 0 /*cbAlignment*/, UINT32_MAX, NULL, NULL, NULL, 0 /*fFlags*/), VINF_SUCCESS);
RTSEMEVENTMULTI hEvt;
RTTESTI_CHECK_RC_OK_RETV(RTSemEventMultiCreate(&hEvt));
TST3THREAD aThreads[64];
RTTESTI_CHECK_RETV(cThreads < RT_ELEMENTS(aThreads));
ASMAtomicWriteBool(&g_fTst3Stop, false);
for (uint32_t i = 0; i < cThreads; i++)
{
aThreads[i].hThread = NIL_RTTHREAD;
aThreads[i].cIterations = 0;
aThreads[i].fUseCache = iMethod == 0;
aThreads[i].cbObject = cbObject;
aThreads[i].hEvt = hEvt;
RTTESTI_CHECK_RC_OK_RETV(RTThreadCreateF(&aThreads[i].hThread, tst3Thread, &aThreads[i], 0,
RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tst3-%u", i));
}
/*
* Start the race.
*/
RTTimeNanoTS(); /* warmup */
uint64_t uStartTS = RTTimeNanoTS();
RTTESTI_CHECK_RC_OK_RETV(RTSemEventMultiSignal(hEvt));
RTThreadSleep(cSecs * 1000);
ASMAtomicWriteBool(&g_fTst3Stop, true);
for (uint32_t i = 0; i < cThreads; i++)
RTTESTI_CHECK_RC_OK_RETV(RTThreadWait(aThreads[i].hThread, 60*1000, NULL));
uint64_t cElapsedNS = RTTimeNanoTS() - uStartTS;
/*
* Sum up the counts.
*/
uint64_t cIterations = 0;
for (uint32_t i = 0; i < cThreads; i++)
cIterations += aThreads[i].cIterations;
RTTestIPrintf(RTTESTLVL_ALWAYS, "%'8u iterations per second, %'llu ns on avg\n",
(unsigned)((long double)cIterations * 1000000000.0 / cElapsedNS),
cElapsedNS / cIterations);
/* clean up */
RTTESTI_CHECK_RC(RTMemCacheDestroy(g_hMemCache), VINF_SUCCESS);
RTTESTI_CHECK_RC_OK(RTSemEventMultiDestroy(hEvt));
}
/**
* Destruct a char driver instance.
*
* Most VM resources are freed by the VM. This callback is provided so that
* any non-VM resources can be freed correctly.
*
* @param pDrvIns The driver instance data.
*/
static DECLCALLBACK(void) drvCharDestruct(PPDMDRVINS pDrvIns)
{
PDRVCHAR pThis = PDMINS_2_DATA(pDrvIns, PDRVCHAR);
LogFlow(("%s: iInstance=%d\n", __FUNCTION__, pDrvIns->iInstance));
PDMDRV_CHECK_VERSIONS_RETURN_VOID(pDrvIns);
/*
* Tell the threads to shut down.
*/
pThis->fShutdown = true;
if (pThis->SendSem != NIL_RTSEMEVENT)
{
RTSemEventSignal(pThis->SendSem);
pThis->SendSem = NIL_RTSEMEVENT;
}
/*
* Wait for the threads.
* ASSUMES that PDM destroys the driver chain from the bottom and up.
*/
if (pThis->ReceiveThread != NIL_RTTHREAD)
{
int rc = RTThreadWait(pThis->ReceiveThread, 30000, NULL);
if (RT_SUCCESS(rc))
pThis->ReceiveThread = NIL_RTTHREAD;
else
LogRel(("Char%d: receive thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
}
if (pThis->SendThread != NIL_RTTHREAD)
{
int rc = RTThreadWait(pThis->SendThread, 30000, NULL);
if (RT_SUCCESS(rc))
pThis->SendThread = NIL_RTTHREAD;
else
LogRel(("Char%d: send thread did not terminate (%Rrc)\n", pDrvIns->iInstance, rc));
}
if (pThis->SendSem != NIL_RTSEMEVENT)
{
RTSemEventDestroy(pThis->SendSem);
pThis->SendSem = NIL_RTSEMEVENT;
}
}
/**
* 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);
}
int VDIoBackendMemDestroy(PVDIOBACKENDMEM pIoBackend)
{
ASMAtomicXchgBool(&pIoBackend->fRunning, false);
vdIoBackendMemThreadPoke(pIoBackend);
RTThreadWait(pIoBackend->hThreadIo, RT_INDEFINITE_WAIT, NULL);
RTSemEventDestroy(pIoBackend->EventSem);
RTCircBufDestroy(pIoBackend->pRequestRing);
RTMemFree(pIoBackend);
return VINF_SUCCESS;
}
bool VBoxCredPoller::Shutdown(void)
{
Log(("VBoxCredPoller::Shutdown\n"));
if (m_hThreadPoller == NIL_RTTHREAD)
{
Log(("VBoxCredPoller::Shutdown: Either thread or exit sem is NULL!\n"));
return false;
}
/* Post termination event semaphore. */
int rc = RTThreadUserSignal(m_hThreadPoller);
if (RT_SUCCESS(rc))
{
Log(("VBoxCredPoller::Shutdown: Waiting for thread to terminate\n"));
/* Wait until the thread has terminated. */
rc = RTThreadWait(m_hThreadPoller, RT_INDEFINITE_WAIT, NULL);
Log(("VBoxCredPoller::Shutdown: Thread has (probably) terminated (rc = %Rrc)\n", rc));
}
else
{
/* Failed to signal the thread - very unlikely - so no point in waiting long. */
Log(("VBoxCredPoller::Shutdown: Failed to signal semaphore, rc = %Rrc\n", rc));
rc = RTThreadWait(m_hThreadPoller, 100, NULL);
Log(("VBoxCredPoller::Shutdown: Thread has terminated? wait rc = %Rrc\n", rc));
}
if (m_pProv != NULL)
{
m_pProv->Release();
m_pProv = NULL;
}
credentialsReset();
RTCritSectDelete(&m_csCredUpate);
m_hThreadPoller = NIL_RTTHREAD;
return true;
}
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;
}
HostPowerServiceWin::~HostPowerServiceWin()
{
if (mHwnd)
{
Log(("HostPowerServiceWin::!HostPowerServiceWin: destroy window %x\n", mHwnd));
/* Is this allowed from another thread? */
SetWindowLongPtr(mHwnd, 0, 0);
/* Poke the thread out of the event loop and wait for it to clean up. */
PostMessage(mHwnd, WM_QUIT, 0, 0);
RTThreadWait(mThread, 5000, NULL);
mThread = NIL_RTTHREAD;
}
}
/**
* @interface_method_impl{PDMDEVREG,pfnDestruct}
*/
static DECLCALLBACK(int) gimdevR3Destruct(PPDMDEVINS pDevIns)
{
PGIMDEV pThis = PDMINS_2_DATA(pDevIns, PGIMDEV);
PVM pVM = PDMDevHlpGetVM(pDevIns);
uint32_t cRegions = 0;
PGIMMMIO2REGION pCur = GIMR3GetMmio2Regions(pVM, &cRegions);
for (uint32_t i = 0; i < cRegions; i++, pCur++)
{
int rc = PDMDevHlpMMIOExDeregister(pDevIns, NULL, pCur->iRegion);
if (RT_FAILURE(rc))
return rc;
}
/*
* Signal and wait for the debug thread to terminate.
*/
if (pThis->hDbgRecvThread != NIL_RTTHREAD)
{
pThis->fDbgRecvThreadShutdown = true;
if (pThis->Dbg.hDbgRecvThreadSem != NIL_RTSEMEVENT)
RTSemEventMultiSignal(pThis->Dbg.hDbgRecvThreadSem);
int rc = RTThreadWait(pThis->hDbgRecvThread, 20000, NULL /*prc*/);
if (RT_SUCCESS(rc))
pThis->hDbgRecvThread = NIL_RTTHREAD;
else
{
LogRel(("GIMDev: Debug thread did not terminate, rc=%Rrc!\n", rc));
return VERR_RESOURCE_BUSY;
}
}
/*
* Now clean up the semaphore & buffer now that the thread is gone.
*/
if (pThis->Dbg.hDbgRecvThreadSem != NIL_RTSEMEVENT)
{
RTSemEventMultiDestroy(pThis->Dbg.hDbgRecvThreadSem);
pThis->Dbg.hDbgRecvThreadSem = NIL_RTSEMEVENTMULTI;
}
if (pThis->Dbg.pvDbgRecvBuf)
{
RTMemFree(pThis->Dbg.pvDbgRecvBuf);
pThis->Dbg.pvDbgRecvBuf = NULL;
}
return VINF_SUCCESS;
}
void vboxClipboardDestroy (void)
{
Log(("vboxClipboardDestroy\n"));
if (g_ctx.hwnd)
{
int rc = PostMessage (g_ctx.hwnd, WM_CLOSE, 0, 0);
}
CloseHandle (g_ctx.hRenderEvent);
/* Wait for the window thread to terminate. */
RTThreadWait (g_ctx.thread, RT_INDEFINITE_WAIT, NULL);
g_ctx.thread = NIL_RTTHREAD;
}
/**
* Send a signal to the thread function that it should exit
*/
int SeamlessMain::stopX11MonitorThread(void)
{
int rc;
mX11MonitorThreadStopping = true;
if (!isX11MonitorThreadRunning())
return VINF_SUCCESS;
mX11Monitor.interruptEventWait();
rc = RTThreadWait(mX11MonitorThread, RT_INDEFINITE_WAIT, NULL);
if (RT_SUCCESS(rc))
mX11MonitorThread = NIL_RTTHREAD;
else
LogRelThisFunc(("Failed to stop X11 monitor thread, rc=%Rrc!\n",
rc));
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;
}
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);
}
void vboxClipboardDestroy (void)
{
Log(("vboxClipboardDestroy\n"));
/* Set the termination flag and ping the window thread. */
ASMAtomicWriteBool (&g_ctx.fTerminate, true);
if (g_ctx.hwnd)
{
PostMessage (g_ctx.hwnd, WM_CLOSE, 0, 0);
}
CloseHandle (g_ctx.hRenderEvent);
/* Wait for the window thread to terminate. */
RTThreadWait (g_ctx.thread, RT_INDEFINITE_WAIT, NULL);
g_ctx.thread = NIL_RTTHREAD;
}
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);
}
/** Terminate the host side of the shared clipboard - called by the hgcm layer. */
void vboxClipboardDestroy(void)
{
Log(("vboxClipboardDestroy\n"));
/*
* Signal the termination of the polling thread and wait for it to respond.
*/
ASMAtomicWriteBool(&g_ctx.fTerminate, true);
int rc = RTThreadUserSignal(g_ctx.thread);
AssertRC(rc);
rc = RTThreadWait(g_ctx.thread, RT_INDEFINITE_WAIT, NULL);
AssertRC(rc);
/*
* Destroy the pasteboard and uninitialize the global context record.
*/
destroyPasteboard(&g_ctx.pasteboard);
g_ctx.thread = NIL_RTTHREAD;
g_ctx.pClient = NULL;
}
VBoxDbgConsole::~VBoxDbgConsole()
{
Assert(isGUIThread());
/*
* Wait for the thread.
*/
ASMAtomicWriteBool(&m_fTerminate, true);
RTSemEventSignal(m_EventSem);
if (m_Thread != NIL_RTTHREAD)
{
int rc = RTThreadWait(m_Thread, 15000, NULL);
AssertRC(rc);
m_Thread = NIL_RTTHREAD;
}
/*
* Free resources.
*/
delete m_pTimer;
m_pTimer = NULL;
RTCritSectDelete(&m_Lock);
RTSemEventDestroy(m_EventSem);
m_EventSem = 0;
m_pOutput = NULL;
m_pInput = NULL;
if (m_pszInputBuf)
{
RTMemFree(m_pszInputBuf);
m_pszInputBuf = NULL;
}
m_cbInputBuf = 0;
m_cbInputBufAlloc = 0;
delete m_pFocusToInput;
m_pFocusToInput = NULL;
delete m_pFocusToOutput;
m_pFocusToOutput = NULL;
}
/** sub test */
static void tst4Sub(uint32_t cThreads)
{
RTTestISubF("Serialization - %u threads", cThreads);
RTMEMPOOL hMemPool;
RTTESTI_CHECK_RC_RETV(RTMemPoolCreate(&hMemPool, "test 2a"), VINF_SUCCESS);
g_hMemPool4 = hMemPool;
PRTTHREAD pahThreads = (PRTTHREAD)RTMemPoolAlloc(hMemPool, cThreads * sizeof(RTTHREAD));
RTTESTI_CHECK(pahThreads);
if (pahThreads)
{
/* start them. */
for (uint32_t i = 0; i < cThreads; i++)
{
int rc = RTThreadCreateF(&pahThreads[i], tst4Thread, (void *)(uintptr_t)i, 0,
RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tst4-%u/%u", i, cThreads);
RTTESTI_CHECK_RC_OK(rc);
if (RT_FAILURE(rc))
pahThreads[i] = NIL_RTTHREAD;
}
RTThreadYield();
/* kick them off. */
for (uint32_t i = 0; i < cThreads; i++)
if (pahThreads[i] != NIL_RTTHREAD)
RTTESTI_CHECK_RC_OK(RTThreadUserSignal(pahThreads[i]));
/* wait for them. */
for (uint32_t i = 0; i < cThreads; i++)
if (pahThreads[i] != NIL_RTTHREAD)
{
int rc = RTThreadWait(pahThreads[i], 2*60*1000, NULL);
RTTESTI_CHECK_RC_OK(rc);
}
}
RTTESTI_CHECK_RC(RTMemPoolDestroy(hMemPool), VINF_SUCCESS);
}
static int testServerListenAndCancel(RTTEST hTest, const char *pszExecPath)
{
RTTestSub(hTest, "testServerListenAndCancel");
RTLOCALIPCSERVER ipcServer;
int rc = RTLocalIpcServerCreate(&ipcServer, "testServerListenAndCancel",
RTLOCALIPC_FLAGS_MULTI_SESSION);
if (RT_SUCCESS(rc))
{
/* 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, testServerListenAndCancelThread,
&ipcServer, 0 /* Stack */, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "tstIpc1");
if (RT_SUCCESS(rc))
{
do
{
RTTestPrintf(hTest, RTTESTLVL_INFO, "Listening for incoming connections ...\n");
RTLOCALIPCSESSION ipcSession;
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerListen(ipcServer, &ipcSession), VERR_CANCELLED);
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerCancel(ipcServer), VINF_SUCCESS);
RTTEST_CHECK_RC_BREAK(hTest, RTLocalIpcServerDestroy(ipcServer), VINF_SUCCESS);
RTTestPrintf(hTest, RTTESTLVL_INFO, "Waiting for thread to exit ...\n");
RTTEST_CHECK_RC(hTest, RTThreadWait(hThread,
30 * 1000 /* 30s timeout */, NULL), VINF_SUCCESS);
} while (0);
}
else
RTTestIFailed("Unable to create thread for cancelling server, rc=%Rrc\n", rc);
}
else
RTTestIFailed("Unable to create IPC server, rc=%Rrc\n", rc);
return VINF_SUCCESS;
}
/**
* Does a multi-threading list test. Several list additions, reading, replacing
* and erasing are done simultaneous.
*
*/
static void test2()
{
RTTestISubF("MT test with 6 threads (%u tests per thread).", MTTESTITEMS);
RTTHREAD hThread1, hThread2, hThread3, hThread4, hThread5, hThread6;
int rc = VINF_SUCCESS;
MTTESTLISTTYPE<MTTESTTYPE> testList;
rc = RTThreadCreate(&hThread1, &mttest1, &testList, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest1");
AssertRC(rc);
rc = RTThreadCreate(&hThread2, &mttest2, &testList, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest2");
AssertRC(rc);
rc = RTThreadCreate(&hThread3, &mttest3, &testList, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest3");
AssertRC(rc);
rc = RTThreadCreate(&hThread4, &mttest4, &testList, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest4");
AssertRC(rc);
rc = RTThreadCreate(&hThread5, &mttest5, &testList, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest5");
AssertRC(rc);
rc = RTThreadCreate(&hThread6, &mttest6, &testList, 0, RTTHREADTYPE_DEFAULT, RTTHREADFLAGS_WAITABLE, "mttest6");
AssertRC(rc);
rc = RTThreadWait(hThread1, RT_INDEFINITE_WAIT, 0);
AssertRC(rc);
rc = RTThreadWait(hThread2, RT_INDEFINITE_WAIT, 0);
AssertRC(rc);
rc = RTThreadWait(hThread3, RT_INDEFINITE_WAIT, 0);
AssertRC(rc);
rc = RTThreadWait(hThread4, RT_INDEFINITE_WAIT, 0);
AssertRC(rc);
rc = RTThreadWait(hThread5, RT_INDEFINITE_WAIT, 0);
AssertRC(rc);
rc = RTThreadWait(hThread6, RT_INDEFINITE_WAIT, 0);
AssertRC(rc);
RTTESTI_CHECK_RETV(testList.size() == MTTESTITEMS * 2);
for (size_t i = 0; i < testList.size(); ++i)
{
uint32_t a = testList.at(i);
RTTESTI_CHECK(a == 0x0 || a == 0xFFFFFFFF || a == 0xF0F0F0F0 || a == 0xFF00FF00);
}
}
