The Tor Browser: nsprpub/pr/src/threads/prcthr.c@b8a032363ba2 (annotated)

nsprpub/pr/src/threads/prcthr.c@b8a032363ba2 (annotated)

nsprpub/pr/src/threads/prcthr.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 #include "primpl.h"
 #if defined(WIN95)
 /*
 ** Some local variables report warnings on Win95 because the code paths
 ** using them are conditioned on HAVE_CUSTOME_USER_THREADS.
 ** The pragma suppresses the warning.
 **
 */
 #pragma warning(disable : 4101)
 #endif
 extern PRLock *_pr_sleeplock;  /* allocated and initialized in prinit */
 /*
 ** Routines common to both native and user threads.
 **
 **
 ** Clean up a thread object, releasing all of the attached data. Do not
 ** free the object itself (it may not have been malloc'd)
 */
 void _PR_CleanupThread(PRThread *thread)
 {
     /* Free up per-thread-data */
     _PR_DestroyThreadPrivate(thread);
     /* Free any thread dump procs */
     if (thread->dumpArg) {
         PR_DELETE(thread->dumpArg);
     }
     thread->dump = 0;
     PR_DELETE(thread->name);
     PR_DELETE(thread->errorString);
     thread->errorStringSize = 0;
     thread->errorStringLength = 0;
     thread->environment = NULL;
 }
 PR_IMPLEMENT(PRStatus) PR_Yield()
 {
     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));
 }
 /*
 ** Make the current thread sleep until "timeout" ticks amount of time
 ** has expired. If "timeout" is PR_INTERVAL_NO_WAIT then the call is
 ** equivalent to a yield. Waiting for an infinite amount of time is
 ** allowed in the expectation that another thread will interrupt().
 **
 ** A single lock is used for all threads calling sleep. Each caller
 ** does get its own condition variable since each is expected to have
 ** a unique 'timeout'.
 */
 PR_IMPLEMENT(PRStatus) PR_Sleep(PRIntervalTime timeout)
 {
     PRStatus rv = PR_SUCCESS;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     if (PR_INTERVAL_NO_WAIT == timeout)
     {
         /*
         ** This is a simple yield, nothing more, nothing less.
         */
         PRIntn is;
         PRThread *me = PR_GetCurrentThread();
         PRUintn pri = me->priority;
         _PRCPU *cpu = _PR_MD_CURRENT_CPU();
         if ( _PR_IS_NATIVE_THREAD(me) ) _PR_MD_YIELD();
         else
         {
             _PR_INTSOFF(is);
             _PR_RUNQ_LOCK(cpu);
             if (_PR_RUNQREADYMASK(cpu) >> pri) {
                 me->cpu = cpu;
                 me->state = _PR_RUNNABLE;
                 _PR_ADD_RUNQ(me, cpu, pri);
                 _PR_RUNQ_UNLOCK(cpu);
                 PR_LOG(_pr_sched_lm, PR_LOG_MIN, ("PR_Yield: yielding"));
                 _PR_MD_SWITCH_CONTEXT(me);
                 PR_LOG(_pr_sched_lm, PR_LOG_MIN, ("PR_Yield: done"));
                 _PR_FAST_INTSON(is);
             }
             else
             {
                 _PR_RUNQ_UNLOCK(cpu);
                 _PR_INTSON(is);
             }
         }
     }
     else
     {
         /*
         ** This is waiting for some finite period of time.
         ** A thread in this state is interruptible (PR_Interrupt()),
         ** but the lock and cvar used are local to the implementation
         ** and not visible to the caller, therefore not notifiable.
         */
         PRCondVar *cv;
         PRIntervalTime timein;
         timein = PR_IntervalNow();
         cv = PR_NewCondVar(_pr_sleeplock);
         PR_ASSERT(cv != NULL);
         PR_Lock(_pr_sleeplock);
         do
         {
             PRIntervalTime delta = PR_IntervalNow() - timein;
             if (delta > timeout) break;
             rv = PR_WaitCondVar(cv, timeout - delta);
         } while (rv == PR_SUCCESS);
         PR_Unlock(_pr_sleeplock);
         PR_DestroyCondVar(cv);
     }
     return rv;
 }
 PR_IMPLEMENT(PRUint32) PR_GetThreadID(PRThread *thread)
 {
     return thread->id;
 }
 PR_IMPLEMENT(PRThreadPriority) PR_GetThreadPriority(const PRThread *thread)
 {
     return (PRThreadPriority) thread->priority;
 }
 PR_IMPLEMENT(PRThread *) PR_GetCurrentThread()
 {
     if (!_pr_initialized) _PR_ImplicitInitialization();
     return _PR_MD_CURRENT_THREAD();
 }
 /*
 ** Set the interrupt flag for a thread. The thread will be unable to
 ** block in i/o functions when this happens. Also, any PR_Wait's in
 ** progress will be undone. The interrupt remains in force until
 ** PR_ClearInterrupt is called.
 */
 PR_IMPLEMENT(PRStatus) PR_Interrupt(PRThread *thread)
 {
 #ifdef _PR_GLOBAL_THREADS_ONLY
     PRCondVar *victim;
     _PR_THREAD_LOCK(thread);
     thread->flags |= _PR_INTERRUPT;
     victim = thread->wait.cvar;
     _PR_THREAD_UNLOCK(thread);
     if ((NULL != victim) && (!(thread->flags & _PR_INTERRUPT_BLOCKED))) {
         int haveLock = (victim->lock->owner == _PR_MD_CURRENT_THREAD());
         if (!haveLock) PR_Lock(victim->lock);
         PR_NotifyAllCondVar(victim);
         if (!haveLock) PR_Unlock(victim->lock);
     }
     return PR_SUCCESS;
 #else  /* ! _PR_GLOBAL_THREADS_ONLY */
     PRIntn is;
     PRThread *me = _PR_MD_CURRENT_THREAD();
             if (!_PR_IS_NATIVE_THREAD(me))
             	_PR_INTSOFF(is);
             _PR_THREAD_LOCK(thread);
             thread->flags |= _PR_INTERRUPT;
         switch (thread->state) {
                 case _PR_COND_WAIT:
                         /*
                          * call is made with thread locked;
                          * on return lock is released
                          */
 						if (!(thread->flags & _PR_INTERRUPT_BLOCKED))
                         	_PR_NotifyLockedThread(thread);
                         break;
                 case _PR_IO_WAIT:
                         /*
                          * Need to hold the thread lock when calling
                          * _PR_Unblock_IO_Wait().  On return lock is
                          * released.
                          */
 #if defined(XP_UNIX) || defined(WINNT) || defined(WIN16)
 						if (!(thread->flags & _PR_INTERRUPT_BLOCKED))
                         	_PR_Unblock_IO_Wait(thread);
 #else
                         _PR_THREAD_UNLOCK(thread);
 #endif
                         break;
                 case _PR_RUNNING:
                 case _PR_RUNNABLE:
                 case _PR_LOCK_WAIT:
                 default:
                             _PR_THREAD_UNLOCK(thread);
                         break;
         }
             if (!_PR_IS_NATIVE_THREAD(me))
             	_PR_INTSON(is);
             return PR_SUCCESS;
 #endif  /* _PR_GLOBAL_THREADS_ONLY */
 }
 /*
 ** Clear the interrupt flag for self.
 */
 PR_IMPLEMENT(void) PR_ClearInterrupt()
 {
     PRIntn is;
     PRThread *me = _PR_MD_CURRENT_THREAD();
         if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSOFF(is);
     _PR_THREAD_LOCK(me);
          me->flags &= ~_PR_INTERRUPT;
     _PR_THREAD_UNLOCK(me);
         if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSON(is);
 }
 PR_IMPLEMENT(void) PR_BlockInterrupt()
 {
     PRIntn is;
     PRThread *me = _PR_MD_CURRENT_THREAD();
     if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSOFF(is);
     _PR_THREAD_LOCK(me);
     _PR_THREAD_BLOCK_INTERRUPT(me);
     _PR_THREAD_UNLOCK(me);
     if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSON(is);
 }  /* PR_BlockInterrupt */
 PR_IMPLEMENT(void) PR_UnblockInterrupt()
 {
     PRIntn is;
     PRThread *me = _PR_MD_CURRENT_THREAD();
     if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSOFF(is);
     _PR_THREAD_LOCK(me);
     _PR_THREAD_UNBLOCK_INTERRUPT(me);
     _PR_THREAD_UNLOCK(me);
     if ( !_PR_IS_NATIVE_THREAD(me)) _PR_INTSON(is);
 }  /* PR_UnblockInterrupt */
 /*
 ** Return the thread stack pointer of the given thread.
 */
 PR_IMPLEMENT(void *) PR_GetSP(PRThread *thread)
 {
         return (void *)_PR_MD_GET_SP(thread);
 }
 PR_IMPLEMENT(void*) GetExecutionEnvironment(PRThread *thread)
 {
         return thread->environment;
 }
 PR_IMPLEMENT(void) SetExecutionEnvironment(PRThread *thread, void *env)
 {
         thread->environment = env;
 }
 PR_IMPLEMENT(PRInt32) PR_GetThreadAffinityMask(PRThread *thread, PRUint32 *mask)
 {
 #ifdef HAVE_THREAD_AFFINITY
     return _PR_MD_GETTHREADAFFINITYMASK(thread, mask);
 #else
     return 0;
 #endif
 }
 PR_IMPLEMENT(PRInt32) PR_SetThreadAffinityMask(PRThread *thread, PRUint32 mask )
 {
 #ifdef HAVE_THREAD_AFFINITY
 #ifndef IRIX
     return _PR_MD_SETTHREADAFFINITYMASK(thread, mask);
 #else
 	return 0;
 #endif
 #else
     return 0;
 #endif
 }
 /* This call is thread unsafe if another thread is calling SetConcurrency()
  */
 PR_IMPLEMENT(PRInt32) PR_SetCPUAffinityMask(PRUint32 mask)
 {
 #ifdef HAVE_THREAD_AFFINITY
     PRCList *qp;
     extern PRUint32 _pr_cpu_affinity_mask;
     if (!_pr_initialized) _PR_ImplicitInitialization();
     _pr_cpu_affinity_mask = mask;
     qp = _PR_CPUQ().next;
     while(qp != &_PR_CPUQ()) {
         _PRCPU *cpu;
         cpu = _PR_CPU_PTR(qp);
         PR_SetThreadAffinityMask(cpu->thread, mask);
         qp = qp->next;
     }
 #endif
     return 0;
 }
 PRUint32 _pr_recycleThreads = 0;
 PR_IMPLEMENT(void) PR_SetThreadRecycleMode(PRUint32 count)
 {
     _pr_recycleThreads = count;
 }
 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_GCABLE_THREAD);
 }
 #ifdef SOLARIS
 PR_IMPLEMENT(PRThread*) PR_CreateThreadBound(PRThreadType type,
                                      void (*start)(void *arg),
                                      void *arg,
                                      PRUintn priority,
                                      PRThreadScope scope,
                                      PRThreadState state,
                                      PRUint32 stackSize)
 {
     return _PR_CreateThread(type, start, arg, priority, scope, state,
                             stackSize, _PR_BOUND_THREAD);
 }
 #endif
 PR_IMPLEMENT(PRThread*) PR_AttachThreadGCAble(
     PRThreadType type, PRThreadPriority priority, PRThreadStack *stack)
 {
     /* $$$$ not sure how to finese this one */
     PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
     return NULL;
 }
 PR_IMPLEMENT(void) PR_SetThreadGCAble()
 {
     if (!_pr_initialized) _PR_ImplicitInitialization();
     PR_Lock(_pr_activeLock);
         _PR_MD_CURRENT_THREAD()->flags |= _PR_GCABLE_THREAD;
         PR_Unlock(_pr_activeLock);
 }
 PR_IMPLEMENT(void) PR_ClearThreadGCAble()
 {
     if (!_pr_initialized) _PR_ImplicitInitialization();
     PR_Lock(_pr_activeLock);
         _PR_MD_CURRENT_THREAD()->flags &= (~_PR_GCABLE_THREAD);
         PR_Unlock(_pr_activeLock);
 }
 PR_IMPLEMENT(PRThreadScope) PR_GetThreadScope(const PRThread *thread)
 {
     if (!_pr_initialized) _PR_ImplicitInitialization();
     if (_PR_IS_NATIVE_THREAD(thread)) {
     	return (thread->flags & _PR_BOUND_THREAD) ? PR_GLOBAL_BOUND_THREAD :
 										PR_GLOBAL_THREAD;
     } else
         return PR_LOCAL_THREAD;
 }
 PR_IMPLEMENT(PRThreadType) PR_GetThreadType(const PRThread *thread)
 {
     return (thread->flags & _PR_SYSTEM) ? PR_SYSTEM_THREAD : PR_USER_THREAD;
 }
 PR_IMPLEMENT(PRThreadState) PR_GetThreadState(const PRThread *thread)
 {
     return (NULL == thread->term) ? PR_UNJOINABLE_THREAD : PR_JOINABLE_THREAD;
 }  /* PR_GetThreadState */

The Tor Browser / annotate

nsprpub/pr/src/threads/prcthr.c@b8a032363ba2 (annotated)

nsprpub/pr/src/threads/prcthr.c