tor-browser

pruthr.c (51989B)

---

/* -*- 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"
#include <signal.h>
#include <string.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

/* _pr_activeLock protects the following global variables */
PRLock* _pr_activeLock;
PRInt32 _pr_primordialExitCount;   /* In PR_Cleanup(), the primordial thread
                                   * waits until all other user (non-system)
                                   * threads have terminated before it exits.
                                   * So whenever we decrement _pr_userActive,
                                   * it is compared with
                                   * _pr_primordialExitCount.
                                   * If the primordial thread is a system
                                   * thread, then _pr_primordialExitCount
                                   * is 0.  If the primordial thread is
                                   * itself a user thread, then
                                   * _pr_primordialThread is 1.
                                   */
PRCondVar* _pr_primordialExitCVar; /* When _pr_userActive is decremented to
                                   * _pr_primordialExitCount, this condition
                                   * variable is notified.
                                   */

PRLock* _pr_deadQLock;
PRUint32 _pr_numNativeDead;
PRUint32 _pr_numUserDead;
PRCList _pr_deadNativeQ;
PRCList _pr_deadUserQ;

PRUint32 _pr_join_counter;

PRUint32 _pr_local_threads;
PRUint32 _pr_global_threads;

PRBool suspendAllOn = PR_FALSE;
PRThread* suspendAllThread = NULL;

extern PRCList _pr_active_global_threadQ;
extern PRCList _pr_active_local_threadQ;

static void _PR_DecrActiveThreadCount(PRThread* thread);
static PRThread* _PR_AttachThread(PRThreadType, PRThreadPriority,
                                 PRThreadStack*);
static void _PR_InitializeNativeStack(PRThreadStack* ts);
static void _PR_InitializeRecycledThread(PRThread* thread);
static void _PR_UserRunThread(void);

void _PR_InitThreads(PRThreadType type, PRThreadPriority priority,
                    PRUintn maxPTDs) {
 PRThread* thread;
 PRThreadStack* stack;

 PR_ASSERT(priority == PR_PRIORITY_NORMAL);

 _pr_terminationCVLock = PR_NewLock();
 _pr_activeLock = PR_NewLock();

#ifndef HAVE_CUSTOM_USER_THREADS
 stack = PR_NEWZAP(PRThreadStack);
#  ifdef HAVE_STACK_GROWING_UP
 stack->stackTop =
     (char*)((((PRWord)&type) >> _pr_pageShift) << _pr_pageShift);
#  else
#    if defined(SOLARIS)
 stack->stackTop = (char*)&thread;
#    else
 stack->stackTop =
     (char*)((((PRWord)&type + _pr_pageSize - 1) >> _pr_pageShift)
             << _pr_pageShift);
#    endif
#  endif
#else
 /* If stack is NULL, we're using custom user threads like NT fibers. */
 stack = PR_NEWZAP(PRThreadStack);
 if (stack) {
   stack->stackSize = 0;
   _PR_InitializeNativeStack(stack);
 }
#endif /* HAVE_CUSTOM_USER_THREADS */

 thread = _PR_AttachThread(type, priority, stack);
 if (thread) {
   _PR_MD_SET_CURRENT_THREAD(thread);

   if (type == PR_SYSTEM_THREAD) {
     thread->flags = _PR_SYSTEM;
     _pr_systemActive++;
     _pr_primordialExitCount = 0;
   } else {
     _pr_userActive++;
     _pr_primordialExitCount = 1;
   }
   thread->no_sched = 1;
   _pr_primordialExitCVar = PR_NewCondVar(_pr_activeLock);
 }

 if (!thread) {
   PR_Abort();
 }
#ifdef _PR_LOCAL_THREADS_ONLY
 thread->flags |= _PR_PRIMORDIAL;
#else
 thread->flags |= _PR_PRIMORDIAL | _PR_GLOBAL_SCOPE;
#endif

 /*
  * Needs _PR_PRIMORDIAL flag set before calling
  * _PR_MD_INIT_THREAD()
  */
 if (_PR_MD_INIT_THREAD(thread) == PR_FAILURE) {
   /*
    * XXX do what?
    */
 }

 if (_PR_IS_NATIVE_THREAD(thread)) {
   PR_APPEND_LINK(&thread->active, &_PR_ACTIVE_GLOBAL_THREADQ());
   _pr_global_threads++;
 } else {
   PR_APPEND_LINK(&thread->active, &_PR_ACTIVE_LOCAL_THREADQ());
   _pr_local_threads++;
 }

 _pr_recycleThreads = 0;
 _pr_deadQLock = PR_NewLock();
 _pr_numNativeDead = 0;
 _pr_numUserDead = 0;
 PR_INIT_CLIST(&_pr_deadNativeQ);
 PR_INIT_CLIST(&_pr_deadUserQ);
}

void _PR_CleanupThreads(void) {
 if (_pr_terminationCVLock) {
   PR_DestroyLock(_pr_terminationCVLock);
   _pr_terminationCVLock = NULL;
 }
 if (_pr_activeLock) {
   PR_DestroyLock(_pr_activeLock);
   _pr_activeLock = NULL;
 }
 if (_pr_primordialExitCVar) {
   PR_DestroyCondVar(_pr_primordialExitCVar);
   _pr_primordialExitCVar = NULL;
 }
 /* TODO _pr_dead{Native,User}Q need to be deleted */
 if (_pr_deadQLock) {
   PR_DestroyLock(_pr_deadQLock);
   _pr_deadQLock = NULL;
 }
}

/*
** Initialize a stack for a native thread
*/
static void _PR_InitializeNativeStack(PRThreadStack* ts) {
 if (ts && (ts->stackTop == 0)) {
   ts->allocSize = ts->stackSize;

   /*
   ** Setup stackTop and stackBottom values.
   */
#ifdef HAVE_STACK_GROWING_UP
   ts->allocBase = (char*)((((PRWord)&ts) >> _pr_pageShift) << _pr_pageShift);
   ts->stackBottom = ts->allocBase + ts->stackSize;
   ts->stackTop = ts->allocBase;
#else
   ts->allocBase = (char*)((((PRWord)&ts + _pr_pageSize - 1) >> _pr_pageShift)
                           << _pr_pageShift);
   ts->stackTop = ts->allocBase;
   ts->stackBottom = ts->allocBase - ts->stackSize;
#endif
 }
}

void _PR_NotifyJoinWaiters(PRThread* thread) {
 /*
 ** Handle joinable threads.  Change the state to waiting for join.
 ** Remove from our run Q and put it on global waiting to join Q.
 ** Notify on our "termination" condition variable so that joining
 ** thread will know about our termination.  Switch our context and
 ** come back later on to continue the cleanup.
 */
 PR_ASSERT(thread == _PR_MD_CURRENT_THREAD());
 if (thread->term != NULL) {
   PR_Lock(_pr_terminationCVLock);
   _PR_THREAD_LOCK(thread);
   thread->state = _PR_JOIN_WAIT;
   if (!_PR_IS_NATIVE_THREAD(thread)) {
     _PR_MISCQ_LOCK(thread->cpu);
     _PR_ADD_JOINQ(thread, thread->cpu);
     _PR_MISCQ_UNLOCK(thread->cpu);
   }
   _PR_THREAD_UNLOCK(thread);
   PR_NotifyCondVar(thread->term);
   PR_Unlock(_pr_terminationCVLock);
   _PR_MD_WAIT(thread, PR_INTERVAL_NO_TIMEOUT);
   PR_ASSERT(thread->state != _PR_JOIN_WAIT);
 }
}

