NSAPI_PUBLIC int systhread_newkey()
{
uintn newkey;
PR_NewThreadPrivateIndex(&newkey, NULL);
return (newkey);
}
nsresult
nsThreadManager::Init()
{
mLock = PR_NewLock();
if (!mLock)
return NS_ERROR_OUT_OF_MEMORY;
if (!mThreadsByPRThread.Init())
return NS_ERROR_OUT_OF_MEMORY;
if (PR_NewThreadPrivateIndex(&mCurThreadIndex, ReleaseObject) == PR_FAILURE)
return NS_ERROR_FAILURE;
// Setup "main" thread
mMainThread = new nsThread();
if (!mMainThread)
return NS_ERROR_OUT_OF_MEMORY;
nsresult rv = mMainThread->InitCurrentThread();
if (NS_FAILED(rv)) {
mMainThread = nsnull;
return rv;
}
// We need to keep a pointer to the current thread, so we can satisfy
// GetIsMainThread calls that occur post-Shutdown.
mMainThread->GetPRThread(&mMainPRThread);
mInitialized = PR_TRUE;
return NS_OK;
}
/*
* mempool_init creates NSPR thread private index,
* then allocates per-thread-private.
* mempool is initialized at the first mempool_return
*/
static void
mempool_init(struct mempool **my_mempool)
{
int i;
if (NULL == my_mempool) {
return;
}
#ifdef SHARED_MEMPOOL
for (i = 0; MEMPOOL_END != mempool[i].mempool_name; i++) {
mempool[i].mempool_mutex = PR_NewLock();
if (NULL == mempool[i].mempool_mutex) {
PRErrorCode ec = PR_GetError();
slapi_log_err(SLAPI_LOG_ERR, "mempool", "mempool_init: "
"failed to create mutex - (%d - %s); mempool(%s) is disabled",
ec, slapd_pr_strerror(ec), mempool[i].mempool_name);
rc = LDAP_OPERATIONS_ERROR;
}
}
#else
PR_NewThreadPrivateIndex (&mempool_index, mempool_destroy);
*my_mempool = (struct mempool *)slapi_ch_calloc(MAX_MEMPOOL, sizeof(struct mempool));
for (i = 0; i < MAX_MEMPOOL; i++) {
(*my_mempool)[i].mempool_name = mempool_names[i];
}
#endif
}
// static
XPCPerThreadData*
XPCPerThreadData::GetDataImpl(JSContext *cx)
{
XPCPerThreadData* data;
if(!gLock)
{
gLock = PR_NewLock();
if(!gLock)
return nsnull;
}
if(gTLSIndex == BAD_TLS_INDEX)
{
nsAutoLock lock(gLock);
// check again now that we have the lock...
if(gTLSIndex == BAD_TLS_INDEX)
{
if(PR_FAILURE ==
PR_NewThreadPrivateIndex(&gTLSIndex, xpc_ThreadDataDtorCB))
{
NS_ERROR("PR_NewThreadPrivateIndex failed!");
gTLSIndex = BAD_TLS_INDEX;
return nsnull;
}
}
}
data = (XPCPerThreadData*) PR_GetThreadPrivate(gTLSIndex);
if(!data)
{
data = new XPCPerThreadData();
if(!data || !data->IsValid())
{
NS_ERROR("new XPCPerThreadData() failed!");
if(data)
delete data;
return nsnull;
}
if(PR_FAILURE == PR_SetThreadPrivate(gTLSIndex, data))
{
NS_ERROR("PR_SetThreadPrivate failed!");
delete data;
return nsnull;
}
}
if(cx && !sMainJSThread && NS_IsMainThread())
{
sMainJSThread = cx->thread;
sMainThreadData = data;
sMainThreadData->mThread = PR_GetCurrentThread();
}
return data;
}
void
nsTraceRefcnt::SetActivityIsLegal(bool aLegal)
{
if (gActivityTLS == BAD_TLS_INDEX) {
PR_NewThreadPrivateIndex(&gActivityTLS, nullptr);
}
PR_SetThreadPrivate(gActivityTLS, reinterpret_cast<void*>(!aLegal));
}
void Logger::logInitialize(LogLevel level)
{
PRStatus rv;
_logLock = PR_NewLock();
rv = PR_NewThreadPrivateIndex(&_threadNameKey, NULL);
PR_ASSERT(rv == PR_SUCCESS);
_logLevel = level;
};
void
nsTraceRefcntImpl::SetActivityIsLegal(bool aLegal)
{
#ifdef NS_IMPL_REFCNT_LOGGING
if (gActivityTLS == BAD_TLS_INDEX)
PR_NewThreadPrivateIndex(&gActivityTLS, nullptr);
PR_SetThreadPrivate(gActivityTLS, NS_INT32_TO_PTR(!aLegal));
#endif
}
void
nsTraceRefcnt::SetActivityIsLegal(bool aLegal)
{
#ifdef NS_IMPL_REFCNT_LOGGING
if (gActivityTLS == BAD_TLS_INDEX) {
PR_NewThreadPrivateIndex(&gActivityTLS, nullptr);
}
PR_SetThreadPrivate(gActivityTLS, reinterpret_cast<void*>(!aLegal));
#endif
}
// Must be single-threaded here, early in primordial thread.
static void InitAutoLockStatics()
{
(void) PR_NewThreadPrivateIndex(&LockStackTPI, 0);
OrderTable = PL_NewHashTable(64, _hash_pointer,
PL_CompareValues, PL_CompareValues,
&_hash_alloc_ops, 0);
if (OrderTable && !(OrderTableLock = PR_NewLock())) {
PL_HashTableDestroy(OrderTable);
OrderTable = 0;
}
PR_CSetOnMonitorRecycle(OnSemaphoreRecycle);
}
static PRStatus
prldap_init_tpd( void )
{
if (( prldap_map_mutex = PR_NewLock()) == NULL || PR_NewThreadPrivateIndex(
&prldap_tpdindex, prldap_tsd_destroy ) != PR_SUCCESS ) {
return( PR_FAILURE );
}
prldap_map_list = NULL;
return( PR_SUCCESS );
}
//-------------------------------------------------------------------------
//
// Return the nsIToolkit for the current thread. If a toolkit does not
// yet exist, then one will be created...
//
//-------------------------------------------------------------------------
NS_METHOD NS_GetCurrentToolkit(nsIToolkit* *aResult)
{
nsIToolkit* toolkit = nsnull;
nsresult rv = NS_OK;
PRStatus status;
#ifdef DEBUG
printf("TK-GetCTK\n");
#endif
// Create the TLS index the first time through...
if (0 == gToolkitTLSIndex)
{
status = PR_NewThreadPrivateIndex(&gToolkitTLSIndex, NULL);
if (PR_FAILURE == status)
{
rv = NS_ERROR_FAILURE;
}
}
if (NS_SUCCEEDED(rv))
{
toolkit = (nsIToolkit*)PR_GetThreadPrivate(gToolkitTLSIndex);
//
// Create a new toolkit for this thread...
//
if (!toolkit)
{
toolkit = new nsToolkit();
if (!toolkit)
{
rv = NS_ERROR_OUT_OF_MEMORY;
}
else
{
NS_ADDREF(toolkit);
toolkit->Init(PR_GetCurrentThread());
//
// The reference stored in the TLS is weak. It is removed in the
// nsToolkit destructor...
//
PR_SetThreadPrivate(gToolkitTLSIndex, (void*)toolkit);
}
}
else
{
NS_ADDREF(toolkit);
}
*aResult = toolkit;
}
return rv;
}
JSBool
js_InitThreadPrivateIndex(void (JS_DLL_CALLBACK *ptr)(void *))
{
PRStatus status;
if (tpIndexInited)
return JS_TRUE;
status = PR_NewThreadPrivateIndex(&threadTPIndex, ptr);
if (status == PR_SUCCESS)
tpIndexInited = JS_TRUE;
return status == PR_SUCCESS;
}
void pyxpcom_construct(void)
{
g_lockMain = PR_NewLock();
#ifndef PYXPCOM_USE_PYGILSTATE
PRStatus status;
status = PR_NewThreadPrivateIndex( &tlsIndex, NULL );
NS_WARN_IF_FALSE(status==0, "Could not allocate TLS storage");
if (NS_FAILED(status)) {
PR_DestroyLock(g_lockMain);
return; // PR_FALSE;
}
#endif // PYXPCOM_USE_PYGILSTATE
return; // PR_TRUE;
}
PRStatus TimelineInit(void)
{
char *timeStr;
char *fileName;
PRInt32 secs, msecs;
PRFileDesc *fd;
PRInt64 tmp1, tmp2;
PRStatus status = PR_NewThreadPrivateIndex( &gTLSIndex, ThreadDestruct );
NS_WARN_IF_FALSE(status==0, "TimelineService could not allocate TLS storage.");
timeStr = PR_GetEnv("NS_TIMELINE_INIT_TIME");
#ifdef XP_MAC
initInterval = PR_IntervalNow();
#endif
// NS_TIMELINE_INIT_TIME only makes sense for the main thread, so if it
// exists, set it there. If not, let normal thread management code take
// care of setting the init time.
if (timeStr != NULL && 2 == PR_sscanf(timeStr, "%d.%d", &secs, &msecs)) {
PRTime &initTime = GetThisThreadData()->initTime;
LL_MUL(tmp1, (PRInt64)secs, 1000000);
LL_MUL(tmp2, (PRInt64)msecs, 1000);
LL_ADD(initTime, tmp1, tmp2);
#ifdef XP_MAC
initInterval -= PR_MicrosecondsToInterval(
(PRUint32)(PR_Now() - initTime));
#endif
}
// Get the log file.
#ifdef XP_MAC
fileName = "timeline.txt";
#else
fileName = PR_GetEnv("NS_TIMELINE_LOG_FILE");
#endif
if (fileName != NULL
&& (fd = PR_Open(fileName, PR_WRONLY | PR_CREATE_FILE | PR_TRUNCATE,
0666)) != NULL) {
timelineFD = fd;
PR_fprintf(fd,
"NOTE: due to asynchrony, the indentation that you see does"
" not necessarily correspond to nesting in the code.\n\n");
}
// Runtime disable of timeline
if (PR_GetEnv("NS_TIMELINE_ENABLE"))
gTimelineDisabled = PR_FALSE;
return PR_SUCCESS;
}
// static
void Init()
{
#ifdef MOZ_VISUAL_EVENT_TRACER
const char * logFile = PR_GetEnv("MOZ_PROFILING_FILE");
if (!logFile || !*logFile)
return;
gLogFilePath = logFile;
const char * logEvents = PR_GetEnv("MOZ_PROFILING_EVENTS");
if (logEvents && *logEvents)
gEventFilter = EventFilter::Build(logEvents);
gProfilerStart = mozilla::TimeStamp::Now();
PRStatus status = PR_NewThreadPrivateIndex(&gThreadPrivateIndex,
&RecordBatch::FlushBatch);
if (status != PR_SUCCESS)
return;
gMonitor = new mozilla::Monitor("Profiler");
if (!gMonitor)
return;
gFlushingThread = PR_CreateThread(PR_USER_THREAD,
&FlushingThread,
nsnull,
PR_PRIORITY_LOW,
PR_LOCAL_THREAD,
PR_JOINABLE_THREAD,
32768);
if (!gFlushingThread)
return;
gInitialized = true;
MOZ_EVENT_TRACER_NAME_OBJECT(gFlushingThread, "Profiler");
MOZ_EVENT_TRACER_MARK(gFlushingThread, "Profiling Start");
#endif
}
nsExceptionService::nsExceptionService()
: mProviders(4, PR_TRUE) /* small, thread-safe hashtable */
{
#ifdef NS_DEBUG
if (PR_AtomicIncrement(&totalInstances)!=1) {
NS_ERROR("The nsExceptionService is a singleton!");
}
#endif
/* member initializers and constructor code */
if (tlsIndex == BAD_TLS_INDEX) {
PRStatus status;
status = PR_NewThreadPrivateIndex( &tlsIndex, ThreadDestruct );
NS_ASSERTION(status==0, "ScriptErrorService could not allocate TLS storage.");
}
lock = PR_NewLock();
NS_ASSERTION(lock, "Error allocating ExceptionService lock");
// observe XPCOM shutdown.
nsCOMPtr<nsIObserverService> observerService =
mozilla::services::GetObserverService();
NS_ASSERTION(observerService, "Could not get observer service!");
if (observerService)
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
}
/*
* error_once_function
*
* This is the once-called callback.
*/
static PRStatus
error_once_function ( void)
{
return PR_NewThreadPrivateIndex(&error_stack_index, PR_Free);
}
ThreadLocalStorage(PRThreadPrivateDTOR dtor) : mIndex(0), mValid(PR_FALSE)
{
mValid = (PR_NewThreadPrivateIndex(&mIndex, dtor) == PR_SUCCESS);
}
static PRIntn PR_CALLBACK Tpd(PRIntn argc, char **argv)
{
void *pd;
PRStatus rv;
PRUintn keys;
PRThread *thread;
char *key_string[] = {
"Key #0", "Key #1", "Key #2", "Key #3",
"Bogus #5", "Bogus #6", "Bogus #7", "Bogus #8"};
fout = PR_STDOUT;
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_NewThreadPrivateIndex(&key[keys], Destructor);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 8; ++keys)
{
pd = PR_GetThreadPrivate(key[keys]);
MY_ASSERT(NULL == pd);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
for (keys = 4; keys < 8; ++keys)
key[keys] = 4096; /* set to invalid value */
did = should = PR_FALSE;
for (keys = 4; keys < 8; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_FAILURE == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], key_string[keys]);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 0; keys < 4; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_NewThreadPrivateIndex(&key[keys], Destructor);
MY_ASSERT(PR_SUCCESS == rv);
rv = PR_SetThreadPrivate(key[keys], "EXTENSION");
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = PR_FALSE; should = PR_TRUE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
PrintProgress(__LINE__);
did = should = PR_FALSE;
for (keys = 8; keys < 127; ++keys)
{
rv = PR_SetThreadPrivate(key[keys], NULL);
MY_ASSERT(PR_SUCCESS == rv);
}
thread = PR_CreateThread(
PR_USER_THREAD, Thread, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
(void)PR_JoinThread(thread);
PrintProgress(__LINE__);
#if defined(WIN16)
printf(
"%s\n",((PR_TRUE == failed) ? "FAILED" : "PASSED"));
#else
(void)PR_fprintf(
fout, "%s\n",((PR_TRUE == failed) ? "FAILED" : "PASSED"));
#endif
return 0;
} /* Tpd */
PRStatus RCThread::NewPrivateIndex(PRUintn* index)
{ return PR_NewThreadPrivateIndex(index, _tpd_dtor); }
int main(int argc, char **argv)
#endif
{
PRUintn pdkey;
PRStatus status;
char *path = NULL;
PRDir *dir = NULL;
PRLock *ml = NULL;
PRCondVar *cv = NULL;
PRThread *thread = NULL;
PRIntervalTime interval = 0;
PRFileDesc *file, *udp, *tcp, *pair[2];
PRIntn test;
if ( argc < 2)
{
test = 0;
}
else
test = atoi(argv[1]);
switch (test)
{
case 0: ml = PR_NewLock();
break;
case 1: interval = PR_SecondsToInterval(1);
break;
case 2: thread = PR_CreateThread(
PR_USER_THREAD, lazyEntry, NULL, PR_PRIORITY_NORMAL,
PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0);
break;
case 3: file = PR_Open("/usr/tmp/", PR_RDONLY, 0);
break;
case 4: udp = PR_NewUDPSocket();
break;
case 5: tcp = PR_NewTCPSocket();
break;
case 6: dir = PR_OpenDir("/usr/tmp/");
break;
case 7: (void)PR_NewThreadPrivateIndex(&pdkey, NULL);
break;
case 8: path = PR_GetEnv("PATH");
break;
case 9: status = PR_NewTCPSocketPair(pair);
break;
case 10: PR_SetConcurrency(2);
break;
default:
printf(
"lazyinit: unrecognized command line argument: %s\n",
argv[1] );
printf( "FAIL\n" );
exit( 1 );
break;
} /* switch() */
return 0;
} /* Lazy */
static PRStatus session_thread_init(void)
{
_session_thread_lock = PR_NewLock();
PR_NewThreadPrivateIndex(&_session_thread_key, NULL);
return PR_SUCCESS;
}
