/* -*- 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
}
