+
−/* -*- 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) || defined (UNIXWARE) && defined (USR_SVR4_THREADS)
+
−    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
+
−}