/*
* Zero some of the data members of a recycled thread.
*
* Note that we can do this either when a dead thread is added to
* the dead thread queue or when it is reused.  Here, we are doing
* this lazily, when the thread is reused in _PR_CreateThread().
*/
static void _PR_InitializeRecycledThread(PRThread* thread) {
 /*
  * Assert that the following data members are already zeroed
  * by _PR_CleanupThread().
  */
#ifdef DEBUG
 if (thread->privateData) {
   unsigned int i;
   for (i = 0; i < thread->tpdLength; i++) {
     PR_ASSERT(thread->privateData[i] == NULL);
   }
 }
#endif
 PR_ASSERT(thread->dumpArg == 0 && thread->dump == 0);
 PR_ASSERT(thread->errorString == 0 && thread->errorStringSize == 0);
 PR_ASSERT(thread->errorStringLength == 0);
 PR_ASSERT(thread->name == 0);

 /* Reset data members in thread structure */
 thread->errorCode = thread->osErrorCode = 0;
 thread->io_pending = thread->io_suspended = PR_FALSE;
 thread->environment = 0;
 PR_INIT_CLIST(&thread->lockList);
}

PRStatus _PR_RecycleThread(PRThread* thread) {
 if (_PR_IS_NATIVE_THREAD(thread) && _PR_NUM_DEADNATIVE < _pr_recycleThreads) {
   _PR_DEADQ_LOCK;
   PR_APPEND_LINK(&thread->links, &_PR_DEADNATIVEQ);
   _PR_INC_DEADNATIVE;
   _PR_DEADQ_UNLOCK;
   return (PR_SUCCESS);
 } else if (!_PR_IS_NATIVE_THREAD(thread) &&
            _PR_NUM_DEADUSER < _pr_recycleThreads) {
   _PR_DEADQ_LOCK;
   PR_APPEND_LINK(&thread->links, &_PR_DEADUSERQ);
   _PR_INC_DEADUSER;
   _PR_DEADQ_UNLOCK;
   return (PR_SUCCESS);
 }
 return (PR_FAILURE);
}

/*
* Decrement the active thread count, either _pr_systemActive or
* _pr_userActive, depending on whether the thread is a system thread
* or a user thread.  If all the user threads, except possibly
* the primordial thread, have terminated, we notify the primordial
* thread of this condition.
*
* Since this function will lock _pr_activeLock, do not call this
* function while holding the _pr_activeLock lock, as this will result
* in a deadlock.
*/

static void _PR_DecrActiveThreadCount(PRThread* thread) {
 PR_Lock(_pr_activeLock);
 if (thread->flags & _PR_SYSTEM) {
   _pr_systemActive--;
 } else {
   _pr_userActive--;
   if (_pr_userActive == _pr_primordialExitCount) {
     PR_NotifyCondVar(_pr_primordialExitCVar);
   }
 }
 PR_Unlock(_pr_activeLock);
}

/*
** Detach thread structure
*/
static void _PR_DestroyThread(PRThread* thread) {
 _PR_MD_FREE_LOCK(&thread->threadLock);
 PR_DELETE(thread);
}

void _PR_NativeDestroyThread(PRThread* thread) {
 if (thread->term) {
   PR_DestroyCondVar(thread->term);
   thread->term = 0;
 }
 if (NULL != thread->privateData) {
   PR_ASSERT(0 != thread->tpdLength);
   PR_DELETE(thread->privateData);
   thread->tpdLength = 0;
 }
 PR_DELETE(thread->stack);
 _PR_DestroyThread(thread);
}

void _PR_UserDestroyThread(PRThread* thread) {
 if (thread->term) {
   PR_DestroyCondVar(thread->term);
   thread->term = 0;
 }
 if (NULL != thread->privateData) {
   PR_ASSERT(0 != thread->tpdLength);
   PR_DELETE(thread->privateData);
   thread->tpdLength = 0;
 }
 _PR_MD_FREE_LOCK(&thread->threadLock);
 if (thread->threadAllocatedOnStack == 1) {
   _PR_MD_CLEAN_THREAD(thread);
   /*
    *  Because the no_sched field is set, this thread/stack will
    *  will not be re-used until the flag is cleared by the thread
    *  we will context switch to.
    */
   _PR_FreeStack(thread->stack);
 } else {
#ifdef WINNT
   _PR_MD_CLEAN_THREAD(thread);
#else
   /*
    * This assertion does not apply to NT.  On NT, every fiber
    * has its threadAllocatedOnStack equal to 0.  Elsewhere,
    * only the primordial thread has its threadAllocatedOnStack
    * equal to 0.
    */
   PR_ASSERT(thread->flags & _PR_PRIMORDIAL);
#endif
 }
}

/*
** Run a thread's start function. When the start function returns the
** thread is done executing and no longer needs the CPU. If there are no
** more user threads running then we can exit the program.
*/
void _PR_NativeRunThread(void* arg) {
 PRThread* thread = (PRThread*)arg;

 _PR_MD_SET_CURRENT_THREAD(thread);

 _PR_MD_SET_CURRENT_CPU(NULL);

 /* Set up the thread stack information */
 _PR_InitializeNativeStack(thread->stack);

 /* Set up the thread md information */
 if (_PR_MD_INIT_THREAD(thread) == PR_FAILURE) {
   /*
    * thread failed to initialize itself, possibly due to
    * failure to allocate per-thread resources
    */
   return;
 }

 while (1) {
   thread->state = _PR_RUNNING;

   /*
    * Add to list of active threads
    */
   PR_Lock(_pr_activeLock);
   PR_APPEND_LINK(&thread->active, &_PR_ACTIVE_GLOBAL_THREADQ());
   _pr_global_threads++;
   PR_Unlock(_pr_activeLock);

   (*thread->startFunc)(thread->arg);

   /*
    * The following two assertions are meant for NT asynch io.
    *
    * The thread should have no asynch io in progress when it
    * exits, otherwise the overlapped buffer, which is part of
    * the thread structure, would become invalid.
    */
   PR_ASSERT(thread->io_pending == PR_FALSE);
   /*
    * This assertion enforces the programming guideline that
    * if an io function times out or is interrupted, the thread
    * should close the fd to force the asynch io to abort
    * before it exits.  Right now, closing the fd is the only
    * way to clear the io_suspended flag.
    */
   PR_ASSERT(thread->io_suspended == PR_FALSE);

   /*
    * remove thread from list of active threads
    */
   PR_Lock(_pr_activeLock);
   PR_REMOVE_LINK(&thread->active);
   _pr_global_threads--;
   PR_Unlock(_pr_activeLock);

   PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("thread exiting"));

   /* All done, time to go away */
   _PR_CleanupThread(thread);

   _PR_NotifyJoinWaiters(thread);

   _PR_DecrActiveThreadCount(thread);

   thread->state = _PR_DEAD_STATE;

   if (!_pr_recycleThreads || (_PR_RecycleThread(thread) == PR_FAILURE)) {
     /*
      * thread not recycled
      * platform-specific thread exit processing
      *        - for stuff like releasing native-thread resources, etc.
      */
     _PR_MD_EXIT_THREAD(thread);
     /*
      * Free memory allocated for the thread
      */
     _PR_NativeDestroyThread(thread);
     /*
      * thread gone, cannot de-reference thread now
      */
     return;
   }

   /* Now wait for someone to activate us again... */
   _PR_MD_WAIT(thread, PR_INTERVAL_NO_TIMEOUT);
 }
}

