nsresult
nsIOThreadPool::Init()
{
#if defined(PR_LOGGING)
if (!gIOThreadPoolLog)
gIOThreadPoolLog = PR_NewLogModule("nsIOThreadPool");
#endif
mNumThreads = 0;
mNumIdleThreads = 0;
mShutdown = PR_FALSE;
mLock = PR_NewLock();
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mIdleThreadCV = PR_NewCondVar(mLock);
if (!mIdleThreadCV)
return NS_ERROR_OUT_OF_MEMORY;
mExitThreadCV = PR_NewCondVar(mLock);
if (!mExitThreadCV)
return NS_ERROR_OUT_OF_MEMORY;
PR_INIT_CLIST(&mEventQ);
// We want to shutdown the i/o thread pool at xpcom-shutdown-threads time.
nsCOMPtr<nsIObserverService> os = mozilla::services::GetObserverService();
if (os)
os->AddObserver(this, "xpcom-shutdown-threads", PR_FALSE);
return NS_OK;
}
SECStatus
launch_thread(GlobalThreadMgr *threadMGR,
startFn *startFunc,
void *a,
int b)
{
perThread *slot;
int i;
if (!threadMGR->threadStartQ) {
threadMGR->threadLock = PR_NewLock();
threadMGR->threadStartQ = PR_NewCondVar(threadMGR->threadLock);
threadMGR->threadEndQ = PR_NewCondVar(threadMGR->threadLock);
}
PR_Lock(threadMGR->threadLock);
while (threadMGR->numRunning >= MAX_THREADS) {
PR_WaitCondVar(threadMGR->threadStartQ, PR_INTERVAL_NO_TIMEOUT);
}
for (i = 0; i < threadMGR->numUsed; ++i) {
slot = &threadMGR->threads[i];
if (slot->running == rs_idle)
break;
}
if (i >= threadMGR->numUsed) {
if (i >= MAX_THREADS) {
/* something's really wrong here. */
PORT_Assert(i < MAX_THREADS);
PR_Unlock(threadMGR->threadLock);
return SECFailure;
}
++(threadMGR->numUsed);
PORT_Assert(threadMGR->numUsed == i + 1);
slot = &threadMGR->threads[i];
}
slot->a = a;
slot->b = b;
slot->startFunc = startFunc;
threadMGR->index = i;
slot->prThread = PR_CreateThread(PR_USER_THREAD,
thread_wrapper, threadMGR,
PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_JOINABLE_THREAD, 0);
if (slot->prThread == NULL) {
PR_Unlock(threadMGR->threadLock);
printf("Failed to launch thread!\n");
return SECFailure;
}
slot->inUse = 1;
slot->running = 1;
++(threadMGR->numRunning);
PR_Unlock(threadMGR->threadLock);
return SECSuccess;
}
PR_IMPLEMENT(PRWaitGroup*) PR_CreateWaitGroup(PRInt32 size /* ignored */)
{
PRWaitGroup *wg = NULL;
if (PR_FAILURE == MW_Init()) goto failed;
if (NULL == (wg = PR_NEWZAP(PRWaitGroup))) goto failed;
/* the wait group itself */
wg->ml = PR_NewLock();
if (NULL == wg->ml) goto failed_lock;
wg->io_taken = PR_NewCondVar(wg->ml);
if (NULL == wg->io_taken) goto failed_cvar0;
wg->io_complete = PR_NewCondVar(wg->ml);
if (NULL == wg->io_complete) goto failed_cvar1;
wg->new_business = PR_NewCondVar(wg->ml);
if (NULL == wg->new_business) goto failed_cvar2;
wg->mw_manage = PR_NewCondVar(wg->ml);
if (NULL == wg->mw_manage) goto failed_cvar3;
PR_INIT_CLIST(&wg->group_link);
PR_INIT_CLIST(&wg->io_ready);
/* the waiters sequence */
wg->waiter = (_PRWaiterHash*)PR_CALLOC(
sizeof(_PRWaiterHash) +
(_PR_DEFAULT_HASH_LENGTH * sizeof(PRRecvWait*)));
if (NULL == wg->waiter) goto failed_waiter;
wg->waiter->count = 0;
wg->waiter->length = _PR_DEFAULT_HASH_LENGTH;
PR_Lock(mw_lock);
PR_APPEND_LINK(&wg->group_link, &mw_state->group_list);
PR_Unlock(mw_lock);
return wg;
failed_waiter:
PR_DestroyCondVar(wg->mw_manage);
failed_cvar3:
PR_DestroyCondVar(wg->new_business);
failed_cvar2:
PR_DestroyCondVar(wg->io_taken);
failed_cvar1:
PR_DestroyCondVar(wg->io_complete);
failed_cvar0:
PR_DestroyLock(wg->ml);
failed_lock:
PR_DELETE(wg);
failed:
return wg;
} /* MW_CreateWaitGroup */
static PRThreadPool *
alloc_threadpool(void)
{
PRThreadPool *tp;
tp = (PRThreadPool *) PR_CALLOC(sizeof(*tp));
if (NULL == tp)
goto failed;
tp->jobq.lock = PR_NewLock();
if (NULL == tp->jobq.lock)
goto failed;
tp->jobq.cv = PR_NewCondVar(tp->jobq.lock);
if (NULL == tp->jobq.cv)
goto failed;
tp->join_lock = PR_NewLock();
if (NULL == tp->join_lock)
goto failed;
#ifdef OPT_WINNT
tp->jobq.nt_completion_port = CreateIoCompletionPort(INVALID_HANDLE_VALUE,
NULL, 0, 0);
if (NULL == tp->jobq.nt_completion_port)
goto failed;
#endif
tp->ioq.lock = PR_NewLock();
if (NULL == tp->ioq.lock)
goto failed;
/* Timer queue */
tp->timerq.lock = PR_NewLock();
if (NULL == tp->timerq.lock)
goto failed;
tp->timerq.cv = PR_NewCondVar(tp->timerq.lock);
if (NULL == tp->timerq.cv)
goto failed;
tp->shutdown_cv = PR_NewCondVar(tp->jobq.lock);
if (NULL == tp->shutdown_cv)
goto failed;
tp->ioq.notify_fd = PR_NewPollableEvent();
if (NULL == tp->ioq.notify_fd)
goto failed;
return tp;
failed:
delete_threadpool(tp);
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return NULL;
}
/*
** NewCB creates and initializes a new circular buffer.
*/
static CircBuf* NewCB(void)
{
CircBuf *cbp;
cbp = PR_NEW(CircBuf);
if (cbp == NULL)
return (NULL);
cbp->bufLock = PR_NewLock();
cbp->startIdx = 0;
cbp->numFull = 0;
cbp->notFull = PR_NewCondVar(cbp->bufLock);
cbp->notEmpty = PR_NewCondVar(cbp->bufLock);
return (cbp);
}
CondVarNSPR::CondVarNSPR(MutexNSPR* mutex)
: mCondVar(NULL)
, mCondMutex(NULL)
{
// If the caller did not specify a mutex variable to use with
// the condition variable, use mDefaultMutex.
if ( mutex == NULL )
{
mCondMutex = &mDefaultMutex;
}
else
{
mCondMutex = mutex;
}
// Initialize the condition variable.
mCondVar = PR_NewCondVar(mCondMutex->mMutex);
if ( NULL == mCondVar )
{
std::ostringstream msg_stream;
NSPR_PrintError("Condition variable allocation failed: ", msg_stream);
throw vpr::ResourceException(msg_stream.str(), VPR_LOCATION);
}
}
void _PR_InitIO(void)
{
const PRIOMethods *methods = PR_GetFileMethods();
_PR_InitFdCache();
_pr_flock_lock = PR_NewLock();
_pr_flock_cv = PR_NewCondVar(_pr_flock_lock);
#ifdef WIN32
_pr_stdin = PR_AllocFileDesc((PROsfd)GetStdHandle(STD_INPUT_HANDLE),
methods);
_pr_stdout = PR_AllocFileDesc((PROsfd)GetStdHandle(STD_OUTPUT_HANDLE),
methods);
_pr_stderr = PR_AllocFileDesc((PROsfd)GetStdHandle(STD_ERROR_HANDLE),
methods);
#ifdef WINNT
_pr_stdin->secret->md.sync_file_io = PR_TRUE;
_pr_stdout->secret->md.sync_file_io = PR_TRUE;
_pr_stderr->secret->md.sync_file_io = PR_TRUE;
#endif
#else
_pr_stdin = PR_AllocFileDesc(0, methods);
_pr_stdout = PR_AllocFileDesc(1, methods);
_pr_stderr = PR_AllocFileDesc(2, methods);
#endif
_PR_MD_INIT_FD_INHERITABLE(_pr_stdin, PR_TRUE);
_PR_MD_INIT_FD_INHERITABLE(_pr_stdout, PR_TRUE);
_PR_MD_INIT_FD_INHERITABLE(_pr_stderr, PR_TRUE);
_PR_MD_INIT_IO();
}
PR_IMPLEMENT(PRSemaphore*) PR_NewSem(PRUintn value)
{
PRSemaphore *semaphore;
static PRBool unwarned = PR_TRUE;
if (!_pr_initialized) _PR_ImplicitInitialization();
if (unwarned) unwarned = _PR_Obsolete(
"PR_NewSem", "locks & condition variables");
semaphore = PR_NEWZAP(PRSemaphore);
if (NULL != semaphore)
{
PRLock *lock = PR_NewLock();
if (NULL != lock)
{
semaphore->cvar = PR_NewCondVar(lock);
if (NULL != semaphore->cvar)
{
semaphore->count = value;
return semaphore;
}
PR_DestroyLock(lock);
}
PR_Free(semaphore);
}
return NULL;
}
static PRIntervalTime ConditionTimeout(PRUint32 loops)
{
PRUintn count;
PRIntervalTime overhead, timein = PR_IntervalNow();
PRLock *ml = PR_NewLock();
PRCondVar *cv = PR_NewCondVar(ml);
PRIntervalTime interval = PR_MillisecondsToInterval(50);
overhead = PR_IntervalNow() - timein;
PR_Lock(ml);
for (count = 0; count < loops; ++count)
{
overhead += interval;
PR_ASSERT(PR_WaitCondVar(cv, interval) == PR_SUCCESS);
}
PR_Unlock(ml);
timein = PR_IntervalNow();
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
overhead += (PR_IntervalNow() - timein);
return overhead;
} /* ConditionTimeout */
static PRJob *
alloc_job(PRBool joinable, PRThreadPool *tp)
{
PRJob *jobp;
jobp = PR_NEWZAP(PRJob);
if (NULL == jobp)
goto failed;
if (joinable) {
jobp->join_cv = PR_NewCondVar(tp->join_lock);
jobp->join_wait = PR_TRUE;
if (NULL == jobp->join_cv)
goto failed;
} else {
jobp->join_cv = NULL;
}
#ifdef OPT_WINNT
jobp->nt_notifier.jobp = jobp;
#endif
return jobp;
failed:
delete_job(jobp);
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return NULL;
}
LdapSessionPool::LdapSessionPool(LdapServerSet *servers, unsigned short limit,
dyngroupmode_t dyngroupmode)
{
authmethod=NULL;
certNickName=NULL;
_maxSessions = (limit < 1 ? 1 : limit);
_dyngroupmode = dyngroupmode;
//_servers = servers;
_waiters = 0;
_lock = PR_NewLock();
assert(_lock);
_cvar = PR_NewCondVar(_lock);
assert(_cvar);
// add new pool to list of all pools
if (_poolListLock == NULL) {
static PRCallOnceType once = { 0, 0, (PRStatus)0 };
PR_CallOnce(&once, PoolListCreate);
}
PR_Lock(_poolListLock);
_nextPool = _poolList;
_poolList = this;
PR_Unlock(_poolListLock);
}
nsresult PeerConnectionCtx::Initialize() {
mCCM = CSF::CallControlManager::create();
NS_ENSURE_TRUE(mCCM.get(), NS_ERROR_FAILURE);
// Add the local audio codecs
// FIX - Get this list from MediaEngine instead
int codecMask = 0;
codecMask |= VCM_CODEC_RESOURCE_G711;
codecMask |= VCM_CODEC_RESOURCE_OPUS;
//codecMask |= VCM_CODEC_RESOURCE_LINEAR;
//codecMask |= VCM_CODEC_RESOURCE_G722;
//codecMask |= VCM_CODEC_RESOURCE_iLBC;
//codecMask |= VCM_CODEC_RESOURCE_iSAC;
mCCM->setAudioCodecs(codecMask);
//Add the local video codecs
// FIX - Get this list from MediaEngine instead
// Turning them all on for now
codecMask = 0;
// Only adding codecs supported
//codecMask |= VCM_CODEC_RESOURCE_H263;
//codecMask |= VCM_CODEC_RESOURCE_H264;
codecMask |= VCM_CODEC_RESOURCE_VP8;
//codecMask |= VCM_CODEC_RESOURCE_I420;
mCCM->setVideoCodecs(codecMask);
ccAppReadyToStartLock = PR_NewLock();
if (!ccAppReadyToStartLock) {
return NS_ERROR_FAILURE;
}
ccAppReadyToStartCond = PR_NewCondVar(ccAppReadyToStartLock);
if (!ccAppReadyToStartCond) {
return NS_ERROR_FAILURE;
}
if (!mCCM->startSDPMode())
return NS_ERROR_FAILURE;
mDevice = mCCM->getActiveDevice();
mCCM->addCCObserver(this);
NS_ENSURE_TRUE(mDevice.get(), NS_ERROR_FAILURE);
ChangeSipccState(mozilla::dom::PCImplSipccState::Starting);
// Now that everything is set up, we let the CCApp thread
// know that it's okay to start processing messages.
PR_Lock(ccAppReadyToStartLock);
ccAppReadyToStart = 1;
PR_NotifyAllCondVar(ccAppReadyToStartCond);
PR_Unlock(ccAppReadyToStartLock);
mConnectionCounter = 0;
#ifdef MOZILLA_INTERNAL_API
Telemetry::GetHistogramById(Telemetry::WEBRTC_CALL_COUNT)->Add(0);
#endif
return NS_OK;
}
void DNSSession :: common(PRIntervalTime tm)
{
starttime = PR_IntervalNow();
timeout = tm;
timedout = PR_FALSE;
sendfailed = PR_FALSE;
id = 0;
lock = PR_NewLock();
PR_ASSERT(lock);
cvar = PR_NewCondVar(lock);
PR_ASSERT(cvar);
status = DNS_INIT;
awake = PR_FALSE;
// query stuff
re_retries = _res.retry;
re_sends = 1;
re_resend = 1;
re_he.h_addr_list[0] = 0;
re_data = NULL;
re_sent = 0;
re_srch = 0;
re_type = 0;
memset(re_name, 0, sizeof(re_name));
memset((void*)&re_he, 0, sizeof(re_he));
memset((void*)&ar_host, 0, sizeof(ar_host));
}
/*
** Create a new semaphore.
*/
PR_IMPLEMENT(PRSemaphore*) PR_NewSem(PRUintn value)
{
PRSemaphore *sem;
PRCondVar *cvar;
PRLock *lock;
sem = PR_NEWZAP(PRSemaphore);
if (sem) {
#ifdef HAVE_CVAR_BUILT_ON_SEM
_PR_MD_NEW_SEM(&sem->md, value);
#else
lock = PR_NewLock();
if (!lock) {
PR_DELETE(sem);
return NULL;
}
cvar = PR_NewCondVar(lock);
if (!cvar) {
PR_DestroyLock(lock);
PR_DELETE(sem);
return NULL;
}
sem->cvar = cvar;
sem->count = value;
#endif
}
return sem;
}
static void PR_CALLBACK forked(void *arg)
{
PRIntn i;
PRLock *ml;
PRCondVar *cv;
PR_LogPrint("%s logging creating mutex\n", (const char*)arg);
ml = PR_NewLock();
PR_LogPrint("%s logging creating condition variable\n", (const char*)arg);
cv = PR_NewCondVar(ml);
PR_LogPrint("%s waiting on condition timeout 10 times\n", (const char*)arg);
for (i = 0; i < 10; ++i)
{
PR_Lock(ml);
PR_WaitCondVar(cv, PR_SecondsToInterval(1));
PR_Unlock(ml);
}
PR_LogPrint("%s logging destroying condition variable\n", (const char*)arg);
PR_DestroyCondVar(cv);
PR_LogPrint("%s logging destroying mutex\n", (const char*)arg);
PR_DestroyLock(ml);
PR_LogPrint("%s forked thread exiting\n", (const char*)arg);
}
/*
** Create a new monitor.
*/
PR_IMPLEMENT(PRMonitor*) PR_NewMonitor()
{
PRMonitor *mon;
PRCondVar *cvar;
PRLock *lock;
mon = PR_NEWZAP(PRMonitor);
if (mon) {
lock = PR_NewLock();
if (!lock) {
PR_DELETE(mon);
return 0;
}
cvar = PR_NewCondVar(lock);
if (!cvar) {
PR_DestroyLock(lock);
PR_DELETE(mon);
return 0;
}
mon->cvar = cvar;
mon->name = NULL;
}
return mon;
}
static void TestIntervals(void)
{
PRStatus rv;
PRUint32 delta;
PRInt32 seconds;
PRUint64 elapsed, thousand;
PRTime timein, timeout;
PRLock *ml = PR_NewLock();
PRCondVar *cv = PR_NewCondVar(ml);
for (seconds = 0; seconds < 10; ++seconds)
{
PRIntervalTime ticks = PR_SecondsToInterval(seconds);
PR_Lock(ml);
timein = PR_Now();
rv = PR_WaitCondVar(cv, ticks);
timeout = PR_Now();
PR_Unlock(ml);
LL_SUB(elapsed, timeout, timein);
LL_I2L(thousand, 1000);
LL_DIV(elapsed, elapsed, thousand);
LL_L2UI(delta, elapsed);
if (debug_mode) PR_fprintf(output,
"TestIntervals: %swaiting %ld seconds took %ld msecs\n",
((rv == PR_SUCCESS) ? "" : "FAILED "), seconds, delta);
}
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
if (debug_mode) PR_fprintf(output, "\n");
} /* TestIntervals */
static void T1Lock(void)
{
PRStatus rv;
PRThread *t2, *t3;
sharedL.o1 = PR_NewLock();
sharedL.o2 = PR_NewLock();
sharedL.cv1 = PR_NewCondVar(sharedL.o1);
sharedL.cv2 = PR_NewCondVar(sharedL.o2);
PR_fprintf(err, "\n**********************************\n");
PR_fprintf(err, " LOCKS\n");
PR_fprintf(err, "**********************************\n");
base = PR_IntervalNow();
PR_Lock(sharedL.o1);
LogNow("T1 waiting 3 seconds on o1", PR_SUCCESS);
rv = PR_WaitCondVar(sharedL.cv1, PR_SecondsToInterval(3));
if (PR_SUCCESS == rv) LogNow("T1 resuming on o1", rv);
else LogNow("T1 wait on o1 failed", rv);
PR_Unlock(sharedL.o1);
LogNow("T1 creating T2", PR_SUCCESS);
t2 = PR_CreateThread(
PR_USER_THREAD, T2Lock, &sharedL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
LogNow("T1 creating T3", PR_SUCCESS);
t3 = PR_CreateThread(
PR_USER_THREAD, T3Lock, &sharedL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_Lock(sharedL.o2);
LogNow("T1 waiting forever on o2", PR_SUCCESS);
rv = PR_WaitCondVar(sharedL.cv2, PR_INTERVAL_NO_TIMEOUT);
if (PR_SUCCESS == rv) LogNow("T1 resuming on o2", rv);
else LogNow("T1 wait on o2 failed", rv);
PR_Unlock(sharedL.o2);
(void)PR_JoinThread(t2);
(void)PR_JoinThread(t3);
PR_DestroyLock(sharedL.o1);
PR_DestroyLock(sharedL.o2);
PR_DestroyCondVar(sharedL.cv1);
PR_DestroyCondVar(sharedL.cv2);
} /* T1Lock */
static void WaitCondVarThread(void *arg)
{
PRIntervalTime timeout = (PRIntervalTime) arg;
PRIntervalTime elapsed;
#if defined(XP_UNIX) || defined(WIN32)
PRInt32 timeout_msecs = PR_IntervalToMilliseconds(timeout);
PRInt32 elapsed_msecs;
#endif
#if defined(XP_UNIX)
struct timeval end_time_tv;
#endif
#if defined(WIN32)
struct _timeb end_time_tb;
#endif
PRLock *ml;
PRCondVar *cv;
ml = PR_NewLock();
if (ml == NULL) {
fprintf(stderr, "PR_NewLock failed\n");
exit(1);
}
cv = PR_NewCondVar(ml);
if (cv == NULL) {
fprintf(stderr, "PR_NewCondVar failed\n");
exit(1);
}
PR_Lock(ml);
PR_WaitCondVar(cv, timeout);
PR_Unlock(ml);
elapsed = (PRIntervalTime)(PR_IntervalNow() - start_time);
if (elapsed + tolerance < timeout || elapsed > timeout + tolerance) {
fprintf(stderr, "timeout wrong\n");
exit(1);
}
#if defined(XP_UNIX)
gettimeofday(&end_time_tv, NULL);
elapsed_msecs = 1000*(end_time_tv.tv_sec - start_time_tv.tv_sec)
+ (end_time_tv.tv_usec - start_time_tv.tv_usec)/1000;
#endif
#if defined(WIN32)
_ftime(&end_time_tb);
elapsed_msecs = 1000*(end_time_tb.time - start_time_tb.time)
+ (end_time_tb.millitm - start_time_tb.millitm);
#endif
#if defined(XP_UNIX) || defined(WIN32)
if (elapsed_msecs + tolerance_msecs < timeout_msecs
|| elapsed_msecs > timeout_msecs + tolerance_msecs) {
fprintf(stderr, "timeout wrong\n");
exit(1);
}
#endif
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
if (debug_mode) {
fprintf(stderr, "wait cond var thread (scope %d) done\n",
PR_GetThreadScope(PR_GetCurrentThread()));
}
}
void
lockedVars_Init( lockedVars * lv)
{
lv->count = 0;
lv->waiters = 0;
lv->lock = PR_NewLock();
lv->condVar = PR_NewCondVar(lv->lock);
}
int referint_postop_start( Slapi_PBlock *pb)
{
char **argv;
int argc = 0;
/* get args */
if ( slapi_pblock_get( pb, SLAPI_PLUGIN_ARGC, &argc ) != 0 ) {
slapi_log_error( SLAPI_LOG_FATAL, REFERINT_PLUGIN_SUBSYSTEM,
"referint_postop failed to get argv\n" );
return( -1 );
}
if ( slapi_pblock_get( pb, SLAPI_PLUGIN_ARGV, &argv ) != 0 ) {
slapi_log_error( SLAPI_LOG_FATAL, REFERINT_PLUGIN_SUBSYSTEM,
"referint_postop failed to get argv\n" );
return( -1 );
}
if(argv == NULL){
slapi_log_error( SLAPI_LOG_FATAL, REFERINT_PLUGIN_SUBSYSTEM,
"args were null in referint_postop_start\n" );
return( -1 );
}
/*
* Only bother to start the thread if you are in delay mode.
* 0 = no delay,
* -1 = integrity off
*/
if (argc >= 1) {
if(atoi(argv[0]) > 0){
/* initialize the cv and lock */
if (!use_txn && (NULL == referint_mutex)) {
referint_mutex = PR_NewLock();
}
keeprunning_mutex = PR_NewLock();
keeprunning_cv = PR_NewCondVar(keeprunning_mutex);
keeprunning =1;
referint_tid = PR_CreateThread (PR_USER_THREAD,
referint_thread_func,
(void *)argv,
PR_PRIORITY_NORMAL,
PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD,
SLAPD_DEFAULT_THREAD_STACKSIZE);
if ( referint_tid == NULL ) {
slapi_log_error( SLAPI_LOG_FATAL, REFERINT_PLUGIN_SUBSYSTEM,
"referint_postop_start PR_CreateThread failed\n" );
exit( 1 );
}
}
} else {
slapi_log_error( SLAPI_LOG_FATAL, REFERINT_PLUGIN_SUBSYSTEM,
"referint_postop_start insufficient arguments supplied\n" );
return( -1 );
}
refint_started = 1;
return(0);
}
static PRStatus TimerInit(void)
{
tm_vars.ml = PR_NewLock();
if (NULL == tm_vars.ml)
{
goto failed;
}
tm_vars.new_timer = PR_NewCondVar(tm_vars.ml);
if (NULL == tm_vars.new_timer)
{
goto failed;
}
tm_vars.cancel_timer = PR_NewCondVar(tm_vars.ml);
if (NULL == tm_vars.cancel_timer)
{
goto failed;
}
PR_INIT_CLIST(&tm_vars.timer_queue);
tm_vars.manager_thread = PR_CreateThread(
PR_SYSTEM_THREAD, TimerManager, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_UNJOINABLE_THREAD, 0);
if (NULL == tm_vars.manager_thread)
{
goto failed;
}
return PR_SUCCESS;
failed:
if (NULL != tm_vars.cancel_timer)
{
PR_DestroyCondVar(tm_vars.cancel_timer);
}
if (NULL != tm_vars.new_timer)
{
PR_DestroyCondVar(tm_vars.new_timer);
}
if (NULL != tm_vars.ml)
{
PR_DestroyLock(tm_vars.ml);
}
return PR_FAILURE;
}
int main(int argc, char **argv)
{
PRThread *thread;
PRIntervalTime start, end;
PRUint32 elapsed_ms;
lock1 = PR_NewLock();
PR_ASSERT(NULL != lock1);
cv1 = PR_NewCondVar(lock1);
PR_ASSERT(NULL != cv1);
lock2 = PR_NewLock();
PR_ASSERT(NULL != lock2);
cv2 = PR_NewCondVar(lock2);
PR_ASSERT(NULL != cv2);
start = PR_IntervalNow();
thread = PR_CreateThread(
PR_USER_THREAD,
ThreadFunc,
NULL,
PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
0);
PR_ASSERT(NULL != thread);
PR_Lock(lock2);
PR_WaitCondVar(cv2, PR_MillisecondsToInterval(LONG_TIMEOUT));
PR_Unlock(lock2);
PR_JoinThread(thread);
end = PR_IntervalNow();
elapsed_ms = PR_IntervalToMilliseconds((PRIntervalTime)(end - start));
/* Allow 100ms imprecision */
if (elapsed_ms < LONG_TIMEOUT - 100 || elapsed_ms > LONG_TIMEOUT + 100) {
printf("Elapsed time should be %u ms but is %u ms\n",
LONG_TIMEOUT, elapsed_ms);
printf("FAIL\n");
exit(1);
}
printf("Elapsed time: %u ms, expected time: %u ms\n",
LONG_TIMEOUT, elapsed_ms);
printf("PASS\n");
return 0;
}
bool
JSBackgroundThread::init()
{
if (!(lock = PR_NewLock()))
return false;
if (!(wakeup = PR_NewCondVar(lock)))
return false;
thread = PR_CreateThread(PR_USER_THREAD, start, this, PR_PRIORITY_LOW,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
return !!thread;
}
static PRIntervalTime ConditionNotify(PRUint32 loops)
{
PRThread *thread;
NotifyData notifyData;
PRIntervalTime timein, overhead;
timein = PR_IntervalNow();
notifyData.counter = loops;
notifyData.ml = PR_NewLock();
notifyData.child = PR_NewCondVar(notifyData.ml);
notifyData.parent = PR_NewCondVar(notifyData.ml);
thread = PR_CreateThread(
PR_USER_THREAD, Notifier, ¬ifyData,
PR_GetThreadPriority(PR_GetCurrentThread()),
thread_scope, PR_JOINABLE_THREAD, 0);
overhead = PR_IntervalNow() - timein; /* elapsed so far */
PR_Lock(notifyData.ml);
while (notifyData.counter > 0)
{
notifyData.pending = PR_TRUE;
PR_NotifyCondVar(notifyData.child);
while (notifyData.pending)
PR_WaitCondVar(notifyData.parent, PR_INTERVAL_NO_TIMEOUT);
}
PR_Unlock(notifyData.ml);
timein = PR_IntervalNow();
(void)PR_JoinThread(thread);
PR_DestroyCondVar(notifyData.child);
PR_DestroyCondVar(notifyData.parent);
PR_DestroyLock(notifyData.ml);
overhead += (PR_IntervalNow() - timein); /* more overhead */
return overhead;
} /* ConditionNotify */
static PRIntervalTime Alarms2(PRUint32 loops)
{
PRStatus rv;
PRAlarm *alarm;
PRIntervalTime overhead, timein = PR_IntervalNow();
AlarmData ad;
PRIntervalTime duration = PR_SecondsToInterval(30);
PRLock *ml = PR_NewLock();
PRCondVar *cv = PR_NewCondVar(ml);
ad.ml = ml;
ad.cv = cv;
ad.rate = 1;
ad.times = loops;
ad.late = ad.times = 0;
ad.duration = duration;
ad.timein = PR_IntervalNow();
ad.period = PR_SecondsToInterval(1);
alarm = PR_CreateAlarm();
(void)PR_SetAlarm(
alarm, ad.period, ad.rate, AlarmFn2, &ad);
overhead = PR_IntervalNow() - timein;
PR_Lock(ml);
while ((PRIntervalTime)(PR_IntervalNow() - ad.timein) < duration)
PR_WaitCondVar(cv, PR_INTERVAL_NO_TIMEOUT);
PR_Unlock(ml);
timein = PR_IntervalNow();
rv = PR_DestroyAlarm(alarm);
if (rv != PR_SUCCESS)
{
if (!debug_mode)
failed_already=1;
else
printf("***Destroying alarm status: FAIL\n");
}
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
overhead += (PR_IntervalNow() - timein);
return duration + overhead;
} /* Alarms2 */
nsresult
TimerThread::InitLocks()
{
NS_ASSERTION(!mLock, "InitLocks called twice?");
mLock = PR_NewLock();
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mCondVar = PR_NewCondVar(mLock);
if (!mCondVar)
return NS_ERROR_OUT_OF_MEMORY;
return NS_OK;
}
/*
* Allocate and initialize the event queue structures.
*/
static PRStatus
eq_create(void)
{
PR_ASSERT(NULL == eq->eq_lock);
if ((eq->eq_lock = PR_NewLock()) == NULL) {
slapi_log_error(SLAPI_LOG_FATAL, NULL, "eq_start PR_NewLock failed\n");
exit(1);
}
if ((eq->eq_cv = PR_NewCondVar(eq->eq_lock)) == NULL) {
slapi_log_error(SLAPI_LOG_FATAL, NULL, "eq_start PR_NewCondVar failed\n");
exit(1);
}
if ((ss_lock = PR_NewLock()) == NULL) {
slapi_log_error(SLAPI_LOG_FATAL, NULL, "eq_start PR_NewLock failed\n");
exit(1);
}
if ((ss_cv = PR_NewCondVar(ss_lock)) == NULL) {
slapi_log_error(SLAPI_LOG_FATAL, NULL, "eq_start PR_NewCondVar failed\n");
exit(1);
}
eq->eq_queue = NULL;
eq_initialized = 1;
return PR_SUCCESS;
}
nsresult nsHTTPListener::InitLocks()
{
mLock = PR_NewLock();
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
mCondition = PR_NewCondVar(mLock);
if (!mCondition)
{
PR_DestroyLock(mLock);
mLock = nsnull;
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
static PRStatus
init_blinding_params_list(void)
{
blindingParamsList.lock = PZ_NewLock(nssILockOther);
if (!blindingParamsList.lock) {
PORT_SetError(SEC_ERROR_NO_MEMORY);
return PR_FAILURE;
}
blindingParamsList.cVar = PR_NewCondVar( blindingParamsList.lock );
if (!blindingParamsList.cVar) {
PORT_SetError(SEC_ERROR_NO_MEMORY);
return PR_FAILURE;
}
blindingParamsList.waitCount = 0;
PR_INIT_CLIST(&blindingParamsList.head);
return PR_SUCCESS;
}