/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /* ** File: ptthread.c ** Descritpion: Implemenation for threds using pthreds ** Exports: ptthread.h */ #if defined(_PR_PTHREADS) # include "prlog.h" # include "primpl.h" # include "prpdce.h" # include # include # include # include # include # if defined(OPENBSD) || defined(FREEBSD) || defined(DRAGONFLY) # include # endif # if defined(ANDROID) # include # endif # ifdef _PR_NICE_PRIORITY_SCHEDULING # undef _POSIX_THREAD_PRIORITY_SCHEDULING # include # ifndef HAVE_GETTID # define gettid() (syscall(SYS_gettid)) # endif # endif /* * Record whether or not we have the privilege to set the scheduling * policy and priority of threads. 0 means that privilege is available. * EPERM means that privilege is not available. */ static PRIntn pt_schedpriv = 0; extern PRLock* _pr_sleeplock; static struct _PT_Bookeeping { PRLock* ml; /* a lock to protect ourselves */ PRCondVar* cv; /* used to signal global things */ PRInt32 system, user; /* a count of the two different types */ PRUintn this_many; /* number of threads allowed for exit */ pthread_key_t key; /* thread private data key */ PRBool keyCreated; /* whether 'key' should be deleted */ PRThread *first, *last; /* list of threads we know about */ # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 PRInt32 minPrio, maxPrio; /* range of scheduling priorities */ # endif } pt_book = {0}; static void _pt_thread_death(void* arg); static void _pt_thread_death_internal(void* arg, PRBool callDestructors); static void init_pthread_gc_support(void); # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 static PRIntn pt_PriorityMap(PRThreadPriority pri) { # ifdef NTO /* This priority algorithm causes lots of problems on Neutrino * for now I have just hard coded everything to run at priority 10 * until I can come up with a new algorithm. * Jerry.Kirk@Nexwarecorp.com */ return 10; # else return pt_book.minPrio + pri * (pt_book.maxPrio - pt_book.minPrio) / PR_PRIORITY_LAST; # endif } # elif defined(_PR_NICE_PRIORITY_SCHEDULING) /* * This functions maps higher priorities to lower nice values relative to the * nice value specified in the |nice| parameter. The corresponding relative * adjustments are: * * PR_PRIORITY_LOW +1 * PR_PRIORITY_NORMAL 0 * PR_PRIORITY_HIGH -1 * PR_PRIORITY_URGENT -2 */ static int pt_RelativePriority(int nice, PRThreadPriority pri) { return nice + (1 - pri); } # endif /* ** Initialize a stack for a native pthread thread */ static void _PR_InitializeStack(PRThreadStack* ts) { if (ts && (ts->stackTop == 0)) { ts->allocBase = (char*)&ts; ts->allocSize = ts->stackSize; /* ** Setup stackTop and stackBottom values. */ # ifdef HAVE_STACK_GROWING_UP ts->stackBottom = ts->allocBase + ts->stackSize; ts->stackTop = ts->allocBase; # else ts->stackTop = ts->allocBase; ts->stackBottom = ts->allocBase - ts->stackSize; # endif } } static void* _pt_root(void* arg) { PRIntn rv; PRThread* thred = (PRThread*)arg; PRBool detached = (thred->state & PT_THREAD_DETACHED) ? PR_TRUE : PR_FALSE; pthread_t id = pthread_self(); # ifdef _PR_NICE_PRIORITY_SCHEDULING pid_t tid; # endif # ifdef _PR_NICE_PRIORITY_SCHEDULING /* * We need to know the kernel thread ID of each thread in order to * set its nice value hence we do it here instead of at creation time. */ tid = gettid(); errno = 0; rv = getpriority(PRIO_PROCESS, 0); /* If we cannot read the main thread's nice value don't try to change the * new thread's nice value. */ if (errno == 0) { setpriority(PRIO_PROCESS, tid, pt_RelativePriority(rv, thred->priority)); } # endif /* Set up the thread stack information */ _PR_InitializeStack(thred->stack); /* * Set within the current thread the pointer to our object. * This object will be deleted when the thread termintates, * whether in a join or detached (see _PR_InitThreads()). */ rv = pthread_setspecific(pt_book.key, thred); PR_ASSERT(0 == rv); /* make the thread visible to the rest of the runtime */ PR_Lock(pt_book.ml); /* * Both the parent thread and this new thread set thred->id. * The new thread must ensure that thred->id is set before * it executes its startFunc. The parent thread must ensure * that thred->id is set before PR_CreateThread() returns. * Both threads set thred->id while holding pt_book.ml and * use thred->idSet to ensure thred->id is written only once. */ if (!thred->idSet) { thred->id = id; thred->idSet = PR_TRUE; } else { PR_ASSERT(pthread_equal(thred->id, id)); } # ifdef _PR_NICE_PRIORITY_SCHEDULING thred->tid = tid; PR_NotifyAllCondVar(pt_book.cv); # endif /* If this is a GCABLE thread, set its state appropriately */ if (thred->suspend & PT_THREAD_SETGCABLE) { thred->state |= PT_THREAD_GCABLE; } thred->suspend = 0; thred->prev = pt_book.last; if (pt_book.last) { pt_book.last->next = thred; } else { pt_book.first = thred; } thred->next = NULL; pt_book.last = thred; PR_Unlock(pt_book.ml); thred->startFunc(thred->arg); /* make visible to the client */ /* unhook the thread from the runtime */ PR_Lock(pt_book.ml); /* * At this moment, PR_CreateThread() may not have set thred->id yet. * It is safe for a detached thread to free thred only after * PR_CreateThread() has accessed thred->id and thred->idSet. */ if (detached) { while (!thred->okToDelete) { PR_WaitCondVar(pt_book.cv, PR_INTERVAL_NO_TIMEOUT); } } if (thred->state & PT_THREAD_SYSTEM) { pt_book.system -= 1; } else if (--pt_book.user == pt_book.this_many) { PR_NotifyAllCondVar(pt_book.cv); } if (NULL == thred->prev) { pt_book.first = thred->next; } else { thred->prev->next = thred->next; } if (NULL == thred->next) { pt_book.last = thred->prev; } else { thred->next->prev = thred->prev; } PR_Unlock(pt_book.ml); /* * Here we set the pthread's backpointer to the PRThread to NULL. * Otherwise the destructor would get called eagerly as the thread * returns to the pthread runtime. The joining thread would them be * the proud possessor of a dangling reference. However, this is the * last chance to delete the object if the thread is detached, so * just let the destructor do the work. */ if (PR_FALSE == detached) { /* Call TPD destructors on this thread. */ _PR_DestroyThreadPrivate(thred); rv = pthread_setspecific(pt_book.key, NULL); PR_ASSERT(0 == rv); } return NULL; } /* _pt_root */ static PRThread* pt_AttachThread(void) { PRThread* thred = NULL; /* * NSPR must have been initialized when PR_AttachThread is called. * We cannot have PR_AttachThread call implicit initialization * because if multiple threads call PR_AttachThread simultaneously, * NSPR may be initialized more than once. * We can't call any function that calls PR_GetCurrentThread() * either (e.g., PR_SetError()) as that will result in infinite * recursion. */ if (!_pr_initialized) { return NULL; } /* PR_NEWZAP must not call PR_GetCurrentThread() */ thred = PR_NEWZAP(PRThread); if (NULL != thred) { int rv; thred->priority = PR_PRIORITY_NORMAL; thred->id = pthread_self(); thred->idSet = PR_TRUE; # ifdef _PR_NICE_PRIORITY_SCHEDULING thred->tid = gettid(); # endif rv = pthread_setspecific(pt_book.key, thred); PR_ASSERT(0 == rv); thred->state = PT_THREAD_GLOBAL | PT_THREAD_FOREIGN; PR_Lock(pt_book.ml); /* then put it into the list */ thred->prev = pt_book.last; if (pt_book.last) { pt_book.last->next = thred; } else { pt_book.first = thred; } thred->next = NULL; pt_book.last = thred; PR_Unlock(pt_book.ml); } return thred; /* may be NULL */ } /* pt_AttachThread */ static PRThread* _PR_CreateThread(PRThreadType type, void (*start)(void* arg), void* arg, PRThreadPriority priority, PRThreadScope scope, PRThreadState state, PRUint32 stackSize, PRBool isGCAble) { int rv; PRThread* thred; pthread_attr_t tattr; if (!_pr_initialized) { _PR_ImplicitInitialization(); } if ((PRIntn)PR_PRIORITY_FIRST > (PRIntn)priority) { priority = PR_PRIORITY_FIRST; } else if ((PRIntn)PR_PRIORITY_LAST < (PRIntn)priority) { priority = PR_PRIORITY_LAST; } rv = _PT_PTHREAD_ATTR_INIT(&tattr); PR_ASSERT(0 == rv); if (EPERM != pt_schedpriv) { # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 struct sched_param schedule; # endif # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 rv = pthread_attr_setinheritsched(&tattr, PTHREAD_EXPLICIT_SCHED); PR_ASSERT(0 == rv); # endif /* Use the default scheduling policy */ # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 rv = pthread_attr_getschedparam(&tattr, &schedule); PR_ASSERT(0 == rv); schedule.sched_priority = pt_PriorityMap(priority); rv = pthread_attr_setschedparam(&tattr, &schedule); PR_ASSERT(0 == rv); # ifdef NTO rv = pthread_attr_setschedpolicy(&tattr, SCHED_RR); /* Round Robin */ PR_ASSERT(0 == rv); # endif # endif /* _POSIX_THREAD_PRIORITY_SCHEDULING > 0 */ } rv = pthread_attr_setdetachstate( &tattr, ((PR_JOINABLE_THREAD == state) ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED)); PR_ASSERT(0 == rv); /* * If stackSize is 0, we use the default pthread stack size. */ if (stackSize) { # ifdef _MD_MINIMUM_STACK_SIZE if (stackSize < _MD_MINIMUM_STACK_SIZE) { stackSize = _MD_MINIMUM_STACK_SIZE; } # endif rv = pthread_attr_setstacksize(&tattr, stackSize); PR_ASSERT(0 == rv); } thred = PR_NEWZAP(PRThread); if (NULL == thred) { PR_SetError(PR_OUT_OF_MEMORY_ERROR, errno); goto done; } else { pthread_t id; thred->arg = arg; thred->startFunc = start; thred->priority = priority; if (PR_UNJOINABLE_THREAD == state) { thred->state |= PT_THREAD_DETACHED; } if (PR_LOCAL_THREAD == scope) { scope = PR_GLOBAL_THREAD; } if (PR_GLOBAL_BOUND_THREAD == scope) { # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 rv = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_SYSTEM); if (rv) { /* * system scope not supported */ scope = PR_GLOBAL_THREAD; /* * reset scope */ rv = pthread_attr_setscope(&tattr, PTHREAD_SCOPE_PROCESS); PR_ASSERT(0 == rv); } # endif } if (PR_GLOBAL_THREAD == scope) { thred->state |= PT_THREAD_GLOBAL; } else if (PR_GLOBAL_BOUND_THREAD == scope) { thred->state |= (PT_THREAD_GLOBAL | PT_THREAD_BOUND); } else { /* force it global */ thred->state |= PT_THREAD_GLOBAL; } if (PR_SYSTEM_THREAD == type) { thred->state |= PT_THREAD_SYSTEM; } thred->suspend = (isGCAble) ? PT_THREAD_SETGCABLE : 0; thred->stack = PR_NEWZAP(PRThreadStack); if (thred->stack == NULL) { PRIntn oserr = errno; PR_Free(thred); /* all that work ... poof! */ PR_SetError(PR_OUT_OF_MEMORY_ERROR, oserr); thred = NULL; /* and for what? */ goto done; } thred->stack->stackSize = stackSize; thred->stack->thr = thred; # ifdef PT_NO_SIGTIMEDWAIT pthread_mutex_init(&thred->suspendResumeMutex, NULL); pthread_cond_init(&thred->suspendResumeCV, NULL); # endif /* make the thread counted to the rest of the runtime */ PR_Lock(pt_book.ml); if (PR_SYSTEM_THREAD == type) { pt_book.system += 1; } else { pt_book.user += 1; } PR_Unlock(pt_book.ml); /* * We pass a pointer to a local copy (instead of thred->id) * to pthread_create() because who knows what wacky things * pthread_create() may be doing to its argument. */ rv = _PT_PTHREAD_CREATE(&id, tattr, _pt_root, thred); if (EPERM == rv) { /* Remember that we don't have thread scheduling privilege. */ pt_schedpriv = EPERM; PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("_PR_CreateThread: no thread scheduling privilege")); /* Try creating the thread again without setting priority. */ # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 rv = pthread_attr_setinheritsched(&tattr, PTHREAD_INHERIT_SCHED); PR_ASSERT(0 == rv); # endif rv = _PT_PTHREAD_CREATE(&id, tattr, _pt_root, thred); } if (0 != rv) { PRIntn oserr = rv; PR_Lock(pt_book.ml); if (thred->state & PT_THREAD_SYSTEM) { pt_book.system -= 1; } else if (--pt_book.user == pt_book.this_many) { PR_NotifyAllCondVar(pt_book.cv); } PR_Unlock(pt_book.ml); PR_Free(thred->stack); PR_Free(thred); /* all that work ... poof! */ PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, oserr); thred = NULL; /* and for what? */ goto done; } PR_Lock(pt_book.ml); /* * Both the parent thread and this new thread set thred->id. * The parent thread must ensure that thred->id is set before * PR_CreateThread() returns. (See comments in _pt_root().) */ if (!thred->idSet) { thred->id = id; thred->idSet = PR_TRUE; } else { PR_ASSERT(pthread_equal(thred->id, id)); } /* * If the new thread is detached, tell it that PR_CreateThread() has * accessed thred->id and thred->idSet so it's ok to delete thred. */ if (PR_UNJOINABLE_THREAD == state) { thred->okToDelete = PR_TRUE; PR_NotifyAllCondVar(pt_book.cv); } PR_Unlock(pt_book.ml); } done: rv = _PT_PTHREAD_ATTR_DESTROY(&tattr); PR_ASSERT(0 == rv); return thred; } /* _PR_CreateThread */ PR_IMPLEMENT(PRThread*) PR_CreateThread(PRThreadType type, void (*start)(void* arg), void* arg, PRThreadPriority priority, PRThreadScope scope, PRThreadState state, PRUint32 stackSize) { return _PR_CreateThread(type, start, arg, priority, scope, state, stackSize, PR_FALSE); } /* PR_CreateThread */ PR_IMPLEMENT(PRThread*) PR_CreateThreadGCAble(PRThreadType type, void (*start)(void* arg), void* arg, PRThreadPriority priority, PRThreadScope scope, PRThreadState state, PRUint32 stackSize) { return _PR_CreateThread(type, start, arg, priority, scope, state, stackSize, PR_TRUE); } /* PR_CreateThreadGCAble */ PR_IMPLEMENT(void*) GetExecutionEnvironment(PRThread* thred) { return thred->environment; } /* GetExecutionEnvironment */ PR_IMPLEMENT(void) SetExecutionEnvironment(PRThread* thred, void* env) { thred->environment = env; } /* SetExecutionEnvironment */ PR_IMPLEMENT(PRThread*) PR_AttachThread(PRThreadType type, PRThreadPriority priority, PRThreadStack* stack) { return PR_GetCurrentThread(); } /* PR_AttachThread */ PR_IMPLEMENT(PRStatus) PR_JoinThread(PRThread* thred) { int rv = -1; void* result = NULL; PR_ASSERT(thred != NULL); if ((0xafafafaf == thred->state) || (PT_THREAD_DETACHED == (PT_THREAD_DETACHED & thred->state)) || (PT_THREAD_FOREIGN == (PT_THREAD_FOREIGN & thred->state))) { /* * This might be a bad address, but if it isn't, the state should * either be an unjoinable thread or it's already had the object * deleted. However, the client that called join on a detached * thread deserves all the rath I can muster.... */ PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); PR_LogPrint("PR_JoinThread: %p not joinable | already smashed\n", thred); } else { pthread_t id = thred->id; rv = pthread_join(id, &result); PR_ASSERT(rv == 0 && result == NULL); if (0 == rv) { /* * PR_FALSE, because the thread already called the TPD * destructors before exiting _pt_root. */ _pt_thread_death_internal(thred, PR_FALSE); } else { PRErrorCode prerror; switch (rv) { case EINVAL: /* not a joinable thread */ case ESRCH: /* no thread with given ID */ prerror = PR_INVALID_ARGUMENT_ERROR; break; case EDEADLK: /* a thread joining with itself */ prerror = PR_DEADLOCK_ERROR; break; default: prerror = PR_UNKNOWN_ERROR; break; } PR_SetError(prerror, rv); } } return (0 == rv) ? PR_SUCCESS : PR_FAILURE; } /* PR_JoinThread */ PR_IMPLEMENT(void) PR_DetachThread(void) { void* thred; int rv; _PT_PTHREAD_GETSPECIFIC(pt_book.key, thred); if (NULL == thred) { return; } _pt_thread_death(thred); rv = pthread_setspecific(pt_book.key, NULL); PR_ASSERT(0 == rv); } /* PR_DetachThread */ PR_IMPLEMENT(PRThread*) PR_GetCurrentThread(void) { void* thred; if (!_pr_initialized) { _PR_ImplicitInitialization(); } _PT_PTHREAD_GETSPECIFIC(pt_book.key, thred); if (NULL == thred) { thred = pt_AttachThread(); } PR_ASSERT(NULL != thred); return (PRThread*)thred; } /* PR_GetCurrentThread */ PR_IMPLEMENT(PRThreadScope) PR_GetThreadScope(const PRThread* thred) { return (thred->state & PT_THREAD_BOUND) ? PR_GLOBAL_BOUND_THREAD : PR_GLOBAL_THREAD; } /* PR_GetThreadScope() */ PR_IMPLEMENT(PRThreadType) PR_GetThreadType(const PRThread* thred) { return (thred->state & PT_THREAD_SYSTEM) ? PR_SYSTEM_THREAD : PR_USER_THREAD; } PR_IMPLEMENT(PRThreadState) PR_GetThreadState(const PRThread* thred) { return (thred->state & PT_THREAD_DETACHED) ? PR_UNJOINABLE_THREAD : PR_JOINABLE_THREAD; } /* PR_GetThreadState */ PR_IMPLEMENT(PRThreadPriority) PR_GetThreadPriority(const PRThread* thred) { PR_ASSERT(thred != NULL); return thred->priority; } /* PR_GetThreadPriority */ PR_IMPLEMENT(void) PR_SetThreadPriority(PRThread* thred, PRThreadPriority newPri) { PRIntn rv; PR_ASSERT(NULL != thred); if ((PRIntn)PR_PRIORITY_FIRST > (PRIntn)newPri) { newPri = PR_PRIORITY_FIRST; } else if ((PRIntn)PR_PRIORITY_LAST < (PRIntn)newPri) { newPri = PR_PRIORITY_LAST; } # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 if (EPERM != pt_schedpriv) { int policy; struct sched_param schedule; rv = pthread_getschedparam(thred->id, &policy, &schedule); if (0 == rv) { schedule.sched_priority = pt_PriorityMap(newPri); rv = pthread_setschedparam(thred->id, policy, &schedule); if (EPERM == rv) { pt_schedpriv = EPERM; PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("PR_SetThreadPriority: no thread scheduling privilege")); } } if (rv != 0) { rv = -1; } } # elif defined(_PR_NICE_PRIORITY_SCHEDULING) PR_Lock(pt_book.ml); while (thred->tid == 0) { PR_WaitCondVar(pt_book.cv, PR_INTERVAL_NO_TIMEOUT); } PR_Unlock(pt_book.ml); errno = 0; rv = getpriority(PRIO_PROCESS, 0); /* Do not proceed unless we know the main thread's nice value. */ if (errno == 0) { rv = setpriority(PRIO_PROCESS, thred->tid, pt_RelativePriority(rv, newPri)); if (rv == -1) { /* We don't set pt_schedpriv to EPERM in case errno == EPERM * because adjusting the nice value might be permitted for certain * ranges but not for others. */ PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("PR_SetThreadPriority: setpriority failed with error %d", errno)); } } # else (void)rv; /* rv is unused */ # endif thred->priority = newPri; } /* PR_SetThreadPriority */ PR_IMPLEMENT(PRStatus) PR_Interrupt(PRThread* thred) { /* ** If the target thread indicates that it's waiting, ** find the condition and broadcast to it. Broadcast ** since we don't know which thread (if there are more ** than one). This sounds risky, but clients must ** test their invariants when resumed from a wait and ** I don't expect very many threads to be waiting on ** a single condition and I don't expect interrupt to ** be used very often. ** ** I don't know why I thought this would work. Must have ** been one of those weaker momements after I'd been ** smelling the vapors. ** ** Even with the followng changes it is possible that ** the pointer to the condition variable is pointing ** at a bogus value. Will the unerlying code detect ** that? */ PRCondVar* cv; PR_ASSERT(NULL != thred); if (NULL == thred) { return PR_FAILURE; } thred->state |= PT_THREAD_ABORTED; cv = thred->waiting; if ((NULL != cv) && !thred->interrupt_blocked) { PRIntn rv; (void)PR_ATOMIC_INCREMENT(&cv->notify_pending); rv = pthread_cond_broadcast(&cv->cv); PR_ASSERT(0 == rv); if (0 > PR_ATOMIC_DECREMENT(&cv->notify_pending)) { PR_DestroyCondVar(cv); } } return PR_SUCCESS; } /* PR_Interrupt */ PR_IMPLEMENT(void) PR_ClearInterrupt(void) { PRThread* me = PR_GetCurrentThread(); me->state &= ~PT_THREAD_ABORTED; } /* PR_ClearInterrupt */ PR_IMPLEMENT(void) PR_BlockInterrupt(void) { PRThread* me = PR_GetCurrentThread(); _PT_THREAD_BLOCK_INTERRUPT(me); } /* PR_BlockInterrupt */ PR_IMPLEMENT(void) PR_UnblockInterrupt(void) { PRThread* me = PR_GetCurrentThread(); _PT_THREAD_UNBLOCK_INTERRUPT(me); } /* PR_UnblockInterrupt */ PR_IMPLEMENT(PRStatus) PR_Yield(void) { static PRBool warning = PR_TRUE; if (warning) warning = _PR_Obsolete("PR_Yield()", "PR_Sleep(PR_INTERVAL_NO_WAIT)"); return PR_Sleep(PR_INTERVAL_NO_WAIT); } PR_IMPLEMENT(PRStatus) PR_Sleep(PRIntervalTime ticks) { PRStatus rv = PR_SUCCESS; if (!_pr_initialized) { _PR_ImplicitInitialization(); } if (PR_INTERVAL_NO_WAIT == ticks) { _PT_PTHREAD_YIELD(); } else { PRCondVar* cv; PRIntervalTime timein; timein = PR_IntervalNow(); cv = PR_NewCondVar(_pr_sleeplock); PR_ASSERT(cv != NULL); PR_Lock(_pr_sleeplock); do { PRIntervalTime now = PR_IntervalNow(); PRIntervalTime delta = now - timein; if (delta > ticks) { break; } rv = PR_WaitCondVar(cv, ticks - delta); } while (PR_SUCCESS == rv); PR_Unlock(_pr_sleeplock); PR_DestroyCondVar(cv); } return rv; } /* PR_Sleep */ static void _pt_thread_death(void* arg) { void* thred; int rv; _PT_PTHREAD_GETSPECIFIC(pt_book.key, thred); if (NULL == thred) { /* * Have PR_GetCurrentThread return the expected value to the * destructors. */ rv = pthread_setspecific(pt_book.key, arg); PR_ASSERT(0 == rv); } /* PR_TRUE for: call destructors */ _pt_thread_death_internal(arg, PR_TRUE); if (NULL == thred) { rv = pthread_setspecific(pt_book.key, NULL); PR_ASSERT(0 == rv); } } static void _pt_thread_death_internal(void* arg, PRBool callDestructors) { PRThread* thred = (PRThread*)arg; if (thred->state & (PT_THREAD_FOREIGN | PT_THREAD_PRIMORD)) { PR_Lock(pt_book.ml); if (NULL == thred->prev) { pt_book.first = thred->next; } else { thred->prev->next = thred->next; } if (NULL == thred->next) { pt_book.last = thred->prev; } else { thred->next->prev = thred->prev; } PR_Unlock(pt_book.ml); } if (callDestructors) { _PR_DestroyThreadPrivate(thred); } PR_Free(thred->privateData); if (NULL != thred->errorString) { PR_Free(thred->errorString); } if (NULL != thred->name) { PR_Free(thred->name); } PR_Free(thred->stack); if (NULL != thred->syspoll_list) { PR_Free(thred->syspoll_list); } # if defined(DEBUG) memset(thred, 0xaf, sizeof(PRThread)); # endif /* defined(DEBUG) */ PR_Free(thred); } /* _pt_thread_death */ void _PR_InitThreads(PRThreadType type, PRThreadPriority priority, PRUintn maxPTDs) { int rv; PRThread* thred; PR_ASSERT(priority == PR_PRIORITY_NORMAL); # ifdef _PR_NEED_PTHREAD_INIT /* * On BSD/OS (3.1 and 4.0), the pthread subsystem is lazily * initialized, but pthread_self() fails to initialize * pthreads and hence returns a null thread ID if invoked * by the primordial thread before any other pthread call. * So we explicitly initialize pthreads here. */ pthread_init(); # endif # if _POSIX_THREAD_PRIORITY_SCHEDULING > 0 # if defined(FREEBSD) { pthread_attr_t attr; int policy; /* get the min and max priorities of the default policy */ pthread_attr_init(&attr); pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); pthread_attr_getschedpolicy(&attr, &policy); pt_book.minPrio = sched_get_priority_min(policy); PR_ASSERT(-1 != pt_book.minPrio); pt_book.maxPrio = sched_get_priority_max(policy); PR_ASSERT(-1 != pt_book.maxPrio); pthread_attr_destroy(&attr); } # else /* ** These might be function evaluations */ pt_book.minPrio = PT_PRIO_MIN; pt_book.maxPrio = PT_PRIO_MAX; # endif # endif PR_ASSERT(NULL == pt_book.ml); pt_book.ml = PR_NewLock(); PR_ASSERT(NULL != pt_book.ml); pt_book.cv = PR_NewCondVar(pt_book.ml); PR_ASSERT(NULL != pt_book.cv); thred = PR_NEWZAP(PRThread); PR_ASSERT(NULL != thred); thred->arg = NULL; thred->startFunc = NULL; thred->priority = priority; thred->id = pthread_self(); thred->idSet = PR_TRUE; # ifdef _PR_NICE_PRIORITY_SCHEDULING thred->tid = gettid(); # endif thred->state = (PT_THREAD_DETACHED | PT_THREAD_PRIMORD); if (PR_SYSTEM_THREAD == type) { thred->state |= PT_THREAD_SYSTEM; pt_book.system += 1; pt_book.this_many = 0; } else { pt_book.user += 1; pt_book.this_many = 1; } thred->next = thred->prev = NULL; pt_book.first = pt_book.last = thred; thred->stack = PR_NEWZAP(PRThreadStack); PR_ASSERT(thred->stack != NULL); thred->stack->stackSize = 0; thred->stack->thr = thred; _PR_InitializeStack(thred->stack); /* * Create a key for our use to store a backpointer in the pthread * to our PRThread object. This object gets deleted when the thread * returns from its root in the case of a detached thread. Other * threads delete the objects in Join. * * NB: The destructor logic seems to have a bug so it isn't used. * NBB: Oh really? I'm going to give it a spin - AOF 19 June 1998. * More info - the problem is that pthreads calls the destructor * eagerly as the thread returns from its root, rather than lazily * after the thread is joined. Therefore, threads that are joining * and holding PRThread references are actually holding pointers to * nothing. */ rv = _PT_PTHREAD_KEY_CREATE(&pt_book.key, _pt_thread_death); if (0 != rv) { PR_Assert("0 == rv", __FILE__, __LINE__); } pt_book.keyCreated = PR_TRUE; rv = pthread_setspecific(pt_book.key, thred); PR_ASSERT(0 == rv); } /* _PR_InitThreads */ # ifdef __GNUC__ /* * GCC supports the constructor and destructor attributes as of * version 2.5. */ # if defined(DARWIN) /* * The dynamic linker on OSX doesn't execute __attribute__((destructor)) * destructors in the right order wrt non-__attribute((destructor)) destructors * in other libraries. So use atexit() instead, which does. * See https://bugzilla.mozilla.org/show_bug.cgi?id=1399746#c99 */ static void _PR_Fini(void); __attribute__((constructor)) static void _register_PR_Fini() { atexit(_PR_Fini); } # else static void _PR_Fini(void) __attribute__((destructor)); # endif # elif defined(__SUNPRO_C) /* * Sun Studio compiler */ # pragma fini(_PR_Fini) static void _PR_Fini(void); # elif defined(AIX) /* Need to use the -binitfini::_PR_Fini linker option. */ # endif void _PR_Fini(void) { void* thred; int rv; if (!_pr_initialized) { /* Either NSPR was never successfully initialized or * PR_Cleanup has been called already. */ if (pt_book.keyCreated) { rv = pthread_key_delete(pt_book.key); PR_ASSERT(0 == rv); pt_book.keyCreated = PR_FALSE; } return; } _PT_PTHREAD_GETSPECIFIC(pt_book.key, thred); if (NULL != thred) { /* * PR_FALSE, because it is unsafe to call back to the * thread private data destructors at final cleanup. */ _pt_thread_death_internal(thred, PR_FALSE); rv = pthread_setspecific(pt_book.key, NULL); PR_ASSERT(0 == rv); } rv = pthread_key_delete(pt_book.key); PR_ASSERT(0 == rv); pt_book.keyCreated = PR_FALSE; /* TODO: free other resources used by NSPR */ /* _pr_initialized = PR_FALSE; */ } /* _PR_Fini */ PR_IMPLEMENT(PRStatus) PR_Cleanup(void) { PRThread* me = PR_GetCurrentThread(); int rv; PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("PR_Cleanup: shutting down NSPR")); PR_ASSERT(me->state & PT_THREAD_PRIMORD); if (me->state & PT_THREAD_PRIMORD) { PR_Lock(pt_book.ml); while (pt_book.user > pt_book.this_many) { PR_WaitCondVar(pt_book.cv, PR_INTERVAL_NO_TIMEOUT); } if (me->state & PT_THREAD_SYSTEM) { pt_book.system -= 1; } else { pt_book.user -= 1; } PR_Unlock(pt_book.ml); _PR_MD_EARLY_CLEANUP(); _PR_CleanupMW(); _PR_CleanupTime(); _PR_CleanupDtoa(); _PR_CleanupCallOnce(); _PR_ShutdownLinker(); _PR_LogCleanup(); _PR_CleanupNet(); /* Close all the fd's before calling _PR_CleanupIO */ _PR_CleanupIO(); _PR_CleanupCMon(); _pt_thread_death(me); rv = pthread_setspecific(pt_book.key, NULL); PR_ASSERT(0 == rv); /* * I am not sure if it's safe to delete the cv and lock here, * since there may still be "system" threads around. If this * call isn't immediately prior to exiting, then there's a * problem. */ if (0 == pt_book.system) { PR_DestroyCondVar(pt_book.cv); pt_book.cv = NULL; PR_DestroyLock(pt_book.ml); pt_book.ml = NULL; } PR_DestroyLock(_pr_sleeplock); _pr_sleeplock = NULL; _PR_CleanupLayerCache(); _PR_CleanupEnv(); # ifdef _PR_ZONE_ALLOCATOR _PR_DestroyZones(); # endif _pr_initialized = PR_FALSE; return PR_SUCCESS; } return PR_FAILURE; } /* PR_Cleanup */ PR_IMPLEMENT(void) PR_ProcessExit(PRIntn status) { _exit(status); } PR_IMPLEMENT(PRUint32) PR_GetThreadID(PRThread* thred) { return (PRUint32)thred->id; /* and I don't know what they will do with it */ } /* * $$$ * The following two thread-to-processor affinity functions are not * yet implemented for pthreads. By the way, these functions should return * PRStatus rather than PRInt32 to indicate the success/failure status. * $$$ */ PR_IMPLEMENT(PRInt32) PR_GetThreadAffinityMask(PRThread* thread, PRUint32* mask) { return 0; /* not implemented */ } PR_IMPLEMENT(PRInt32) PR_SetThreadAffinityMask(PRThread* thread, PRUint32 mask) { return 0; /* not implemented */ } PR_IMPLEMENT(void) PR_SetThreadDumpProc(PRThread* thread, PRThreadDumpProc dump, void* arg) { thread->dump = dump; thread->dumpArg = arg; } /* * Garbage collection support follows. */ /* a bogus signal mask for forcing a timed wait */ /* Not so bogus in AIX as we really do a sigwait */ static sigset_t sigwait_set; static struct timespec onemillisec = {0, 1000000L}; # ifndef PT_NO_SIGTIMEDWAIT static struct timespec hundredmillisec = {0, 100000000L}; # endif static void suspend_signal_handler(PRIntn sig); # ifdef PT_NO_SIGTIMEDWAIT static void null_signal_handler(PRIntn sig); # endif /* * Linux pthreads use SIGUSR1 and SIGUSR2 internally, which * conflict with the use of these two signals in our GC support. * So we don't know how to support GC on Linux pthreads. */ static void init_pthread_gc_support(void) { PRIntn rv; { struct sigaction sigact_usr2; sigact_usr2.sa_handler = suspend_signal_handler; sigact_usr2.sa_flags = SA_RESTART; sigemptyset(&sigact_usr2.sa_mask); rv = sigaction(SIGUSR2, &sigact_usr2, NULL); PR_ASSERT(0 == rv); sigemptyset(&sigwait_set); # if defined(PT_NO_SIGTIMEDWAIT) sigaddset(&sigwait_set, SIGUSR1); # else sigaddset(&sigwait_set, SIGUSR2); # endif /* defined(PT_NO_SIGTIMEDWAIT) */ } # if defined(PT_NO_SIGTIMEDWAIT) { struct sigaction sigact_null; sigact_null.sa_handler = null_signal_handler; sigact_null.sa_flags = SA_RESTART; sigemptyset(&sigact_null.sa_mask); rv = sigaction(SIGUSR1, &sigact_null, NULL); PR_ASSERT(0 == rv); } # endif /* defined(PT_NO_SIGTIMEDWAIT) */ } PR_IMPLEMENT(void) PR_SetThreadGCAble(void) { PR_Lock(pt_book.ml); PR_GetCurrentThread()->state |= PT_THREAD_GCABLE; PR_Unlock(pt_book.ml); } PR_IMPLEMENT(void) PR_ClearThreadGCAble(void) { PR_Lock(pt_book.ml); PR_GetCurrentThread()->state &= (~PT_THREAD_GCABLE); PR_Unlock(pt_book.ml); } # if defined(DEBUG) static PRBool suspendAllOn = PR_FALSE; # endif static PRBool suspendAllSuspended = PR_FALSE; PR_IMPLEMENT(PRStatus) PR_EnumerateThreads(PREnumerator func, void* arg) { PRIntn count = 0; PRStatus rv = PR_SUCCESS; PRThread* thred = pt_book.first; # if defined(DEBUG) || defined(FORCE_PR_ASSERT) PRThread* me = PR_GetCurrentThread(); # endif PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("Begin PR_EnumerateThreads\n")); /* * $$$ * Need to suspend all threads other than me before doing this. * This is really a gross and disgusting thing to do. The only * good thing is that since all other threads are suspended, holding * the lock during a callback seems like child's play. * $$$ */ PR_ASSERT(suspendAllOn); while (thred != NULL) { /* Steve Morse, 4-23-97: Note that we can't walk a queue by taking * qp->next after applying the function "func". In particular, "func" * might remove the thread from the queue and put it into another one in * which case qp->next no longer points to the next entry in the original * queue. * * To get around this problem, we save qp->next in qp_next before applying * "func" and use that saved value as the next value after applying "func". */ PRThread* next = thred->next; if (_PT_IS_GCABLE_THREAD(thred)) { PR_ASSERT((thred == me) || (thred->suspend & PT_THREAD_SUSPENDED)); PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("In PR_EnumerateThreads callback thread %p thid = %X\n", thred, thred->id)); rv = func(thred, count++, arg); if (rv != PR_SUCCESS) { return rv; } } thred = next; } PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End PR_EnumerateThreads count = %d \n", count)); return rv; } /* PR_EnumerateThreads */ /* * PR_SuspendAll and PR_ResumeAll are called during garbage collection. The * strategy we use is to send a SIGUSR2 signal to every gc able thread that we * intend to suspend. The signal handler will record the stack pointer and will * block until resumed by the resume call. Since the signal handler is the last * routine called for the suspended thread, the stack pointer will also serve as * a place where all the registers have been saved on the stack for the * previously executing routines. * * Through global variables, we also make sure that PR_Suspend and PR_Resume * does not proceed until the thread is suspended or resumed. */ /* * In the signal handler, we can not use condition variable notify or wait. * This does not work consistently across all pthread platforms. We also can * not use locking since that does not seem to work reliably across platforms. * Only thing we can do is yielding while testing for a global condition * to change. This does work on pthread supported platforms. We may have * to play with priortities if there are any problems detected. */ /* * In AIX, you cannot use ANY pthread calls in the signal handler except perhaps * pthread_yield. But that is horribly inefficient. Hence we use only sigwait, * no sigtimedwait is available. We need to use another user signal, SIGUSR1. * Actually SIGUSR1 is also used by exec in Java. So our usage here breaks the * exec in Java, for AIX. You cannot use pthread_cond_wait or pthread_delay_np * in the signal handler as all synchronization mechanisms just break down. */ # if defined(PT_NO_SIGTIMEDWAIT) static void null_signal_handler(PRIntn sig) { return; } # endif static void suspend_signal_handler(PRIntn sig) { PRThread* me = PR_GetCurrentThread(); PR_ASSERT(me != NULL); PR_ASSERT(_PT_IS_GCABLE_THREAD(me)); PR_ASSERT((me->suspend & PT_THREAD_SUSPENDED) == 0); PR_LOG( _pr_gc_lm, PR_LOG_ALWAYS, ("Begin suspend_signal_handler thred %p thread id = %X\n", me, me->id)); /* * save stack pointer */ me->sp = &me; /* At this point, the thread's stack pointer has been saved, And it is going to enter a wait loop until it is resumed. So it is _really_ suspended */ me->suspend |= PT_THREAD_SUSPENDED; /* * now, block current thread */ # if defined(PT_NO_SIGTIMEDWAIT) pthread_cond_signal(&me->suspendResumeCV); while (me->suspend & PT_THREAD_SUSPENDED) { # if !defined(FREEBSD) && !defined(NETBSD) && !defined(OPENBSD) && \ !defined(DARWIN) && !defined(RISCOS) PRIntn rv; sigwait(&sigwait_set, &rv); # endif } me->suspend |= PT_THREAD_RESUMED; pthread_cond_signal(&me->suspendResumeCV); # else /* defined(PT_NO_SIGTIMEDWAIT) */ while (me->suspend & PT_THREAD_SUSPENDED) { PRIntn rv = sigtimedwait(&sigwait_set, NULL, &hundredmillisec); PR_ASSERT(-1 == rv); } me->suspend |= PT_THREAD_RESUMED; # endif /* * At this point, thread has been resumed, so set a global condition. * The ResumeAll needs to know that this has really been resumed. * So the signal handler sets a flag which PR_ResumeAll will reset. * The PR_ResumeAll must reset this flag ... */ PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End suspend_signal_handler thred = %p tid = %X\n", me, me->id)); } /* suspend_signal_handler */ static void pt_SuspendSet(PRThread* thred) { PRIntn rv; PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("pt_SuspendSet thred %p thread id = %X\n", thred, thred->id)); /* * Check the thread state and signal the thread to suspend */ PR_ASSERT((thred->suspend & PT_THREAD_SUSPENDED) == 0); PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("doing pthread_kill in pt_SuspendSet thred %p tid = %X\n", thred, thred->id)); rv = pthread_kill(thred->id, SIGUSR2); PR_ASSERT(0 == rv); } static void pt_SuspendTest(PRThread* thred) { PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("Begin pt_SuspendTest thred %p thread id = %X\n", thred, thred->id)); /* * Wait for the thread to be really suspended. This happens when the * suspend signal handler stores the stack pointer and sets the state * to suspended. */ # if defined(PT_NO_SIGTIMEDWAIT) pthread_mutex_lock(&thred->suspendResumeMutex); while ((thred->suspend & PT_THREAD_SUSPENDED) == 0) { pthread_cond_timedwait(&thred->suspendResumeCV, &thred->suspendResumeMutex, &onemillisec); } pthread_mutex_unlock(&thred->suspendResumeMutex); # else while ((thred->suspend & PT_THREAD_SUSPENDED) == 0) { PRIntn rv = sigtimedwait(&sigwait_set, NULL, &onemillisec); PR_ASSERT(-1 == rv); } # endif PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End pt_SuspendTest thred %p tid %X\n", thred, thred->id)); } /* pt_SuspendTest */ static void pt_ResumeSet(PRThread* thred) { PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("pt_ResumeSet thred %p thread id = %X\n", thred, thred->id)); /* * Clear the global state and set the thread state so that it will * continue past yield loop in the suspend signal handler */ PR_ASSERT(thred->suspend & PT_THREAD_SUSPENDED); thred->suspend &= ~PT_THREAD_SUSPENDED; # if defined(PT_NO_SIGTIMEDWAIT) pthread_kill(thred->id, SIGUSR1); # endif } /* pt_ResumeSet */ static void pt_ResumeTest(PRThread* thred) { PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("Begin pt_ResumeTest thred %p thread id = %X\n", thred, thred->id)); /* * Wait for the threads resume state to change * to indicate it is really resumed */ # if defined(PT_NO_SIGTIMEDWAIT) pthread_mutex_lock(&thred->suspendResumeMutex); while ((thred->suspend & PT_THREAD_RESUMED) == 0) { pthread_cond_timedwait(&thred->suspendResumeCV, &thred->suspendResumeMutex, &onemillisec); } pthread_mutex_unlock(&thred->suspendResumeMutex); # else while ((thred->suspend & PT_THREAD_RESUMED) == 0) { PRIntn rv = sigtimedwait(&sigwait_set, NULL, &onemillisec); PR_ASSERT(-1 == rv); } # endif thred->suspend &= ~PT_THREAD_RESUMED; PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End pt_ResumeTest thred %p tid %X\n", thred, thred->id)); } /* pt_ResumeTest */ static pthread_once_t pt_gc_support_control = PTHREAD_ONCE_INIT; PR_IMPLEMENT(void) PR_SuspendAll(void) { # ifdef DEBUG PRIntervalTime stime, etime; # endif PRThread* thred = pt_book.first; PRThread* me = PR_GetCurrentThread(); int rv; rv = pthread_once(&pt_gc_support_control, init_pthread_gc_support); PR_ASSERT(0 == rv); PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("Begin PR_SuspendAll\n")); /* * Stop all threads which are marked GC able. */ PR_Lock(pt_book.ml); # ifdef DEBUG suspendAllOn = PR_TRUE; stime = PR_IntervalNow(); # endif while (thred != NULL) { if ((thred != me) && _PT_IS_GCABLE_THREAD(thred)) { pt_SuspendSet(thred); } thred = thred->next; } /* Wait till they are really suspended */ thred = pt_book.first; while (thred != NULL) { if ((thred != me) && _PT_IS_GCABLE_THREAD(thred)) { pt_SuspendTest(thred); } thred = thred->next; } suspendAllSuspended = PR_TRUE; # ifdef DEBUG etime = PR_IntervalNow(); PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End PR_SuspendAll (time %dms)\n", PR_IntervalToMilliseconds(etime - stime))); # endif } /* PR_SuspendAll */ PR_IMPLEMENT(void) PR_ResumeAll(void) { # ifdef DEBUG PRIntervalTime stime, etime; # endif PRThread* thred = pt_book.first; PRThread* me = PR_GetCurrentThread(); PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("Begin PR_ResumeAll\n")); /* * Resume all previously suspended GC able threads. */ suspendAllSuspended = PR_FALSE; # ifdef DEBUG stime = PR_IntervalNow(); # endif while (thred != NULL) { if ((thred != me) && _PT_IS_GCABLE_THREAD(thred)) { pt_ResumeSet(thred); } thred = thred->next; } thred = pt_book.first; while (thred != NULL) { if ((thred != me) && _PT_IS_GCABLE_THREAD(thred)) { pt_ResumeTest(thred); } thred = thred->next; } PR_Unlock(pt_book.ml); # ifdef DEBUG suspendAllOn = PR_FALSE; etime = PR_IntervalNow(); PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("End PR_ResumeAll (time %dms)\n", PR_IntervalToMilliseconds(etime - stime))); # endif } /* PR_ResumeAll */ /* Return the stack pointer for the given thread- used by the GC */ PR_IMPLEMENT(void*) PR_GetSP(PRThread* thred) { PR_LOG(_pr_gc_lm, PR_LOG_ALWAYS, ("in PR_GetSP thred %p thid = %X, sp = %p\n", thred, thred->id, thred->sp)); return thred->sp; } /* PR_GetSP */ PR_IMPLEMENT(PRStatus) PR_SetCurrentThreadName(const char* name) { PRThread* thread; size_t nameLen; int result = 0; if (!name) { PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0); return PR_FAILURE; } thread = PR_GetCurrentThread(); if (!thread) { return PR_FAILURE; } PR_Free(thread->name); nameLen = strlen(name); thread->name = (char*)PR_Malloc(nameLen + 1); if (!thread->name) { return PR_FAILURE; } memcpy(thread->name, name, nameLen + 1); # if defined(OPENBSD) || defined(FREEBSD) || defined(DRAGONFLY) pthread_set_name_np(thread->id, name); # elif defined(ANDROID) prctl(PR_SET_NAME, (unsigned long)(name)); # elif defined(NETBSD) result = pthread_setname_np(thread->id, "%s", (void*)name); # else /* not BSD */ /* * On OSX, pthread_setname_np is only available in 10.6 or later, so test * for it at runtime. It also may not be available on all linux distros. */ # if defined(DARWIN) int (*dynamic_pthread_setname_np)(const char*); # else int (*dynamic_pthread_setname_np)(pthread_t, const char*); # endif *(void**)(&dynamic_pthread_setname_np) = dlsym(RTLD_DEFAULT, "pthread_setname_np"); if (!dynamic_pthread_setname_np) { return PR_SUCCESS; } # if defined(DARWIN) /* Mac OS X has a length limit of 63 characters, but there is no API * exposing it. */ # define SETNAME_LENGTH_CONSTRAINT 63 # else /* * The 15-character name length limit is an experimentally determined * length of a null-terminated string that most linux distros accept * as an argument to pthread_setname_np. Otherwise the E2BIG * error is returned by the function. */ # define SETNAME_LENGTH_CONSTRAINT 15 # endif # define SETNAME_FRAGMENT1_LENGTH (SETNAME_LENGTH_CONSTRAINT >> 1) # define SETNAME_FRAGMENT2_LENGTH \ (SETNAME_LENGTH_CONSTRAINT - SETNAME_FRAGMENT1_LENGTH - 1) char name_dup[SETNAME_LENGTH_CONSTRAINT + 1]; if (nameLen > SETNAME_LENGTH_CONSTRAINT) { memcpy(name_dup, name, SETNAME_FRAGMENT1_LENGTH); name_dup[SETNAME_FRAGMENT1_LENGTH] = '~'; /* Note that this also copies the null terminator. */ memcpy(name_dup + SETNAME_FRAGMENT1_LENGTH + 1, name + nameLen - SETNAME_FRAGMENT2_LENGTH, SETNAME_FRAGMENT2_LENGTH + 1); name = name_dup; } # if defined(DARWIN) result = dynamic_pthread_setname_np(name); # else result = dynamic_pthread_setname_np(thread->id, name); # endif # endif /* not BSD */ if (result) { PR_SetError(PR_UNKNOWN_ERROR, result); return PR_FAILURE; } return PR_SUCCESS; } PR_IMPLEMENT(const char*) PR_GetThreadName(const PRThread* thread) { if (!thread) { return NULL; } return thread->name; } #endif /* defined(_PR_PTHREADS) */ /* ptthread.c */