static void _PR_UserRunThread(void) {
 PRThread* thread = _PR_MD_CURRENT_THREAD();
 PRIntn is;

 if (_MD_LAST_THREAD()) {
   _MD_LAST_THREAD()->no_sched = 0;
 }

#ifdef HAVE_CUSTOM_USER_THREADS
 if (thread->stack == NULL) {
   thread->stack = PR_NEWZAP(PRThreadStack);
   _PR_InitializeNativeStack(thread->stack);
 }
#endif /* HAVE_CUSTOM_USER_THREADS */

 while (1) {
   /* Run thread main */
   if (!_PR_IS_NATIVE_THREAD(thread)) {
     _PR_MD_SET_INTSOFF(0);
   }

   /*
    * Add to list of active threads
    */
   if (!(thread->flags & _PR_IDLE_THREAD)) {
     PR_Lock(_pr_activeLock);
     PR_APPEND_LINK(&thread->active, &_PR_ACTIVE_LOCAL_THREADQ());
     _pr_local_threads++;
     PR_Unlock(_pr_activeLock);
   }

   (*thread->startFunc)(thread->arg);

   /*
    * The following two assertions are meant for NT asynch io.
    *
    * The thread should have no asynch io in progress when it
    * exits, otherwise the overlapped buffer, which is part of
    * the thread structure, would become invalid.
    */
   PR_ASSERT(thread->io_pending == PR_FALSE);
   /*
    * This assertion enforces the programming guideline that
    * if an io function times out or is interrupted, the thread
    * should close the fd to force the asynch io to abort
    * before it exits.  Right now, closing the fd is the only
    * way to clear the io_suspended flag.
    */
   PR_ASSERT(thread->io_suspended == PR_FALSE);

   PR_Lock(_pr_activeLock);
   /*
    * remove thread from list of active threads
    */
   if (!(thread->flags & _PR_IDLE_THREAD)) {
     PR_REMOVE_LINK(&thread->active);
     _pr_local_threads--;
   }
   PR_Unlock(_pr_activeLock);
   PR_LOG(_pr_thread_lm, PR_LOG_MIN, ("thread exiting"));

   /* All done, time to go away */
   _PR_CleanupThread(thread);

   _PR_INTSOFF(is);

   _PR_NotifyJoinWaiters(thread);

   _PR_DecrActiveThreadCount(thread);

   thread->state = _PR_DEAD_STATE;

   if (!_pr_recycleThreads || (_PR_RecycleThread(thread) == PR_FAILURE)) {
     /*
     ** Destroy the thread resources
     */
     _PR_UserDestroyThread(thread);
   }

   /*
   ** Find another user thread to run. This cpu has finished the
   ** previous threads main and is now ready to run another thread.
   */
   {
     PRInt32 is;
     _PR_INTSOFF(is);
     _PR_MD_SWITCH_CONTEXT(thread);
   }

   /* Will land here when we get scheduled again if we are recycling... */
 }
}

void _PR_SetThreadPriority(PRThread* thread, PRThreadPriority newPri) {
 PRThread* me = _PR_MD_CURRENT_THREAD();
 PRIntn is;

 if (_PR_IS_NATIVE_THREAD(thread)) {
   _PR_MD_SET_PRIORITY(&(thread->md), newPri);
   return;
 }

 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSOFF(is);
 }
 _PR_THREAD_LOCK(thread);
 if (newPri != thread->priority) {
   _PRCPU* cpu = thread->cpu;

   switch (thread->state) {
     case _PR_RUNNING:
       /* Change my priority */

       _PR_RUNQ_LOCK(cpu);
       thread->priority = newPri;
       if (_PR_RUNQREADYMASK(cpu) >> (newPri + 1)) {
         if (!_PR_IS_NATIVE_THREAD(me)) {
           _PR_SET_RESCHED_FLAG();
         }
       }
       _PR_RUNQ_UNLOCK(cpu);
       break;

     case _PR_RUNNABLE:

       _PR_RUNQ_LOCK(cpu);
       /* Move to different runQ */
       _PR_DEL_RUNQ(thread);
       thread->priority = newPri;
       PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
       _PR_ADD_RUNQ(thread, cpu, newPri);
       _PR_RUNQ_UNLOCK(cpu);

       if (newPri > me->priority) {
         if (!_PR_IS_NATIVE_THREAD(me)) {
           _PR_SET_RESCHED_FLAG();
         }
       }

       break;

     case _PR_LOCK_WAIT:
     case _PR_COND_WAIT:
     case _PR_IO_WAIT:
     case _PR_SUSPENDED:

       thread->priority = newPri;
       break;
   }
 }
 _PR_THREAD_UNLOCK(thread);
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSON(is);
 }
}

/*
** Suspend the named thread and copy its gc registers into regBuf
*/
static void _PR_Suspend(PRThread* thread) {
 PRIntn is;
 PRThread* me = _PR_MD_CURRENT_THREAD();

 PR_ASSERT(thread != me);
 PR_ASSERT(!_PR_IS_NATIVE_THREAD(thread) || (!thread->cpu));

 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSOFF(is);
 }
 _PR_THREAD_LOCK(thread);
 switch (thread->state) {
   case _PR_RUNNABLE:
     if (!_PR_IS_NATIVE_THREAD(thread)) {
       _PR_RUNQ_LOCK(thread->cpu);
       _PR_DEL_RUNQ(thread);
       _PR_RUNQ_UNLOCK(thread->cpu);

       _PR_MISCQ_LOCK(thread->cpu);
       _PR_ADD_SUSPENDQ(thread, thread->cpu);
       _PR_MISCQ_UNLOCK(thread->cpu);
     } else {
       /*
        * Only LOCAL threads are suspended by _PR_Suspend
        */
       PR_ASSERT(0);
     }
     thread->state = _PR_SUSPENDED;
     break;

   case _PR_RUNNING:
     /*
      * The thread being suspended should be a LOCAL thread with
      * _pr_numCPUs == 1. Hence, the thread cannot be in RUNNING state
      */
     PR_ASSERT(0);
     break;

   case _PR_LOCK_WAIT:
   case _PR_IO_WAIT:
   case _PR_COND_WAIT:
     if (_PR_IS_NATIVE_THREAD(thread)) {
       _PR_MD_SUSPEND_THREAD(thread);
     }
     thread->flags |= _PR_SUSPENDING;
     break;

   default:
     PR_Abort();
 }
 _PR_THREAD_UNLOCK(thread);
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSON(is);
 }
}

static void _PR_Resume(PRThread* thread) {
 PRThreadPriority pri;
 PRIntn is;
 PRThread* me = _PR_MD_CURRENT_THREAD();

 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSOFF(is);
 }
 _PR_THREAD_LOCK(thread);
 switch (thread->state) {
   case _PR_SUSPENDED:
     thread->state = _PR_RUNNABLE;
     thread->flags &= ~_PR_SUSPENDING;
     if (!_PR_IS_NATIVE_THREAD(thread)) {
       _PR_MISCQ_LOCK(thread->cpu);
       _PR_DEL_SUSPENDQ(thread);
       _PR_MISCQ_UNLOCK(thread->cpu);

       pri = thread->priority;

       _PR_RUNQ_LOCK(thread->cpu);
       _PR_ADD_RUNQ(thread, thread->cpu, pri);
       _PR_RUNQ_UNLOCK(thread->cpu);

       if (pri > _PR_MD_CURRENT_THREAD()->priority) {
         if (!_PR_IS_NATIVE_THREAD(me)) {
           _PR_SET_RESCHED_FLAG();
         }
       }
     } else {
       PR_ASSERT(0);
     }
     break;

   case _PR_IO_WAIT:
   case _PR_COND_WAIT:
     thread->flags &= ~_PR_SUSPENDING;
     /*      PR_ASSERT(thread->wait.monitor->stickyCount == 0); */
     break;

   case _PR_LOCK_WAIT: {
     PRLock* wLock = thread->wait.lock;

     thread->flags &= ~_PR_SUSPENDING;

     _PR_LOCK_LOCK(wLock);
     if (thread->wait.lock->owner == 0) {
       _PR_UnblockLockWaiter(thread->wait.lock);
     }
     _PR_LOCK_UNLOCK(wLock);
     break;
   }
   case _PR_RUNNABLE:
     break;
   case _PR_RUNNING:
     /*
      * The thread being suspended should be a LOCAL thread with
      * _pr_numCPUs == 1. Hence, the thread cannot be in RUNNING state
      */
     PR_ASSERT(0);
     break;

   default:
     /*
      * thread should have been in one of the above-listed blocked states
      * (_PR_JOIN_WAIT, _PR_IO_WAIT, _PR_UNBORN, _PR_DEAD_STATE)
      */
     PR_Abort();
 }
 _PR_THREAD_UNLOCK(thread);
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSON(is);
 }
}

