void _PR_CleanupLayerCache(void)
{
if (identity_cache.ml)
{
PR_DestroyLock(identity_cache.ml);
identity_cache.ml = NULL;
}
if (identity_cache.name)
{
PRDescIdentity ident;
for (ident = 0; ident <= identity_cache.ident; ident++)
PR_DELETE(identity_cache.name[ident]);
PR_DELETE(identity_cache.name);
}
} /* _PR_CleanupLayerCache */
void
destroy_thread_data(GlobalThreadMgr *threadMGR)
{
PORT_Memset(threadMGR->threads, 0, sizeof(threadMGR->threads));
if (threadMGR->threadEndQ) {
PR_DestroyCondVar(threadMGR->threadEndQ);
threadMGR->threadEndQ = NULL;
}
if (threadMGR->threadStartQ) {
PR_DestroyCondVar(threadMGR->threadStartQ);
threadMGR->threadStartQ = NULL;
}
if (threadMGR->threadLock) {
PR_DestroyLock(threadMGR->threadLock);
threadMGR->threadLock = NULL;
}
}
static void
_PR_CleanupBeforeExit(void)
{
/*
Do not make any calls here other than to destroy resources. For example,
do not make any calls that eventually may end up in PR_Lock. Because the
thread is destroyed, can not access current thread any more.
*/
_PR_CleanupTPD();
if (_pr_terminationCVLock)
/*
* In light of the comment above, this looks real suspicious.
* I'd go so far as to say it's just a problem waiting to happen.
*/
PR_DestroyLock(_pr_terminationCVLock);
_PR_MD_CLEANUP_BEFORE_EXIT();
}
/* Global cleanup */
void Curl_nss_cleanup(void)
{
/* This function isn't required to be threadsafe and this is only done
* as a safety feature.
*/
PR_Lock(nss_initlock);
if (initialized) {
if(mod)
SECMOD_DestroyModule(mod);
mod = NULL;
NSS_Shutdown();
}
PR_Unlock(nss_initlock);
PR_DestroyLock(nss_initlock);
nss_initlock = NULL;
initialized = 0;
}
PR_IMPLEMENT(PRStatus) PR_DestroyAlarm(PRAlarm *alarm)
{
PRStatus rv;
PR_Lock(alarm->lock);
alarm->state = alarm_inactive;
rv = PR_NotifyCondVar(alarm->cond);
PR_Unlock(alarm->lock);
if (rv == PR_SUCCESS)
rv = PR_JoinThread(alarm->notifier);
if (rv == PR_SUCCESS)
{
PR_DestroyCondVar(alarm->cond);
PR_DestroyLock(alarm->lock);
PR_DELETE(alarm);
}
return rv;
} /* PR_DestroyAlarm */
void
nsHttp::DestroyAtomTable()
{
if (sAtomTable.ops) {
PL_DHashTableFinish(&sAtomTable);
sAtomTable.ops = nsnull;
}
while (sHeapAtoms) {
HttpHeapAtom *next = sHeapAtoms->next;
free(sHeapAtoms);
sHeapAtoms = next;
}
if (sLock) {
PR_DestroyLock(sLock);
sLock = nsnull;
}
}
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;
}
static PRIntn PR_CALLBACK RealMain( PRIntn argc, char **argv )
{
PLOptStatus os;
PLOptState *opt = PL_CreateOptState(argc, argv, "dhlmc");
PRBool locks = PR_FALSE, monitors = PR_FALSE, cmonitors = PR_FALSE;
err = PR_GetSpecialFD(PR_StandardError);
while (PL_OPT_EOL != (os = PL_GetNextOpt(opt)))
{
if (PL_OPT_BAD == os) continue;
switch (opt->option)
{
case 'd': /* debug mode (noop) */
break;
case 'l': /* locks */
locks = PR_TRUE;
break;
case 'm': /* monitors */
monitors = PR_TRUE;
break;
case 'c': /* cached monitors */
cmonitors = PR_TRUE;
break;
case 'h': /* needs guidance */
default:
Help();
return 2;
}
}
PL_DestroyOptState(opt);
ml = PR_NewLock();
if (locks) T1Lock();
if (monitors) T1Mon();
if (cmonitors) T1CMon();
PR_DestroyLock(ml);
PR_fprintf(err, "Done!\n");
return 0;
} /* main */
static PRIntervalTime ContentiousLock(PRUint32 loops)
{
PRStatus status;
PRThread *thread = NULL;
LockContentious_t * contention;
PRIntervalTime rv, overhead, timein = PR_IntervalNow();
contention = PR_NEWZAP(LockContentious_t);
contention->loops = loops;
contention->overhead = 0;
contention->ml = PR_NewLock();
contention->interval = contention_interval;
thread = PR_CreateThread(
PR_USER_THREAD, LockContender, contention,
PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
PR_ASSERT(thread != NULL);
overhead = PR_IntervalNow() - timein;
while (contention->loops-- > 0)
{
PR_Lock(contention->ml);
PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(contention->ml);
contention->contentious+= 1;
contention->overhead += contention->interval;
PR_Sleep(contention->interval);
PR_ASSERT_CURRENT_THREAD_OWNS_LOCK(contention->ml);
PR_Unlock(contention->ml);
}
timein = PR_IntervalNow();
status = PR_JoinThread(thread);
PR_DestroyLock(contention->ml);
overhead += (PR_IntervalNow() - timein);
rv = overhead + contention->overhead;
if (verbosity)
PR_fprintf(
std_err, "Access ratio: %u to %u\n",
contention->contentious, contention->contender);
PR_Free(contention);
return rv;
} /* ContentiousLock */
void _PR_CleanupIO(void)
{
PR_FreeFileDesc(_pr_stdin);
_pr_stdin = NULL;
PR_FreeFileDesc(_pr_stdout);
_pr_stdout = NULL;
PR_FreeFileDesc(_pr_stderr);
_pr_stderr = NULL;
if (_pr_flock_cv) {
PR_DestroyCondVar(_pr_flock_cv);
_pr_flock_cv = NULL;
}
if (_pr_flock_lock) {
PR_DestroyLock(_pr_flock_lock);
_pr_flock_lock = NULL;
}
_PR_CleanupFdCache();
}
DNSSession :: ~ DNSSession()
{
//PR_ASSERT(awake);
PR_DestroyCondVar(cvar);
PR_DestroyLock(lock);
hostname = "grmblll";
free_packet_list();
PRInt32 host_cnt = 0;
while (re_he.h_addr_list[host_cnt])
{
free(re_he.h_addr_list[host_cnt++]);
}
if (re_he.h_name)
{
free(re_he.h_name);
}
ar_free_hostent(&ar_host, 0);
}
XPCPerThreadData::~XPCPerThreadData()
{
/* Be careful to ensure that both any update to |gThreads| and the
decision about whether or not to destroy the lock, are done
atomically. See bug 557586. */
PRBool doDestroyLock = PR_FALSE;
MOZ_COUNT_DTOR(xpcPerThreadData);
Cleanup();
// Unlink 'this' from the list of threads.
if(gLock)
{
nsAutoLock lock(gLock);
if(gThreads == this)
gThreads = mNextThread;
else
{
XPCPerThreadData* cur = gThreads;
while(cur)
{
if(cur->mNextThread == this)
{
cur->mNextThread = mNextThread;
break;
}
cur = cur->mNextThread;
}
}
if (!gThreads)
doDestroyLock = PR_TRUE;
}
if(gLock && doDestroyLock)
{
PR_DestroyLock(gLock);
gLock = nsnull;
}
}
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 */
/*
* Add the given pblock to the list of outstanding persistent searches.
* Then, start a thread to send the results to the client as they
* are dispatched by add, modify, and modrdn operations.
*/
void
ps_add( Slapi_PBlock *pb, ber_int_t changetypes, int send_entchg_controls )
{
PSearch *ps;
if ( PS_IS_INITIALIZED() && NULL != pb ) {
/* Create the new node */
ps = psearch_alloc();
ps->ps_pblock = pb;
ps->ps_changetypes = changetypes;
ps->ps_send_entchg_controls = send_entchg_controls;
/* Add it to the head of the list of persistent searches */
ps_add_ps( ps );
/* Start a thread to send the results */
ps->ps_tid = PR_CreateThread( PR_USER_THREAD, ps_send_results,
(void *) ps, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD,
PR_UNJOINABLE_THREAD, SLAPD_DEFAULT_THREAD_STACKSIZE );
/* Checking if the thread is succesfully created and
* if the thread is not created succesfully.... we send
* error messages to the Log file
*/
if(NULL == (ps->ps_tid)){
int prerr;
prerr = PR_GetError();
LDAPDebug(LDAP_DEBUG_ANY,"persistent search PR_CreateThread()failed in the "
"ps_add function: " SLAPI_COMPONENT_NAME_NSPR " error %d (%s)\n",
prerr, slapd_pr_strerror(prerr), 0);
/* Now remove the ps from the list so call the function ps_remove */
ps_remove(ps);
PR_DestroyLock ( ps->ps_lock );
ps->ps_lock = NULL;
slapi_ch_free((void **) &ps->ps_pblock );
slapi_ch_free((void **) &ps );
}
}
}
/*
* pagedresults_cleanup_all frees the list.
* return values
* 0: not a simple paged result connection
* 1: simple paged result and successfully abandoned
*/
int
pagedresults_cleanup_all(Connection *conn, int needlock)
{
int rc = 0;
int i;
PagedResults *prp = NULL;
slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_cleanup_all", "=>\n");
if (NULL == conn) {
slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_cleanup_all", "<= Connection is NULL\n");
return 0;
}
if (needlock) {
PR_EnterMonitor(conn->c_mutex);
}
for (i = 0; conn->c_pagedresults.prl_list &&
i < conn->c_pagedresults.prl_maxlen; i++) {
prp = conn->c_pagedresults.prl_list + i;
if (prp->pr_mutex) {
PR_DestroyLock(prp->pr_mutex);
}
if (prp->pr_current_be && prp->pr_search_result_set &&
prp->pr_current_be->be_search_results_release) {
prp->pr_current_be->be_search_results_release(&(prp->pr_search_result_set));
rc = 1;
}
prp->pr_current_be = NULL;
}
slapi_ch_free((void **)&conn->c_pagedresults.prl_list);
conn->c_pagedresults.prl_maxlen = 0;
conn->c_pagedresults.prl_count = 0;
if (needlock) {
PR_ExitMonitor(conn->c_mutex);
}
slapi_log_err(SLAPI_LOG_TRACE, "pagedresults_cleanup_all", "<= %d\n", rc);
return rc;
}
void _PR_LogCleanup(void)
{
PRLogModuleInfo *lm = logModules;
PR_LogFlush();
#ifdef _PR_USE_STDIO_FOR_LOGGING
if (logFile
&& logFile != stdout
&& logFile != stderr
#ifdef XP_PC
&& logFile != WIN32_DEBUG_FILE
#endif
) {
fclose(logFile);
}
#else
if (logFile && logFile != _pr_stdout && logFile != _pr_stderr) {
PR_Close(logFile);
}
#endif
logFile = NULL;
if (logBuf)
PR_DELETE(logBuf);
while (lm != NULL) {
PRLogModuleInfo *next = lm->next;
free((/*const*/ char *)lm->name);
PR_Free(lm);
lm = next;
}
logModules = NULL;
if (_pr_logLock) {
PR_DestroyLock(_pr_logLock);
_pr_logLock = NULL;
}
}
void
terminateWorkerThreads(void)
{
VLOG(("selfserv: server_thead: waiting on stopping"));
PZ_Lock(qLock);
PZ_NotifyAllCondVar(jobQNotEmptyCv);
while (threadCount > 0) {
PZ_WaitCondVar(threadCountChangeCv, PR_INTERVAL_NO_TIMEOUT);
}
/* The worker threads empty the jobQ before they terminate. */
PORT_Assert(PR_CLIST_IS_EMPTY(&jobQ));
PZ_Unlock(qLock);
DESTROY_CONDVAR(jobQNotEmptyCv);
DESTROY_CONDVAR(freeListNotEmptyCv);
DESTROY_CONDVAR(threadCountChangeCv);
PR_DestroyLock(lastLoadedCrlLock);
DESTROY_LOCK(qLock);
PR_Free(jobTable);
PR_Free(threads);
}
static PRIntervalTime Alarms1(PRUint32 loops)
{
PRAlarm *alarm;
AlarmData ad;
PRIntervalTime overhead, timein = PR_IntervalNow();
PRIntervalTime duration = PR_SecondsToInterval(3);
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, AlarmFn1, &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();
(void)PR_DestroyAlarm(alarm);
PR_DestroyCondVar(cv);
PR_DestroyLock(ml);
overhead += (PR_IntervalNow() - timein);
return duration + overhead;
} /* Alarms1 */
nsConsoleService::~nsConsoleService()
{
PRUint32 i = 0;
while (i < mBufferSize && mMessages[i] != nsnull) {
NS_RELEASE(mMessages[i]);
i++;
}
#ifdef DEBUG_mccabe
if (mListeners.Count() != 0) {
fprintf(stderr,
"WARNING - %d console error listeners still registered!\n"
"More calls to nsIConsoleService::UnregisterListener needed.\n",
mListeners.Count());
}
#endif
if (mMessages)
nsMemory::Free(mMessages);
if (mLock)
PR_DestroyLock(mLock);
}
npAPInsIInputStreamShim::~npAPInsIInputStreamShim()
{
this->doLock();
DoClose();
mPlugletListener = nsnull;
mStreamInfo = nsnull;
NPN_MemFree(mBuffer);
mBuffer = nsnull;
mBufferLength = 0;
this->doUnlock();
mAvailableForPluglet = 0;
mNumWrittenFromPluginHost = 0;
mDoClose = PR_TRUE;
mDidClose = PR_TRUE;
PR_DestroyLock(mLock);
mLock = nsnull;
}
// nsIBaseWindow
NS_IMETHODIMP nsWebShellWindow::Destroy()
{
nsresult rv;
nsCOMPtr<nsIWebProgress> webProgress(do_GetInterface(mDocShell, &rv));
if (webProgress) {
webProgress->RemoveProgressListener(this);
}
nsCOMPtr<nsIXULWindow> kungFuDeathGrip(this);
if (mSPTimerLock) {
PR_Lock(mSPTimerLock);
if (mSPTimer) {
mSPTimer->Cancel();
SavePersistentAttributes();
mSPTimer = nsnull;
NS_RELEASE_THIS(); // the timer held a reference to us
}
PR_Unlock(mSPTimerLock);
PR_DestroyLock(mSPTimerLock);
mSPTimerLock = nsnull;
}
return nsXULWindow::Destroy();
}
/**
* Destructs processor.
*/
TPS_PUBLIC HttpConnection::~HttpConnection ()
{
if( m_clientnickname != NULL ) {
PL_strfree( m_clientnickname );
m_clientnickname = NULL;
}
if( m_Id != NULL ) {
PL_strfree( m_Id );
m_Id = NULL;
}
if( m_failoverList != NULL ) {
delete m_failoverList;
m_failoverList = NULL;
}
if( m_headers != NULL ) {
delete m_headers;
m_headers = NULL;
}
if( m_lock != NULL ) {
PR_DestroyLock( m_lock );
m_lock = NULL;
}
}
PR_IMPLEMENT(PRAlarm*) PR_CreateAlarm(void)
{
PRAlarm *alarm = PR_NEWZAP(PRAlarm);
if (alarm != NULL)
{
if ((alarm->lock = PR_NewLock()) == NULL) goto done;
if ((alarm->cond = PR_NewCondVar(alarm->lock)) == NULL) goto done;
alarm->state = alarm_active;
PR_INIT_CLIST(&alarm->timers);
alarm->notifier = PR_CreateThread(
PR_USER_THREAD, pr_alarmNotifier, alarm,
PR_GetThreadPriority(PR_GetCurrentThread()),
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
if (alarm->notifier == NULL) goto done;
}
return alarm;
done:
if (alarm->cond != NULL) PR_DestroyCondVar(alarm->cond);
if (alarm->lock != NULL) PR_DestroyLock(alarm->lock);
PR_DELETE(alarm);
return NULL;
} /* CreateAlarm */
PR_IMPLEMENT(PRStatus) PR_DestroyWaitGroup(PRWaitGroup *group)
{
PRStatus rv = PR_SUCCESS;
if (NULL == group) group = mw_state->group;
PR_ASSERT(NULL != group);
if (NULL != group)
{
if (_prmw_stopped != group->state) /* quick, unsafe test */
{
PRMWGroupState mws;
/* One shot to correct the situation */
PR_Lock(group->ml);
if (group->state < _prmw_stopped) /* safer test */
group->state = _prmw_stopping;
mws = MW_TestForShutdownInternal(group);
PR_Unlock(group->ml);
if (_prmw_stopped != mws) /* quick test again */
{
PR_SetError(PR_INVALID_STATE_ERROR, 0);
return PR_FAILURE;
}
}
PR_Lock(mw_lock);
PR_REMOVE_LINK(&group->group_link);
PR_Unlock(mw_lock);
PR_DELETE(group->waiter);
PR_DestroyCondVar(group->new_business);
PR_DestroyCondVar(group->io_complete);
PR_DestroyCondVar(group->io_taken);
PR_DestroyLock(group->ml);
if (group == mw_state->group) mw_state->group = NULL;
PR_DELETE(group);
}
return rv;
} /* PR_DestroyWaitGroup */
InputStreamShim::~InputStreamShim()
{
JNIEnv *env = (JNIEnv *) JNU_GetEnv(gVm, JNI_VERSION);
::util_DeleteGlobalRef(env, mJavaStream);
mJavaStream = nsnull;
mContentLength = -1;
PR_Lock(mLock);
delete [] mBuffer;
mBuffer = nsnull;
mBufferLength = 0;
PR_Unlock(mLock);
mAvailable = 0;
mAvailableForMozilla = 0;
mNumRead = 0;
mDoClose = PR_TRUE;
mDidClose = PR_TRUE;
PR_DestroyLock(mLock);
mLock = nsnull;
}
/*
** Destroy a monitor. There must be no thread waiting on the monitor's
** condition variable. The caller is responsible for guaranteeing that the
** monitor is no longer in use.
*/
PR_IMPLEMENT(void) PR_DestroyMonitor(PRMonitor *mon)
{
PR_DestroyLock(mon->cvar->lock);
PR_DestroyCondVar(mon->cvar);
PR_DELETE(mon);
}
// destructor
//
nsLDAPModification::~nsLDAPModification()
{
if (mValuesLock) {
PR_DestroyLock(mValuesLock);
}
}
CMapiImp::~CMapiImp()
{
if (m_Lock)
PR_DestroyLock(m_Lock);
}
void
CondVarMixedTest(void *_arg)
{
PRInt32 arg = (PRInt32)_arg;
PRInt32 index, loops;
threadinfo *list;
PRLock *sharedlock;
PRCondVar *sharedcvar;
PRLock *exitlock;
PRCondVar *exitcvar;
PRInt32 *ptcount;
exitcount=0;
tcount=0;
list = (threadinfo *)PR_MALLOC(sizeof(threadinfo) * (arg * 4));
ptcount = (PRInt32 *)PR_CALLOC(sizeof(*ptcount) * (arg * 4));
sharedlock = PR_NewLock();
sharedcvar = PR_NewCondVar(sharedlock);
exitlock = PR_NewLock();
exitcvar = PR_NewCondVar(exitlock);
/* Create the threads */
for(index=0; index<arg*4; ) {
CreateTestThread(&list[index],
index,
sharedlock,
sharedcvar,
count,
PR_MillisecondsToInterval(50),
&tcount,
exitlock,
exitcvar,
&exitcount,
PR_TRUE,
PR_LOCAL_THREAD);
index++;
CreateTestThread(&list[index],
index,
sharedlock,
sharedcvar,
count,
PR_MillisecondsToInterval(50),
&tcount,
exitlock,
exitcvar,
&exitcount,
PR_TRUE,
PR_GLOBAL_THREAD);
index++;
list[index].lock = PR_NewLock();
list[index].cvar = PR_NewCondVar(list[index].lock);
CreateTestThread(&list[index],
index,
list[index].lock,
list[index].cvar,
count,
PR_MillisecondsToInterval(50),
ptcount,
exitlock,
exitcvar,
&exitcount,
PR_FALSE,
PR_LOCAL_THREAD);
index++;
ptcount++;
list[index].lock = PR_NewLock();
list[index].cvar = PR_NewCondVar(list[index].lock);
CreateTestThread(&list[index],
index,
list[index].lock,
list[index].cvar,
count,
PR_MillisecondsToInterval(50),
ptcount,
exitlock,
exitcvar,
&exitcount,
PR_FALSE,
PR_GLOBAL_THREAD);
index++;
ptcount++;
}
/* Notify every 3rd thread */
for (loops = 0; loops < count; loops++) {
/* Notify the threads */
for(index=0; index<(arg*4); index+=3) {
PR_Lock(list[index].lock);
*list[index].tcount++;
PR_NotifyCondVar(list[index].cvar);
PR_Unlock(list[index].lock);
}
/* Wait for threads to finish */
PR_Lock(exitlock);
while(exitcount < arg*4)
PR_WaitCondVar(exitcvar, PR_SecondsToInterval(60));
PR_ASSERT(exitcount >= arg*4);
exitcount -= arg*4;
PR_Unlock(exitlock);
}
/* Join all the threads */
for(index=0; index<(arg*4); index++) {
PR_JoinThread(list[index].thread);
if (list[index].internal) {
PR_Lock(list[index].lock);
PR_DestroyCondVar(list[index].cvar);
PR_Unlock(list[index].lock);
PR_DestroyLock(list[index].lock);
}
}
PR_DestroyCondVar(sharedcvar);
PR_DestroyLock(sharedlock);
PR_DELETE(list);
}
nsMAPIConfiguration::~nsMAPIConfiguration()
{
if (m_Lock)
PR_DestroyLock(m_Lock);
}
