void _PR_NotifyCondVar(PRCondVar *cvar, PRThread *me)
{
#ifdef _PR_GLOBAL_THREADS_ONLY
_PR_MD_NOTIFY_CV(&cvar->md, &cvar->lock->ilock);
#else /* _PR_GLOBAL_THREADS_ONLY */
PRCList *q;
PRIntn is;
if ( !_PR_IS_NATIVE_THREAD(me))
_PR_INTSOFF(is);
PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0);
_PR_CVAR_LOCK(cvar);
q = cvar->condQ.next;
while (q != &cvar->condQ) {
#ifndef XP_MAC
PR_LOG(_pr_cvar_lm, PR_LOG_MIN, ("_PR_NotifyCondVar: cvar=%p", cvar));
#endif
if (_PR_THREAD_CONDQ_PTR(q)->wait.cvar) {
if (_PR_NotifyThread(_PR_THREAD_CONDQ_PTR(q), me) == PR_TRUE)
break;
}
q = q->next;
}
_PR_CVAR_UNLOCK(cvar);
if ( !_PR_IS_NATIVE_THREAD(me))
_PR_INTSON(is);
#endif /* _PR_GLOBAL_THREADS_ONLY */
}
/*
** Deal with delayed interrupts/requested reschedule during interrupt
** re-enables.
*/
void _PR_IntsOn(_PRCPU *cpu)
{
PRUintn missed, pri, i;
_PRInterruptTable *it;
PRThread *me;
PR_ASSERT(cpu); /* Global threads don't have CPUs */
PR_ASSERT(_PR_MD_GET_INTSOFF() > 0);
me = _PR_MD_CURRENT_THREAD();
#if !defined(XP_MAC)
PR_ASSERT(!(me->flags & _PR_IDLE_THREAD));
#endif
/*
** Process delayed interrupts. This logic is kinda scary because we
** need to avoid losing an interrupt (it's ok to delay an interrupt
** until later).
**
** There are two missed state words. _pr_ints.where indicates to the
** interrupt handler which state word is currently safe for
** modification.
**
** This code scans both interrupt state words, using the where flag
** to indicate to the interrupt which state word is safe for writing.
** If an interrupt comes in during a scan the other word will be
** modified. This modification will be noticed during the next
** iteration of the loop or during the next call to this routine.
*/
for (i = 0; i < 2; i++) {
cpu->where = (1 - i);
missed = cpu->u.missed[i];
if (missed != 0) {
cpu->u.missed[i] = 0;
for (it = _pr_interruptTable; it->name; it++) {
if (missed & it->missed_bit) {
#ifndef XP_MAC
PR_LOG(_pr_sched_lm, PR_LOG_MIN,
("IntsOn[0]: %s intr", it->name));
#endif
(*it->handler)();
}
}
}
}
if (cpu->u.missed[3] != 0) {
_PRCPU *cpu;
_PR_THREAD_LOCK(me);
me->state = _PR_RUNNABLE;
pri = me->priority;
cpu = me->cpu;
_PR_RUNQ_LOCK(cpu);
_PR_ADD_RUNQ(me, cpu, pri);
_PR_RUNQ_UNLOCK(cpu);
_PR_THREAD_UNLOCK(me);
_PR_MD_SWITCH_CONTEXT(me);
}
}
// Notification routine
// Async callback routine.
// A5 is OK. Cannot allocate memory here
pascal void NotifierRoutine(void * contextPtr, OTEventCode code, OTResult result, void * cookie)
{
PRThread * thread = (PRThread *) contextPtr;
_PRCPU *cpu = _PR_MD_CURRENT_CPU();
switch (code)
{
// Async Completion Event
case T_OPENCOMPLETE:
case T_BINDCOMPLETE:
case T_UNBINDCOMPLETE:
case T_GETPROTADDRCOMPLETE:
case T_ACCEPTCOMPLETE:
// Connect callback
case T_CONNECT:
// Standard or expedited data is available
case T_DATA:
case T_EXDATA:
// Standard or expedited data Flow control lifted
case T_GODATA:
case T_GOEXDATA:
// Asynchronous Listen Event
case T_LISTEN:
// DNR String To Address Complete Event
case T_DNRSTRINGTOADDRCOMPLETE:
// Option Management Request Complete Event
case T_OPTMGMTCOMPLETE:
thread->md.osErrCode = result;
thread->md.cookie = cookie;
if (_PR_MD_GET_INTSOFF()) {
cpu->u.missed[cpu->where] |= _PR_MISSED_IO;
thread->md.notifyPending = PR_TRUE;
return;
}
DoneWaitingOnThisThread(thread);
break;
// T_ORDREL orderly release is available; nothing to do
case T_ORDREL:
break;
// T_PASSCON; nothing to do
case T_PASSCON:
break;
// T_DISCONNECT; disconnect is available; nothing to do
case T_DISCONNECT:
break;
// UDP Send error; clear the error
case T_UDERR:
(void) OTRcvUDErr((EndpointRef) cookie, NULL);
default:
PR_ASSERT(0);
}
}
/*
* Notify thread waiting on cvar; called when thread is interrupted
* The thread lock is held on entry and released before return
*/
void _PR_NotifyLockedThread (PRThread *thread)
{
PRThread *me = _PR_MD_CURRENT_THREAD();
PRCondVar *cvar;
PRThreadPriority pri;
if ( !_PR_IS_NATIVE_THREAD(me))
PR_ASSERT(_PR_MD_GET_INTSOFF() != 0);
cvar = thread->wait.cvar;
thread->wait.cvar = NULL;
_PR_THREAD_UNLOCK(thread);
_PR_CVAR_LOCK(cvar);
_PR_THREAD_LOCK(thread);
if (!_PR_IS_NATIVE_THREAD(thread)) {
_PR_SLEEPQ_LOCK(thread->cpu);
/* The notify and timeout can collide; in which case both may
* attempt to delete from the sleepQ; only let one do it.
*/
if (thread->flags & (_PR_ON_SLEEPQ|_PR_ON_PAUSEQ))
_PR_DEL_SLEEPQ(thread, PR_TRUE);
_PR_SLEEPQ_UNLOCK(thread->cpu);
/* Make thread runnable */
pri = thread->priority;
thread->state = _PR_RUNNABLE;
PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
_PR_AddThreadToRunQ(me, thread);
_PR_THREAD_UNLOCK(thread);
_PR_MD_WAKEUP_WAITER(thread);
} else {
if (thread->flags & _PR_SUSPENDING) {
/*
* set thread state to SUSPENDED; a Resume operation
* on the thread will enable the thread to run
*/
thread->state = _PR_SUSPENDED;
} else
thread->state = _PR_RUNNING;
_PR_THREAD_UNLOCK(thread);
_PR_MD_WAKEUP_WAITER(thread);
}
_PR_CVAR_UNLOCK(cvar);
return;
}
static void asyncIOCompletion (ExtendedParamBlock pbAsyncPtr_thread)
{
while (__START_ASYNC__ == False) {}; // second thread waits until the async read is issued
PRThread thread = pbAsyncPtr_thread;
if (_PR_MD_GET_INTSOFF()) {
return;
}
_PR_MD_SET_INTSOFF(1);
DoneWaitingOnThisThread(thread);
_PR_MD_SET_INTSOFF(0);
}
/*
** Lock the lock.
*/
PR_IMPLEMENT(void) PR_Lock(PRLock *lock)
{
PRThread *me = _PR_MD_CURRENT_THREAD();
PRIntn is;
PRThread *t;
PRCList *q;
PR_ASSERT(me != suspendAllThread);
PR_ASSERT(!(me->flags & _PR_IDLE_THREAD));
PR_ASSERT(lock != NULL);
#ifdef _PR_GLOBAL_THREADS_ONLY
_PR_MD_LOCK(&lock->ilock);
PR_ASSERT(lock->owner == 0);
lock->owner = me;
return;
#else /* _PR_GLOBAL_THREADS_ONLY */
if (_native_threads_only) {
_PR_MD_LOCK(&lock->ilock);
PR_ASSERT(lock->owner == 0);
lock->owner = me;
return;
}
if (!_PR_IS_NATIVE_THREAD(me))
_PR_INTSOFF(is);
PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0);
retry:
_PR_LOCK_LOCK(lock);
if (lock->owner == 0) {
/* Just got the lock */
lock->owner = me;
lock->priority = me->priority;
/* Add the granted lock to this owning thread's lock list */
PR_APPEND_LINK(&lock->links, &me->lockList);
_PR_LOCK_UNLOCK(lock);
if (!_PR_IS_NATIVE_THREAD(me))
_PR_FAST_INTSON(is);
return;
}
/* If this thread already owns this lock, then it is a deadlock */
PR_ASSERT(lock->owner != me);
PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0);
#if 0
if (me->priority > lock->owner->priority) {
/*
** Give the lock owner a priority boost until we get the
** lock. Record the priority we boosted it to.
*/
lock->boostPriority = me->priority;
_PR_SetThreadPriority(lock->owner, me->priority);
}
#endif
/*
Add this thread to the asked for lock's list of waiting threads. We
add this thread thread in the right priority order so when the unlock
occurs, the thread with the higher priority will get the lock.
*/
q = lock->waitQ.next;
if (q == &lock->waitQ || _PR_THREAD_CONDQ_PTR(q)->priority ==
_PR_THREAD_CONDQ_PTR(lock->waitQ.prev)->priority) {
/*
* If all the threads in the lock waitQ have the same priority,
* then avoid scanning the list: insert the element at the end.
*/
q = &lock->waitQ;
} else {
/* Sort thread into lock's waitQ at appropriate point */
/* Now scan the list for where to insert this entry */
while (q != &lock->waitQ) {
t = _PR_THREAD_CONDQ_PTR(lock->waitQ.next);
if (me->priority > t->priority) {
/* Found a lower priority thread to insert in front of */
break;
}
q = q->next;
}
}
PR_INSERT_BEFORE(&me->waitQLinks, q);
/*
Now grab the threadLock since we are about to change the state. We have
to do this since a PR_Suspend or PR_SetThreadPriority type call that takes
a PRThread* as an argument could be changing the state of this thread from
a thread running on a different cpu.
*/
_PR_THREAD_LOCK(me);
me->state = _PR_LOCK_WAIT;
me->wait.lock = lock;
_PR_THREAD_UNLOCK(me);
_PR_LOCK_UNLOCK(lock);
_PR_MD_WAIT(me, PR_INTERVAL_NO_TIMEOUT);
goto retry;
#endif /* _PR_GLOBAL_THREADS_ONLY */
}
/*
** Notify one thread that it has finished waiting on a condition variable
** Caller must hold the _PR_CVAR_LOCK(cv)
*/
PRBool _PR_NotifyThread (PRThread *thread, PRThread *me)
{
PRBool rv;
PR_ASSERT(_PR_IS_NATIVE_THREAD(me) || _PR_MD_GET_INTSOFF() != 0);
_PR_THREAD_LOCK(thread);
PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
if ( !_PR_IS_NATIVE_THREAD(thread) ) {
if (thread->wait.cvar != NULL) {
thread->wait.cvar = NULL;
_PR_SLEEPQ_LOCK(thread->cpu);
/* The notify and timeout can collide; in which case both may
* attempt to delete from the sleepQ; only let one do it.
*/
if (thread->flags & (_PR_ON_SLEEPQ|_PR_ON_PAUSEQ))
_PR_DEL_SLEEPQ(thread, PR_TRUE);
_PR_SLEEPQ_UNLOCK(thread->cpu);
if (thread->flags & _PR_SUSPENDING) {
/*
* set thread state to SUSPENDED; a Resume operation
* on the thread will move it to the runQ
*/
thread->state = _PR_SUSPENDED;
_PR_MISCQ_LOCK(thread->cpu);
_PR_ADD_SUSPENDQ(thread, thread->cpu);
_PR_MISCQ_UNLOCK(thread->cpu);
_PR_THREAD_UNLOCK(thread);
} else {
/* Make thread runnable */
thread->state = _PR_RUNNABLE;
_PR_THREAD_UNLOCK(thread);
_PR_AddThreadToRunQ(me, thread);
_PR_MD_WAKEUP_WAITER(thread);
}
rv = PR_TRUE;
} else {
/* Thread has already been notified */
_PR_THREAD_UNLOCK(thread);
rv = PR_FALSE;
}
} else { /* If the thread is a native thread */
if (thread->wait.cvar) {
thread->wait.cvar = NULL;
if (thread->flags & _PR_SUSPENDING) {
/*
* set thread state to SUSPENDED; a Resume operation
* on the thread will enable the thread to run
*/
thread->state = _PR_SUSPENDED;
} else
thread->state = _PR_RUNNING;
_PR_THREAD_UNLOCK(thread);
_PR_MD_WAKEUP_WAITER(thread);
rv = PR_TRUE;
} else {
_PR_THREAD_UNLOCK(thread);
rv = PR_FALSE;
}
}
return rv;
}
/*
** Expire condition variable waits that are ready to expire. "now" is the current
** time.
*/
void _PR_ClockInterrupt(void)
{
PRThread *thread, *me = _PR_MD_CURRENT_THREAD();
_PRCPU *cpu = me->cpu;
PRIntervalTime elapsed, now;
PR_ASSERT(_PR_MD_GET_INTSOFF() != 0);
/* Figure out how much time elapsed since the last clock tick */
now = PR_IntervalNow();
elapsed = now - cpu->last_clock;
cpu->last_clock = now;
#ifndef XP_MAC
PR_LOG(_pr_clock_lm, PR_LOG_MAX,
("ExpireWaits: elapsed=%lld usec", elapsed));
#endif
while(1) {
_PR_SLEEPQ_LOCK(cpu);
if (_PR_SLEEPQ(cpu).next == &_PR_SLEEPQ(cpu)) {
_PR_SLEEPQ_UNLOCK(cpu);
break;
}
thread = _PR_THREAD_PTR(_PR_SLEEPQ(cpu).next);
PR_ASSERT(thread->cpu == cpu);
if (elapsed < thread->sleep) {
thread->sleep -= elapsed;
_PR_SLEEPQMAX(thread->cpu) -= elapsed;
_PR_SLEEPQ_UNLOCK(cpu);
break;
}
_PR_SLEEPQ_UNLOCK(cpu);
PR_ASSERT(!_PR_IS_NATIVE_THREAD(thread));
_PR_THREAD_LOCK(thread);
if (thread->cpu != cpu) {
/*
** The thread was switched to another CPU
** between the time we unlocked the sleep
** queue and the time we acquired the thread
** lock, so it is none of our business now.
*/
_PR_THREAD_UNLOCK(thread);
continue;
}
/*
** Consume this sleeper's amount of elapsed time from the elapsed
** time value. The next remaining piece of elapsed time will be
** available for the next sleeping thread's timer.
*/
_PR_SLEEPQ_LOCK(cpu);
PR_ASSERT(!(thread->flags & _PR_ON_PAUSEQ));
if (thread->flags & _PR_ON_SLEEPQ) {
_PR_DEL_SLEEPQ(thread, PR_FALSE);
elapsed -= thread->sleep;
_PR_SLEEPQ_UNLOCK(cpu);
} else {
/* Thread was already handled; Go get another one */
_PR_SLEEPQ_UNLOCK(cpu);
_PR_THREAD_UNLOCK(thread);
continue;
}
/* Notify the thread waiting on the condition variable */
if (thread->flags & _PR_SUSPENDING) {
PR_ASSERT((thread->state == _PR_IO_WAIT) ||
(thread->state == _PR_COND_WAIT));
/*
** Thread is suspended and its condition timeout
** expired. Transfer thread from sleepQ to suspendQ.
*/
thread->wait.cvar = NULL;
_PR_MISCQ_LOCK(cpu);
thread->state = _PR_SUSPENDED;
_PR_ADD_SUSPENDQ(thread, cpu);
_PR_MISCQ_UNLOCK(cpu);
} else {
if (thread->wait.cvar) {
PRThreadPriority pri;
/* Do work very similar to what _PR_NotifyThread does */
PR_ASSERT( !_PR_IS_NATIVE_THREAD(thread) );
/* Make thread runnable */
pri = thread->priority;
thread->state = _PR_RUNNABLE;
PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
PR_ASSERT(thread->cpu == cpu);
_PR_RUNQ_LOCK(cpu);
_PR_ADD_RUNQ(thread, cpu, pri);
_PR_RUNQ_UNLOCK(cpu);
if (pri > me->priority)
_PR_SET_RESCHED_FLAG();
thread->wait.cvar = NULL;
_PR_MD_WAKEUP_WAITER(thread);
} else if (thread->io_pending == PR_TRUE) {
/* Need to put IO sleeper back on runq */
int pri = thread->priority;
thread->io_suspended = PR_TRUE;
#ifdef WINNT
/*
* For NT, record the cpu on which I/O was issued
* I/O cancellation is done on the same cpu
*/
thread->md.thr_bound_cpu = cpu;
#endif
PR_ASSERT(!(thread->flags & _PR_IDLE_THREAD));
PR_ASSERT(thread->cpu == cpu);
thread->state = _PR_RUNNABLE;
_PR_RUNQ_LOCK(cpu);
_PR_ADD_RUNQ(thread, cpu, pri);
_PR_RUNQ_UNLOCK(cpu);
}
}
_PR_THREAD_UNLOCK(thread);
}
}