#if !defined(_PR_LOCAL_THREADS_ONLY) && defined(XP_UNIX)
static PRThread* get_thread(_PRCPU* cpu, PRBool* wakeup_cpus) {
 PRThread* thread;
 PRIntn pri;
 PRUint32 r;
 PRCList* qp;
 PRIntn priMin, priMax;

 _PR_RUNQ_LOCK(cpu);
 r = _PR_RUNQREADYMASK(cpu);
 if (r == 0) {
   priMin = priMax = PR_PRIORITY_FIRST;
 } else if (r == (1 << PR_PRIORITY_NORMAL)) {
   priMin = priMax = PR_PRIORITY_NORMAL;
 } else {
   priMin = PR_PRIORITY_FIRST;
   priMax = PR_PRIORITY_LAST;
 }
 thread = NULL;
 for (pri = priMax; pri >= priMin; pri--) {
   if (r & (1 << pri)) {
     for (qp = _PR_RUNQ(cpu)[pri].next; qp != &_PR_RUNQ(cpu)[pri];
          qp = qp->next) {
       thread = _PR_THREAD_PTR(qp);
       /*
        * skip non-schedulable threads
        */
       PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
       if (thread->no_sched) {
         thread = NULL;
         /*
          * Need to wakeup cpus to avoid missing a
          * runnable thread
          * Waking up all CPU's need happen only once.
          */

         *wakeup_cpus = PR_TRUE;
         continue;
       } else if (thread->flags & _PR_BOUND_THREAD) {
         /*
          * Thread bound to cpu 0
          */

         thread = NULL;
         continue;
       } else if (thread->io_pending == PR_TRUE) {
         /*
          * A thread that is blocked for I/O needs to run
          * on the same cpu on which it was blocked. This is because
          * the cpu's ioq is accessed without lock protection and scheduling
          * the thread on a different cpu would preclude this optimization.
          */
         thread = NULL;
         continue;
       } else {
         /* Pull thread off of its run queue */
         _PR_DEL_RUNQ(thread);
         _PR_RUNQ_UNLOCK(cpu);
         return (thread);
       }
     }
   }
   thread = NULL;
 }
 _PR_RUNQ_UNLOCK(cpu);
 return (thread);
}
#endif /* !defined(_PR_LOCAL_THREADS_ONLY) && defined(XP_UNIX) */

/*
** Schedule this native thread by finding the highest priority nspr
** thread that is ready to run.
**
** Note- everyone really needs to call _PR_MD_SWITCH_CONTEXT (which calls
**       PR_Schedule() rather than calling PR_Schedule.  Otherwise if there
**       is initialization required for switching from SWITCH_CONTEXT,
**       it will not get done!
*/
void _PR_Schedule(void) {
 PRThread *thread, *me = _PR_MD_CURRENT_THREAD();
 _PRCPU* cpu = _PR_MD_CURRENT_CPU();
 PRIntn pri;
 PRUint32 r;
 PRCList* qp;
 PRIntn priMin, priMax;
#if !defined(_PR_LOCAL_THREADS_ONLY) && defined(XP_UNIX)
 PRBool wakeup_cpus;
#endif

 /* Interrupts must be disabled */
 PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0);

 /* Since we are rescheduling, we no longer want to */
 _PR_CLEAR_RESCHED_FLAG();

 /*
 ** Find highest priority thread to run. Bigger priority numbers are
 ** higher priority threads
 */
 _PR_RUNQ_LOCK(cpu);
 /*
  *  if we are in SuspendAll mode, can schedule only the thread
  *    that called PR_SuspendAll
  *
  *  The thread may be ready to run now, after completing an I/O
  *  operation, for example
  */
 if ((thread = suspendAllThread) != 0) {
   if ((!(thread->no_sched)) && (thread->state == _PR_RUNNABLE)) {
     /* Pull thread off of its run queue */
     _PR_DEL_RUNQ(thread);
     _PR_RUNQ_UNLOCK(cpu);
     goto found_thread;
   } else {
     thread = NULL;
     _PR_RUNQ_UNLOCK(cpu);
     goto idle_thread;
   }
 }
 r = _PR_RUNQREADYMASK(cpu);
 if (r == 0) {
   priMin = priMax = PR_PRIORITY_FIRST;
 } else if (r == (1 << PR_PRIORITY_NORMAL)) {
   priMin = priMax = PR_PRIORITY_NORMAL;
 } else {
   priMin = PR_PRIORITY_FIRST;
   priMax = PR_PRIORITY_LAST;
 }
 thread = NULL;
 for (pri = priMax; pri >= priMin; pri--) {
   if (r & (1 << pri)) {
     for (qp = _PR_RUNQ(cpu)[pri].next; qp != &_PR_RUNQ(cpu)[pri];
          qp = qp->next) {
       thread = _PR_THREAD_PTR(qp);
       /*
        * skip non-schedulable threads
        */
       PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
       if ((thread->no_sched) && (me != thread)) {
         thread = NULL;
         continue;
       } else {
         /* Pull thread off of its run queue */
         _PR_DEL_RUNQ(thread);
         _PR_RUNQ_UNLOCK(cpu);
         goto found_thread;
       }
     }
   }
   thread = NULL;
 }
 _PR_RUNQ_UNLOCK(cpu);

#if !defined(_PR_LOCAL_THREADS_ONLY) && defined(XP_UNIX)

 wakeup_cpus = PR_FALSE;
 _PR_CPU_LIST_LOCK();
 for (qp = _PR_CPUQ().next; qp != &_PR_CPUQ(); qp = qp->next) {
   if (cpu != _PR_CPU_PTR(qp)) {
     if ((thread = get_thread(_PR_CPU_PTR(qp), &wakeup_cpus)) != NULL) {
       thread->cpu = cpu;
       _PR_CPU_LIST_UNLOCK();
       if (wakeup_cpus == PR_TRUE) {
         _PR_MD_WAKEUP_CPUS();
       }
       goto found_thread;
     }
   }
 }
 _PR_CPU_LIST_UNLOCK();
 if (wakeup_cpus == PR_TRUE) {
   _PR_MD_WAKEUP_CPUS();
 }

#endif /* _PR_LOCAL_THREADS_ONLY */

idle_thread:
 /*
  ** There are no threads to run. Switch to the idle thread
  */
 PR_LOG(_pr_sched_lm, PR_LOG_MAX, ("pausing"));
 thread = _PR_MD_CURRENT_CPU()->idle_thread;

found_thread:
 PR_ASSERT((me == thread) ||
           ((thread->state == _PR_RUNNABLE) && (!(thread->no_sched))));

 /* Resume the thread */
 PR_LOG(_pr_sched_lm, PR_LOG_MAX, ("switching to %d[%p]", thread->id, thread));
 PR_ASSERT(thread->state != _PR_RUNNING);
 thread->state = _PR_RUNNING;

 /* If we are on the runq, it just means that we went to sleep on some
  * resource, and by the time we got here another real native thread had
  * already given us the resource and put us back on the runqueue
  */
 PR_ASSERT(thread->cpu == _PR_MD_CURRENT_CPU());
 if (thread != me) {
   _PR_MD_RESTORE_CONTEXT(thread);
 }
#if 0
   /* XXXMB; with setjmp/longjmp it is impossible to land here, but
    * it is not with fibers... Is this a bad thing?  I believe it is
    * still safe.
    */
   PR_NOT_REACHED("impossible return from schedule");
#endif
}

/*
** Attaches a thread.
** Does not set the _PR_MD_CURRENT_THREAD.
** Does not specify the scope of the thread.
*/
static PRThread* _PR_AttachThread(PRThreadType type, PRThreadPriority priority,
                                 PRThreadStack* stack) {
 PRThread* thread;
 char* mem;

 if (priority > PR_PRIORITY_LAST) {
   priority = PR_PRIORITY_LAST;
 } else if (priority < PR_PRIORITY_FIRST) {
   priority = PR_PRIORITY_FIRST;
 }

 mem = (char*)PR_CALLOC(sizeof(PRThread));
 if (mem) {
   thread = (PRThread*)mem;
   thread->priority = priority;
   thread->stack = stack;
   thread->state = _PR_RUNNING;
   PR_INIT_CLIST(&thread->lockList);
   if (_PR_MD_NEW_LOCK(&thread->threadLock) == PR_FAILURE) {
     PR_DELETE(thread);
     return 0;
   }

   return thread;
 }
 return 0;
}

PR_IMPLEMENT(PRThread*)
_PR_NativeCreateThread(PRThreadType type, void (*start)(void* arg), void* arg,
                      PRThreadPriority priority, PRThreadScope scope,
                      PRThreadState state, PRUint32 stackSize,
                      PRUint32 flags) {
 PRThread* thread;

 thread = _PR_AttachThread(type, priority, NULL);

 if (thread) {
   PR_Lock(_pr_activeLock);
   thread->flags = (flags | _PR_GLOBAL_SCOPE);
   thread->id = ++_pr_utid;
   if (type == PR_SYSTEM_THREAD) {
     thread->flags |= _PR_SYSTEM;
     _pr_systemActive++;
   } else {
     _pr_userActive++;
   }
   PR_Unlock(_pr_activeLock);

   thread->stack = PR_NEWZAP(PRThreadStack);
   if (!thread->stack) {
     PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
     goto done;
   }
   thread->stack->stackSize = stackSize ? stackSize : _MD_DEFAULT_STACK_SIZE;
   thread->stack->thr = thread;
   thread->startFunc = start;
   thread->arg = arg;

   /*
     Set thread flags related to scope and joinable state. If joinable
     thread, allocate a "termination" conidition variable.
    */
   if (state == PR_JOINABLE_THREAD) {
     thread->term = PR_NewCondVar(_pr_terminationCVLock);
     if (thread->term == NULL) {
       PR_DELETE(thread->stack);
       goto done;
     }
   }

   thread->state = _PR_RUNNING;
   if (_PR_MD_CREATE_THREAD(thread, _PR_NativeRunThread, priority, scope,
                            state, stackSize) == PR_SUCCESS) {
     return thread;
   }
   if (thread->term) {
     PR_DestroyCondVar(thread->term);
     thread->term = NULL;
   }
   PR_DELETE(thread->stack);
 }

done:
 if (thread) {
   _PR_DecrActiveThreadCount(thread);
   _PR_DestroyThread(thread);
 }
 return NULL;
}

/************************************************************************/

PR_IMPLEMENT(PRThread*)
_PR_CreateThread(PRThreadType type, void (*start)(void* arg), void* arg,
                PRThreadPriority priority, PRThreadScope scope,
                PRThreadState state, PRUint32 stackSize, PRUint32 flags) {
 PRThread* me;
 PRThread* thread = NULL;
 PRThreadStack* stack;
 char* top;
 PRIntn is;
 PRIntn native = 0;
 PRIntn useRecycled = 0;
 PRBool status;

 /*
 First, pin down the priority.  Not all compilers catch passing out of
 range enum here.  If we let bad values thru, priority queues won't work.
 */
 if (priority > PR_PRIORITY_LAST) {
   priority = PR_PRIORITY_LAST;
 } else if (priority < PR_PRIORITY_FIRST) {
   priority = PR_PRIORITY_FIRST;
 }

 if (!_pr_initialized) {
   _PR_ImplicitInitialization();
 }

 if (!(flags & _PR_IDLE_THREAD)) {
   me = _PR_MD_CURRENT_THREAD();
 }

#if defined(_PR_GLOBAL_THREADS_ONLY)
 /*
  * can create global threads only
  */
 if (scope == PR_LOCAL_THREAD) {
   scope = PR_GLOBAL_THREAD;
 }
#endif

 if (_native_threads_only) {
   scope = PR_GLOBAL_THREAD;
 }

 native =
     (((scope == PR_GLOBAL_THREAD) || (scope == PR_GLOBAL_BOUND_THREAD)) &&
      _PR_IS_NATIVE_THREAD_SUPPORTED());

 _PR_ADJUST_STACKSIZE(stackSize);

 if (native) {
   /*
    * clear the IDLE_THREAD flag which applies to LOCAL
    * threads only
    */
   flags &= ~_PR_IDLE_THREAD;
   flags |= _PR_GLOBAL_SCOPE;
   if (_PR_NUM_DEADNATIVE > 0) {
     _PR_DEADQ_LOCK;

     if (_PR_NUM_DEADNATIVE == 0) { /* Thread safe check */
       _PR_DEADQ_UNLOCK;
     } else {
       thread = _PR_THREAD_PTR(_PR_DEADNATIVEQ.next);
       PR_REMOVE_LINK(&thread->links);
       _PR_DEC_DEADNATIVE;
       _PR_DEADQ_UNLOCK;

       _PR_InitializeRecycledThread(thread);
       thread->startFunc = start;
       thread->arg = arg;
       thread->flags = (flags | _PR_GLOBAL_SCOPE);
       if (type == PR_SYSTEM_THREAD) {
         thread->flags |= _PR_SYSTEM;
         PR_ATOMIC_INCREMENT(&_pr_systemActive);
       } else {
         PR_ATOMIC_INCREMENT(&_pr_userActive);
       }

       if (state == PR_JOINABLE_THREAD) {
         if (!thread->term) {
           thread->term = PR_NewCondVar(_pr_terminationCVLock);
         }
       } else {
         if (thread->term) {
           PR_DestroyCondVar(thread->term);
           thread->term = 0;
         }
       }

       thread->priority = priority;
       _PR_MD_SET_PRIORITY(&(thread->md), priority);
       /* XXX what about stackSize? */
       thread->state = _PR_RUNNING;
       _PR_MD_WAKEUP_WAITER(thread);
       return thread;
     }
   }
   thread = _PR_NativeCreateThread(type, start, arg, priority, scope, state,
                                   stackSize, flags);
 } else {
   if (_PR_NUM_DEADUSER > 0) {
     _PR_DEADQ_LOCK;

     if (_PR_NUM_DEADUSER == 0) { /* thread safe check */
       _PR_DEADQ_UNLOCK;
     } else {
       PRCList* ptr;

       /* Go down list checking for a recycled thread with a
        * large enough stack.  XXXMB - this has a bad degenerate case.
        */
       ptr = _PR_DEADUSERQ.next;
       while (ptr != &_PR_DEADUSERQ) {
         thread = _PR_THREAD_PTR(ptr);
         if ((thread->stack->stackSize >= stackSize) && (!thread->no_sched)) {
           PR_REMOVE_LINK(&thread->links);
           _PR_DEC_DEADUSER;
           break;
         } else {
           ptr = ptr->next;
           thread = NULL;
         }
       }

       _PR_DEADQ_UNLOCK;

       if (thread) {
         _PR_InitializeRecycledThread(thread);
         thread->startFunc = start;
         thread->arg = arg;
         thread->priority = priority;
         if (state == PR_JOINABLE_THREAD) {
           if (!thread->term) {
             thread->term = PR_NewCondVar(_pr_terminationCVLock);
           }
         } else {
           if (thread->term) {
             PR_DestroyCondVar(thread->term);
             thread->term = 0;
           }
         }
         useRecycled++;
       }
     }
   }
   if (thread == NULL) {
#ifndef HAVE_CUSTOM_USER_THREADS
     stack = _PR_NewStack(stackSize);
     if (!stack) {
       PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
       return NULL;
     }

     /* Allocate thread object and per-thread data off the top of the stack*/
     top = stack->stackTop;
#  ifdef HAVE_STACK_GROWING_UP
     thread = (PRThread*)top;
     top = top + sizeof(PRThread);
     /*
      * Make stack 64-byte aligned
      */
     if ((PRUptrdiff)top & 0x3f) {
       top = (char*)(((PRUptrdiff)top + 0x40) & ~0x3f);
     }
#  else
     top = top - sizeof(PRThread);
     thread = (PRThread*)top;
     /*
      * Make stack 64-byte aligned
      */
     if ((PRUptrdiff)top & 0x3f) {
       top = (char*)((PRUptrdiff)top & ~0x3f);
     }
#  endif
     stack->thr = thread;
     memset(thread, 0, sizeof(PRThread));
     thread->threadAllocatedOnStack = 1;
#else
     thread = _PR_MD_CREATE_USER_THREAD(stackSize, start, arg);
     if (!thread) {
       PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
       return NULL;
     }
     thread->threadAllocatedOnStack = 0;
     stack = NULL;
     top = NULL;
#endif

     /* Initialize thread */
     thread->tpdLength = 0;
     thread->privateData = NULL;
     thread->stack = stack;
     thread->priority = priority;
     thread->startFunc = start;
     thread->arg = arg;
     PR_INIT_CLIST(&thread->lockList);

     if (_PR_MD_INIT_THREAD(thread) == PR_FAILURE) {
       if (thread->threadAllocatedOnStack == 1) {
         _PR_FreeStack(thread->stack);
       } else {
         PR_DELETE(thread);
       }
       PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, 0);
       return NULL;
     }

     if (_PR_MD_NEW_LOCK(&thread->threadLock) == PR_FAILURE) {
       if (thread->threadAllocatedOnStack == 1) {
         _PR_FreeStack(thread->stack);
       } else {
         PR_DELETE(thread->privateData);
         PR_DELETE(thread);
       }
       PR_SetError(PR_INSUFFICIENT_RESOURCES_ERROR, 0);
       return NULL;
     }

     _PR_MD_INIT_CONTEXT(thread, top, _PR_UserRunThread, &status);

     if (status == PR_FALSE) {
       _PR_MD_FREE_LOCK(&thread->threadLock);
       if (thread->threadAllocatedOnStack == 1) {
         _PR_FreeStack(thread->stack);
       } else {
         PR_DELETE(thread->privateData);
         PR_DELETE(thread);
       }
       return NULL;
     }

     /*
       Set thread flags related to scope and joinable state. If joinable
       thread, allocate a "termination" condition variable.
     */
     if (state == PR_JOINABLE_THREAD) {
       thread->term = PR_NewCondVar(_pr_terminationCVLock);
       if (thread->term == NULL) {
         _PR_MD_FREE_LOCK(&thread->threadLock);
         if (thread->threadAllocatedOnStack == 1) {
           _PR_FreeStack(thread->stack);
         } else {
           PR_DELETE(thread->privateData);
           PR_DELETE(thread);
         }
         return NULL;
       }
     }
   }

   /* Update thread type counter */
   PR_Lock(_pr_activeLock);
   thread->flags = flags;
   thread->id = ++_pr_utid;
   if (type == PR_SYSTEM_THREAD) {
     thread->flags |= _PR_SYSTEM;
     _pr_systemActive++;
   } else {
     _pr_userActive++;
   }

   /* Make thread runnable */
   thread->state = _PR_RUNNABLE;
   /*
    * Add to list of active threads
    */
   PR_Unlock(_pr_activeLock);

   if ((!(thread->flags & _PR_IDLE_THREAD)) && _PR_IS_NATIVE_THREAD(me)) {
     thread->cpu = _PR_GetPrimordialCPU();
   } else {
     thread->cpu = _PR_MD_CURRENT_CPU();
   }

   PR_ASSERT(!_PR_IS_NATIVE_THREAD(thread));

   if ((!(thread->flags & _PR_IDLE_THREAD)) && !_PR_IS_NATIVE_THREAD(me)) {
     _PR_INTSOFF(is);
     _PR_RUNQ_LOCK(thread->cpu);
     _PR_ADD_RUNQ(thread, thread->cpu, priority);
     _PR_RUNQ_UNLOCK(thread->cpu);
   }

   if (thread->flags & _PR_IDLE_THREAD) {
     /*
     ** If the creating thread is a kernel thread, we need to
     ** awaken the user thread idle thread somehow; potentially
     ** it could be sleeping in its idle loop, and we need to poke
     ** it.  To do so, wake the idle thread...
     */
     _PR_MD_WAKEUP_WAITER(NULL);
   } else if (_PR_IS_NATIVE_THREAD(me)) {
     _PR_MD_WAKEUP_WAITER(thread);
   }
   if ((!(thread->flags & _PR_IDLE_THREAD)) && !_PR_IS_NATIVE_THREAD(me)) {
     _PR_INTSON(is);
   }
 }

 return thread;
}

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,
                         0);
}

/*
** Associate a thread object with an existing native thread.
**     "type" is the type of thread object to attach
**     "priority" is the priority to assign to the thread
**     "stack" defines the shape of the threads stack
**
** This can return NULL if some kind of error occurs, or if memory is
** tight.
**
** This call is not normally needed unless you create your own native
** thread. PR_Init does this automatically for the primordial thread.
*/
PRThread* _PRI_AttachThread(PRThreadType type, PRThreadPriority priority,
                           PRThreadStack* stack, PRUint32 flags) {
 PRThread* thread;

 if ((thread = _PR_MD_GET_ATTACHED_THREAD()) != NULL) {
   return thread;
 }
 _PR_MD_SET_CURRENT_THREAD(NULL);

 /* Clear out any state if this thread was attached before */
 _PR_MD_SET_CURRENT_CPU(NULL);

 thread = _PR_AttachThread(type, priority, stack);
 if (thread) {
   PRIntn is;

   _PR_MD_SET_CURRENT_THREAD(thread);

   thread->flags = flags | _PR_GLOBAL_SCOPE | _PR_ATTACHED;

   if (!stack) {
     thread->stack = PR_NEWZAP(PRThreadStack);
     if (!thread->stack) {
       _PR_DestroyThread(thread);
       return NULL;
     }
     thread->stack->stackSize = _MD_DEFAULT_STACK_SIZE;
   }
   PR_INIT_CLIST(&thread->links);

   if (_PR_MD_INIT_ATTACHED_THREAD(thread) == PR_FAILURE) {
     PR_DELETE(thread->stack);
     _PR_DestroyThread(thread);
     return NULL;
   }

   _PR_MD_SET_CURRENT_CPU(NULL);

   if (_PR_MD_CURRENT_CPU()) {
     _PR_INTSOFF(is);
     PR_Lock(_pr_activeLock);
   }
   if (type == PR_SYSTEM_THREAD) {
     thread->flags |= _PR_SYSTEM;
     _pr_systemActive++;
   } else {
     _pr_userActive++;
   }
   if (_PR_MD_CURRENT_CPU()) {
     PR_Unlock(_pr_activeLock);
     _PR_INTSON(is);
   }
 }
 return thread;
}

PR_IMPLEMENT(PRThread*)
PR_AttachThread(PRThreadType type, PRThreadPriority priority,
               PRThreadStack* stack) {
 return PR_GetCurrentThread();
}

PR_IMPLEMENT(void) PR_DetachThread(void) {
 /*
  * On Solaris, and Windows, foreign threads are detached when
  * they terminate.
  */
#if !defined(WIN32) && !(defined(SOLARIS) && defined(_PR_GLOBAL_THREADS_ONLY))
 PRThread* me;
 if (_pr_initialized) {
   me = _PR_MD_GET_ATTACHED_THREAD();
   if ((me != NULL) && (me->flags & _PR_ATTACHED)) {
     _PRI_DetachThread();
   }
 }
#endif
}

void _PRI_DetachThread(void) {
 PRThread* me = _PR_MD_CURRENT_THREAD();

 if (me->flags & _PR_PRIMORDIAL) {
   /*
    * ignore, if primordial thread
    */
   return;
 }
 PR_ASSERT(me->flags & _PR_ATTACHED);
 PR_ASSERT(_PR_IS_NATIVE_THREAD(me));
 _PR_CleanupThread(me);
 PR_DELETE(me->privateData);

 _PR_DecrActiveThreadCount(me);

 _PR_MD_CLEAN_THREAD(me);
 _PR_MD_SET_CURRENT_THREAD(NULL);
 if (!me->threadAllocatedOnStack) {
   PR_DELETE(me->stack);
 }
 _PR_MD_FREE_LOCK(&me->threadLock);
 PR_DELETE(me);
}

/*
** Wait for thread termination:
**     "thread" is the target thread
**
** This can return PR_FAILURE if no joinable thread could be found
** corresponding to the specified target thread.
**
** The calling thread is suspended until the target thread completes.
** Several threads cannot wait for the same thread to complete; one thread
** will complete successfully and others will terminate with an error
*PR_FAILURE.
** The calling thread will not be blocked if the target thread has already
** terminated.
*/
PR_IMPLEMENT(PRStatus) PR_JoinThread(PRThread* thread) {
 PRIntn is;
 PRCondVar* term;
 PRThread* me = _PR_MD_CURRENT_THREAD();

 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSOFF(is);
 }
 term = thread->term;
 /* can't join a non-joinable thread */
 if (term == NULL) {
   PR_SetError(PR_INVALID_ARGUMENT_ERROR, 0);
   goto ErrorExit;
 }

 /* multiple threads can't wait on the same joinable thread */
 if (term->condQ.next != &term->condQ) {
   goto ErrorExit;
 }
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSON(is);
 }

 /* wait for the target thread's termination cv invariant */
 PR_Lock(_pr_terminationCVLock);
 while (thread->state != _PR_JOIN_WAIT) {
   (void)PR_WaitCondVar(term, PR_INTERVAL_NO_TIMEOUT);
 }
 (void)PR_Unlock(_pr_terminationCVLock);

 /*
  Remove target thread from global waiting to join Q; make it runnable
  again and put it back on its run Q.  When it gets scheduled later in
  _PR_RunThread code, it will clean up its stack.
 */
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSOFF(is);
 }
 thread->state = _PR_RUNNABLE;
 if (!_PR_IS_NATIVE_THREAD(thread)) {
   _PR_THREAD_LOCK(thread);

   _PR_MISCQ_LOCK(thread->cpu);
   _PR_DEL_JOINQ(thread);
   _PR_MISCQ_UNLOCK(thread->cpu);

   _PR_AddThreadToRunQ(me, thread);
   _PR_THREAD_UNLOCK(thread);
 }
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSON(is);
 }

 _PR_MD_WAKEUP_WAITER(thread);

 return PR_SUCCESS;

ErrorExit:
 if (!_PR_IS_NATIVE_THREAD(me)) {
   _PR_INTSON(is);
 }
 return PR_FAILURE;
}

PR_IMPLEMENT(void)
PR_SetThreadPriority(PRThread* thread, PRThreadPriority newPri) {
 /*
 First, pin down the priority.  Not all compilers catch passing out of
 range enum here.  If we let bad values thru, priority queues won't work.
 */
 if ((PRIntn)newPri > (PRIntn)PR_PRIORITY_LAST) {
   newPri = PR_PRIORITY_LAST;
 } else if ((PRIntn)newPri < (PRIntn)PR_PRIORITY_FIRST) {
   newPri = PR_PRIORITY_FIRST;
 }

 if (_PR_IS_NATIVE_THREAD(thread)) {
   thread->priority = newPri;
   _PR_MD_SET_PRIORITY(&(thread->md), newPri);
 } else {
   _PR_SetThreadPriority(thread, newPri);
 }
}

PR_IMPLEMENT(PRStatus) PR_SetCurrentThreadName(const char* name) {
 PRThread* thread;
 size_t nameLen;

 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);
 _PR_MD_SET_CURRENT_THREAD_NAME(thread->name);
 return PR_SUCCESS;
}

PR_IMPLEMENT(const char*) PR_GetThreadName(const PRThread* thread) {
 if (!thread) {
   return NULL;
 }
 return thread->name;
}

/*
** This routine prevents all other threads from running. This call is needed by
** the garbage collector.
*/
PR_IMPLEMENT(void) PR_SuspendAll(void) {
 PRThread* me = _PR_MD_CURRENT_THREAD();
 PRCList* qp;

 /*
  * Stop all user and native threads which are marked GC able.
  */
 PR_Lock(_pr_activeLock);
 suspendAllOn = PR_TRUE;
 suspendAllThread = _PR_MD_CURRENT_THREAD();
 _PR_MD_BEGIN_SUSPEND_ALL();
 for (qp = _PR_ACTIVE_LOCAL_THREADQ().next; qp != &_PR_ACTIVE_LOCAL_THREADQ();
      qp = qp->next) {
   if ((me != _PR_ACTIVE_THREAD_PTR(qp)) &&
       _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) {
     _PR_Suspend(_PR_ACTIVE_THREAD_PTR(qp));
     PR_ASSERT((_PR_ACTIVE_THREAD_PTR(qp))->state != _PR_RUNNING);
   }
 }
 for (qp = _PR_ACTIVE_GLOBAL_THREADQ().next;
      qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp->next) {
   if ((me != _PR_ACTIVE_THREAD_PTR(qp)) &&
       _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp)))
   /* PR_Suspend(_PR_ACTIVE_THREAD_PTR(qp)); */
   {
     _PR_MD_SUSPEND_THREAD(_PR_ACTIVE_THREAD_PTR(qp));
   }
 }
 _PR_MD_END_SUSPEND_ALL();
}

/*
** This routine unblocks all other threads that were suspended from running by
** PR_SuspendAll(). This call is needed by the garbage collector.
*/
PR_IMPLEMENT(void) PR_ResumeAll(void) {
 PRThread* me = _PR_MD_CURRENT_THREAD();
 PRCList* qp;

 /*
  * Resume all user and native threads which are marked GC able.
  */
 _PR_MD_BEGIN_RESUME_ALL();
 for (qp = _PR_ACTIVE_LOCAL_THREADQ().next; qp != &_PR_ACTIVE_LOCAL_THREADQ();
      qp = qp->next) {
   if ((me != _PR_ACTIVE_THREAD_PTR(qp)) &&
       _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) {
     _PR_Resume(_PR_ACTIVE_THREAD_PTR(qp));
   }
 }
 for (qp = _PR_ACTIVE_GLOBAL_THREADQ().next;
      qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp->next) {
   if ((me != _PR_ACTIVE_THREAD_PTR(qp)) &&
       _PR_IS_GCABLE_THREAD(_PR_ACTIVE_THREAD_PTR(qp))) {
     _PR_MD_RESUME_THREAD(_PR_ACTIVE_THREAD_PTR(qp));
   }
 }
 _PR_MD_END_RESUME_ALL();
 suspendAllThread = NULL;
 suspendAllOn = PR_FALSE;
 PR_Unlock(_pr_activeLock);
}

PR_IMPLEMENT(PRStatus) PR_EnumerateThreads(PREnumerator func, void* arg) {
 PRCList *qp, *qp_next;
 PRIntn i = 0;
 PRStatus rv = PR_SUCCESS;
 PRThread* t;

 /*
 ** Currently Enumerate threads happen only with suspension and
 ** pr_activeLock held
 */
 PR_ASSERT(suspendAllOn);

 /* 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".
  */

 /*
  * Traverse the list of local and global threads
  */
 for (qp = _PR_ACTIVE_LOCAL_THREADQ().next; qp != &_PR_ACTIVE_LOCAL_THREADQ();
      qp = qp_next) {
   qp_next = qp->next;
   t = _PR_ACTIVE_THREAD_PTR(qp);
   if (_PR_IS_GCABLE_THREAD(t)) {
     rv = (*func)(t, i, arg);
     if (rv != PR_SUCCESS) {
       return rv;
     }
     i++;
   }
 }
 for (qp = _PR_ACTIVE_GLOBAL_THREADQ().next;
      qp != &_PR_ACTIVE_GLOBAL_THREADQ(); qp = qp_next) {
   qp_next = qp->next;
   t = _PR_ACTIVE_THREAD_PTR(qp);
   if (_PR_IS_GCABLE_THREAD(t)) {
     rv = (*func)(t, i, arg);
     if (rv != PR_SUCCESS) {
       return rv;
     }
     i++;
   }
 }
 return rv;
}

/* FUNCTION: _PR_AddSleepQ
** DESCRIPTION:
**    Adds a thread to the sleep/pauseQ.
** RESTRICTIONS:
**    Caller must have the RUNQ lock.
**    Caller must be a user level thread
*/
PR_IMPLEMENT(void)
_PR_AddSleepQ(PRThread* thread, PRIntervalTime timeout) {
 _PRCPU* cpu = thread->cpu;

 if (timeout == PR_INTERVAL_NO_TIMEOUT) {
   /* append the thread to the global pause Q */
   PR_APPEND_LINK(&thread->links, &_PR_PAUSEQ(thread->cpu));
   thread->flags |= _PR_ON_PAUSEQ;
 } else {
   PRIntervalTime sleep;
   PRCList* q;
   PRThread* t;

   /* sort onto global sleepQ */
   sleep = timeout;

   /* Check if we are longest timeout */
   if (timeout >= _PR_SLEEPQMAX(cpu)) {
     PR_INSERT_BEFORE(&thread->links, &_PR_SLEEPQ(cpu));
     thread->sleep = timeout - _PR_SLEEPQMAX(cpu);
     _PR_SLEEPQMAX(cpu) = timeout;
   } else {
     /* Sort thread into global sleepQ at appropriate point */
     q = _PR_SLEEPQ(cpu).next;

     /* Now scan the list for where to insert this entry */
     while (q != &_PR_SLEEPQ(cpu)) {
       t = _PR_THREAD_PTR(q);
       if (sleep < t->sleep) {
         /* Found sleeper to insert in front of */
         break;
       }
       sleep -= t->sleep;
       q = q->next;
     }
     thread->sleep = sleep;
     PR_INSERT_BEFORE(&thread->links, q);

     /*
     ** Subtract our sleep time from the sleeper that follows us (there
     ** must be one) so that they remain relative to us.
     */
     PR_ASSERT(thread->links.next != &_PR_SLEEPQ(cpu));

     t = _PR_THREAD_PTR(thread->links.next);
     PR_ASSERT(_PR_THREAD_PTR(t->links.prev) == thread);
     t->sleep -= sleep;
   }

   thread->flags |= _PR_ON_SLEEPQ;
 }
}

/* FUNCTION: _PR_DelSleepQ
** DESCRIPTION:
**    Removes a thread from the sleep/pauseQ.
** INPUTS:
**    If propogate_time is true, then the thread following the deleted
**    thread will be get the time from the deleted thread.  This is used
**    when deleting a sleeper that has not timed out.
** RESTRICTIONS:
**    Caller must have the RUNQ lock.
**    Caller must be a user level thread
*/
PR_IMPLEMENT(void)
_PR_DelSleepQ(PRThread* thread, PRBool propogate_time) {
 _PRCPU* cpu = thread->cpu;

 /* Remove from pauseQ/sleepQ */
 if (thread->flags & (_PR_ON_PAUSEQ | _PR_ON_SLEEPQ)) {
   if (thread->flags & _PR_ON_SLEEPQ) {
     PRCList* q = thread->links.next;
     if (q != &_PR_SLEEPQ(cpu)) {
       if (propogate_time == PR_TRUE) {
         PRThread* after = _PR_THREAD_PTR(q);
         after->sleep += thread->sleep;
       } else {
         _PR_SLEEPQMAX(cpu) -= thread->sleep;
       }
     } else {
       /* Check if prev is the beggining of the list; if so,
        * we are the only element on the list.
        */
       if (thread->links.prev != &_PR_SLEEPQ(cpu)) {
         _PR_SLEEPQMAX(cpu) -= thread->sleep;
       } else {
         _PR_SLEEPQMAX(cpu) = 0;
       }
     }
     thread->flags &= ~_PR_ON_SLEEPQ;
   } else {
     thread->flags &= ~_PR_ON_PAUSEQ;
   }
   PR_REMOVE_LINK(&thread->links);
 } else {
   PR_ASSERT(0);
 }
}

void _PR_AddThreadToRunQ(
   PRThread* me,     /* the current thread */
   PRThread* thread) /* the local thread to be added to a run queue */
{
 PRThreadPriority pri = thread->priority;
 _PRCPU* cpu = thread->cpu;

 PR_ASSERT(!_PR_IS_NATIVE_THREAD(thread));

#if defined(WINNT)
 /*
  * On NT, we can only reliably know that the current CPU
  * is not idle.  We add the awakened thread to the run
  * queue of its CPU if its CPU is the current CPU.
  * For any other CPU, we don't really know whether it
  * is busy or idle.  So in all other cases, we just
  * "post" the awakened thread to the IO completion port
  * for the next idle CPU to execute (this is done in
  * _PR_MD_WAKEUP_WAITER).
  * Threads with a suspended I/O operation remain bound to
  * the same cpu until I/O is cancelled
  *
  * NOTE: the boolean expression below must be the exact
  * opposite of the corresponding boolean expression in
  * _PR_MD_WAKEUP_WAITER.
  */
 if ((!_PR_IS_NATIVE_THREAD(me) && (cpu == me->cpu)) ||
     (thread->md.thr_bound_cpu)) {
   PR_ASSERT(!thread->md.thr_bound_cpu || (thread->md.thr_bound_cpu == cpu));
   _PR_RUNQ_LOCK(cpu);
   _PR_ADD_RUNQ(thread, cpu, pri);
   _PR_RUNQ_UNLOCK(cpu);
 }
#else
 _PR_RUNQ_LOCK(cpu);
 _PR_ADD_RUNQ(thread, cpu, pri);
 _PR_RUNQ_UNLOCK(cpu);
 if (!_PR_IS_NATIVE_THREAD(me) && (cpu == me->cpu)) {
   if (pri > me->priority) {
     _PR_SET_RESCHED_FLAG();
   }
 }
#endif
}