1 files changed, 726 insertions, 0 deletions

diff --git a/java/jdk16/files/patch-threads_bsd.c b/java/jdk16/files/patch-threads_bsd.c
new file mode 100644
index 000000000000..0549832f1833
--- /dev/null
+++ b/java/jdk16/files/patch-threads_bsd.c
@@ -0,0 +1,726 @@
+$FreeBSD$
+
+--- ../src/solaris/hpi/native_threads/src/threads_bsd.c	7 Feb 2002 05:19:54 -0000	1.12
++++ ../src/solaris/hpi/native_threads/src/threads_bsd.c	25 Feb 2003 16:31:54 -0000
+@@ -22,32 +22,23 @@
+ #include "np.h"
+ 
+ #include <pthread.h>
++#include <pthread_np.h>
+ 
+ #if defined(__FreeBSD__)
+ 
+-#include <pthread_np.h>
++#include <assert.h>
+ 
+-/* Remove defines from pthread.h so pthread_private.h can be included */
+-#undef pthread_condattr_default
+-#undef pthread_mutexattr_default
+ #undef pthread_attr_default
++#undef pthread_mutexattr_default
++#undef pthread_condattr_default
+ #include "pthread_private.h"
+ 
+-#include <assert.h>
+-#include <ucontext.h>
+-#include <machine/ucontext.h>
+-
+-#include <sys/exec.h>
+-#include <vm/vm.h>
+-#include <vm/pmap.h>
+-#include <machine/pmap.h>
+-#include <machine/vmparam.h>
+-
+ #endif
+ 
+ #include <string.h>
+ #include <signal.h>
+ #include <sys/signal.h>
++#include <sys/time.h>
+ #include <sys/resource.h>
+ #include <stdlib.h>
+ #include <string.h>
+@@ -63,14 +54,9 @@
+ /* Private functions used to implement native threading. --billh */
+ 
+ #ifdef DEBUG_BSD_NATIVE_THREADS
+-void _pthread_suspend_all_np(void);
+-void _pthread_resume_all_np(void);
+-#endif
+-void record_uc(sys_thread_t *, ucontext_t *);
+-void record_gc_registers_of(sys_thread_t *);
+-
+-void dumpThreadStates();
+ void dumpThreadLogStates(pthread_t);
++void dumpThreadStates();
++#endif
+ 
+ /*
+  * Suspend a thread.  Used to implement java.lang.Thread.suspend(),
+@@ -108,28 +94,24 @@
+ int
+ np_stackinfo(void **addr, long *sizep)
+ {
+-    thread_t self = pthread_self();
+-    int base;
+-    int size;
+-
+-    if (!pthread_equal(self, _thread_initial)) {
+-        *addr = self->stack;
+-	*sizep = (long) PTHREAD_STACK_DEFAULT;
+-
+-    } else {
+-	/* in main()'s thread */
+-	struct rlimit r;
+-
+-	if (getrlimit(RLIMIT_STACK, &r) == -1)
+-	    return SYS_ERR;
+-
+-	/* PS_STRINGS is also from sys/exec.h in FreeBSD, but as macro. --billh */
+-
+-	*addr  = (void *) (PS_STRINGS +1);
+-	*sizep = (long)r.rlim_cur;
+-    }
++    pthread_attr_t attr;
++    size_t size;
+ 
++    if ((errno = pthread_attr_init(&attr)))
++	return SYS_ERR;
++    if ((errno = pthread_attr_get_np(pthread_self(), &attr)))
++	goto err;
++    if ((errno = pthread_attr_getstackaddr(&attr, addr)))
++	goto err;
++    if ((errno = pthread_attr_getstacksize(&attr, &size)))
++	goto err;
++    *sizep = size;
++    pthread_attr_destroy(&attr);
+     return SYS_OK;
++
++err:
++    pthread_attr_destroy(&attr);
++    return SYS_ERR;
+ }
+ 
+ /*
+@@ -177,7 +159,7 @@
+ 	Do this for the FreeBSD implementation too, since this is a silly
+ 	function anyways.  --billh
+ */
+-	return TRUE;
++    return TRUE;
+ }
+ 
+ 
+@@ -190,38 +172,54 @@
+ static void
+ record_thread_regs()
+ {
+-    sys_thread_t *tid;
++    struct pthread *self = pthread_self();
++    sys_thread_t *tid = ThreadQueue;
+     int i;
+-    int sp;
+ 
+-    tid = ThreadQueue;
+-    for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
+-	int i;
+-
+-	if (tid->sys_thread != 0) {
+-#ifdef __bsdi__
+-	    /* if thread has already been initialized */
+-	    if (pthread_getstackpointer_np(tid->sys_thread, &sp) == 0)
+-		tid->sp = sp;
+-	    else
+-		tid->sp = 0;
+-#elif __FreeBSD__
+-#endif
+-            tid->sp = tid->sys_thread->stack;
+-//#endif	//__FreeBSD__
+-/*	Potential race here if the stack isn't setup before GC. --billh */
+-	} else {
++    for (i = 0; i < ActiveThreadCount && tid != NULL; i++, tid = tid->next) {
++	struct pthread *thread = tid->sys_thread;
++
++	if (thread == 0) {
+ 	    /*
+ 	     * thread is still in the process of being initalized.
+ 	     * So GC should not care about this thread. Just
+ 	     * set its sp to 0, and this will force GC to ignore it.
+ 	     */
+ 	    tid->sp = 0;
++	    continue;
+ 	}
+ 
+-	record_gc_registers_of(tid);
++        tid->sp = thread->stack;
++/*	Potential race here if the stack isn't setup before GC. --billh */
+ 
+-	tid = tid->next;
++	/*
++	 * The thread that calls this function will alway be the JVM GC thread,
++	 * so skip over it in the list of threads.
++	 */
++	if (thread != self && (thread->flags & PTHREAD_FLAGS_PRIVATE) == 0) {
++	    register_t *regbase;
++
++#ifdef DEBUG_BSD_NATIVE_THREADS
++	    /*
++	     * Got search candidate..
++	     */
++	    if (thread->state != PS_SUSPENDED)
++		dumpThreadLogStates(thread);
++#endif
++
++	    regbase = (register_t*) &thread->ctx.jb[0];
++	    tid->regs[0] = regbase[6];	/* eax */
++	    tid->regs[1] = 0;		/* ecx (missing) */
++	    tid->regs[2] = 0;		/* edx (missing) */
++	    tid->regs[3] = regbase[1];	/* ebx */
++	    tid->regs[4] = regbase[3];	/* ebp */
++	    tid->regs[5] = regbase[4];	/* esi */
++	    tid->regs[6] = regbase[5];	/* edi */
++
++#ifdef DEBUG_BSD_NATIVE_THREADS
++	    dumpThreadStates();
++#endif
++	}
+     }
+ 
+ #ifdef DEBUG_BSD_NATIVE_THREADS
+@@ -239,14 +237,7 @@
+ {
+     sysAssert(SYS_QUEUE_LOCKED(sysThreadSelf()));
+ 
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-    _pthread_suspend_all_np();
+-#else
+-    pthread_single_np();
+-#endif
+-
+-//usleep(100000 *3);
+-
++    pthread_suspend_all_np();
+     record_thread_regs();
+     return SYS_OK;
+ }
+@@ -259,42 +250,13 @@
+ np_multi(void)
+ {
+     sysAssert(SYS_QUEUE_LOCKED(sysThreadSelf()));
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-    _pthread_resume_all_np();
+-#else
+-    pthread_multi_np();
+-#endif
++    pthread_resume_all_np();
+ }
+ 
+-
+-
+-
++#ifdef DEBUG_BSD_NATIVE_THREADS
+ /* pthreads hackery begins --billh */
+ 
+-#define ANALRETENTIVE (6 + 1)
+-
+-char SuspendList[ANALRETENTIVE][16] = 
+-{
+-	"SUSP_NO",		/* Not suspended. */
+-	"SUSP_YES",		/* Suspended. */
+-	"SUSP_JOIN",		/* Suspended, joining. */  
+-	"SUSP_NOWAIT",		/* Suspended, was in a mutex or condition queue. */
+-	"SUSP_MUTEX_WAIT",	/* Suspended, still in a mutex queue. */
+-	"SUSP_COND_WAIT",	/* Suspended, still in a condition queue. */
+-	"susp boundless"
+-};
+-
+-char *getSuspendStateString(enum pthread_susp suspendState)
+-{
+-	if (suspendState < ANALRETENTIVE)
+-		return &SuspendList[suspendState][0];
+-	else 
+-		return &SuspendList[ANALRETENTIVE-1][0];
+-}
+-
+-#define SATAN (21 + 1) /* for the error string at the end of the list */
+-
+-char SignalList [SATAN][16]
++char SignalList [][16]
+ =
+ {
+ 	"PS_RUNNING",
+@@ -316,18 +278,17 @@
+ 	"PS_JOIN",
+ 	"PS_SUSPENDED",
+ 	"PS_DEAD",
+-	"PS_DEADLCK",
++	"PS_DEADLOCK",
+ 	"PS_STATE_MAX",
+-	"PS_REQUEST_WAITING_SUSPENDED",
+ 	"boundless"
+ };
+ 
+ char *getThreadStateString(enum pthread_state threadState)
+ {
+ 	if (threadState < SATAN)
+-		return &SignalList[threadState][0];
+-	else 
+-		return &SignalList[SATAN-1][0];
++		return SignalList[threadState];
++	else
++		return SignalList[SATAN-1];
+ }
+ 
+ void dumpThreadStates()
+@@ -336,114 +297,29 @@
+ 	struct pthread	*thread;
+ 	struct pthread	*self = pthread_self();
+ 
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+ 	_thread_kern_sig_defer();
+ 	TAILQ_FOREACH(thread, &_thread_list, tle) {
+ 		if (thread != self) { /* special case this --billh */
+-			printf("\tthread %d\t%s\t%s\n",
++			printf("\tthread %d\t%s\n",
+ 				threadCount,
+-				getThreadStateString(thread->state),
+-				getSuspendStateString(thread->suspended));
++				getThreadStateString(thread->state));
+ 
+ 			if (thread->state != PS_SUSPENDED)
+ 				dumpThreadLogStates(thread);
+-		}
+-		else
+-		{
+-			printf("\tgc thread %d\t%s\t%s\n",
++		} else {
++			printf("\tgc thread %d\t%s\n",
+ 				threadCount,
+-				getThreadStateString(thread->state),
+-				getSuspendStateString(thread->suspended));
++				getThreadStateString(thread->state))
+ 		}
+ 		++threadCount;
+ 	}
+ 	_thread_kern_sig_undefer();
+ 	printf("\n");
+-#endif
+-}
+-
+-
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-extern void _pthread_suspend_np_by_pthread_common(pthread_t);
+-extern void _pthread_resume_by_pthread_common(pthread_t, enum pthread_susp);
+-
+-void
+-_pthread_suspend_all_np(void)
+-{
+-	struct pthread	*thread;
+-	struct pthread	*self = pthread_self();
+-
+-fprintf(stderr, "pthread_suspend_all_np\n");
+-	/*
+-	 * Defer signals to protect the scheduling queues from
+-	 * access by the signal handler:
+-	 */
+-	_thread_kern_sig_defer();
+-
+-	/* Suspend all threads other than the current thread: */
+-	TAILQ_FOREACH(thread, &_thread_list, tle) {
+-		if (thread != self) {
+-			_pthread_suspend_np_by_pthread_common(thread);
+-		}
+-	}
+-
+-	/*
+-	 * Undefer and handle pending signals, yielding if necessary:
+-	 */
+-	_thread_kern_sig_undefer();
+-fprintf(stderr, "pthread_suspend_all_np END\n");
+-}
+-
+-/* Resume a thread: */
+-void
+-_pthread_resume_all_np(void)
+-{
+-	enum		pthread_susp old_suspended;
+-	struct pthread	*thread;
+-	struct pthread	*self = pthread_self();
+-
+-fprintf(stderr, "pthread_resume_all_np\n");
+-	_thread_kern_sig_defer();
+-
+-	/*
+-		Iterate through the thread list and resume suspended threads.
+-		this is copied from pthread_resume_np(). --billh
+-	*/
+-
+-	TAILQ_FOREACH(thread, &_thread_list, tle) {
+-		if (thread != self) {
+-			/* Cancel any pending suspensions: */
+-
+-			old_suspended = thread->suspended;
+-			thread->suspended = SUSP_NO;
+-
+-			_pthread_resume_by_pthread_common(thread, old_suspended);
+-
+-		} // if !thread_self
+-	} // TAILQ_FOREACH
+-
+-	/*
+-	 * Undefer and handle pending signals, yielding if
+-	 * necessary:
+-	 */
+-	_thread_kern_sig_undefer();
+-fprintf(stderr, "pthread_resume_all_np END\n");
+ }
+-#endif
+ 
+ /*
+ 	[A snippet from Dan Eichen's email on the subject]
+ 
+-	It uses _longjmp (non-signal-saving/restoring) for the most part.
+-	The only exception is when the process (currently running thread) is 
+-	interrupted by a signal.  So your context types are a jmp_buf and
+-	a ucontext_t (if interrupted by a signal).  If thread->ctxtype is
+-	CTX_UC, the context is stored as a ucontext in thread->ctx.uc.
+-	Otherwise, the context is stored as a jmp_buf in thread->ctx.jb.
+-	We don't currently use CTX_JB and CTX_SJB, so don't even bother
+-	with those cases.  Those should go away actually; all we need
+-	to know is if it is a ucontext_t or a jmp_buf.
+-
+ 	You can also look at src/gnu/usr.bin/binutils/gdb/freebsd-uthread.c.
+ 	It knows how to iterate through all the threads and pull out
+ 	(and even set) thread contexts.
+@@ -462,19 +338,8 @@
+ 	--billh
+ */
+ 
+-void clear_gc_registers(sys_thread_t * jthread)
+-{
+-/* clear out x86 registers for the thread's "self" --billh */
+-
+-	jthread->regs[0] = 0; jthread->regs[1] = 0;
+-	jthread->regs[2] = 0; jthread->regs[3] = 0;
+-	jthread->regs[4] = 0; jthread->regs[5] = 0;
+-	jthread->regs[6] = 0;
+-}
+-
+ void dumpThreadLogStates(pthread_t thread)
+ {
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+ int i;
+ 	for(i=0; i < STATE_LOG_SIZE; ++i)
+ 	{
+@@ -494,311 +359,5 @@
+ 		}
+ 	}
+ 	printf("\t\t***XXX\n");
+-#endif
+-}
+-
+-void record_gc_registers_of(sys_thread_t *javaThread)
+-{
+-struct pthread	*self	= pthread_self();
+-struct pthread	*thread	= NULL;
+-
+-	assert( javaThread != NULL );
+-	assert( javaThread->sys_thread != NULL );
+-
+-	thread = javaThread->sys_thread;
+-
+-	/*
+-	 * The thread that calls this function will alway be the JVM GC thread,
+-	 * so skip over it in the list of threads.
+-	 */
+-	if (	(thread == self)
+-		|| ((thread->flags & PTHREAD_FLAGS_PRIVATE) != 1)
+-	   )
+-	{
+-		record_uc(javaThread, &thread->ctx.uc);
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-		goto Terminate; // And do nothing with this pthread entry. 
+-#endif
+-	}
+-
+-	/*
+-	 * Got search candiate..
+-	 */
+-	if (thread->state != PS_SUSPENDED)
+-		dumpThreadLogStates(thread);
+-
+-	switch ((int)thread->ctxtype)
+-	{
+-		case CTX_JB_NOSIG:	/* 0) jmp_buf context without signal mask for blocking IO, etc... */
+-		case CTX_JB:		/* 1) should never be CTX_JB */
+-		case CTX_SJB:		/* 2) should never be CTX_SJB */
+-			clear_gc_registers(javaThread);
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-			goto Terminate;
+-#endif
+-			break;
+-		case CTX_UC:		/* 3) */
+-			/* context is a ucontext_t */
+-			record_uc(javaThread, &thread->ctx.uc);
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-			goto Terminate;
+-#endif
+-			break;
+-		default:
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-			fprintf(stderr, "ctxtype failed %d.\n", thread->ctxtype);
+-			goto TermFailed;
+-#endif
+-			break;
+-	}
+-
+-#ifdef DEBUG_BSD_NATIVE_THREADS
+-TermFailed:
+-	fprintf(stderr, "Failed to find pthread struct.\n"); fflush(stderr);
+-	assert(0);
+-
+-Terminate:
+-	dumpThreadStates();
+-#endif
+ }
+-
+-void record_uc(sys_thread_t *t, ucontext_t *uc)
+-{
+-	mcontext_t *mc = &(uc->uc_mcontext);
+-
+-	t->regs[0] = mc->mc_eax;
+-	t->regs[1] = mc->mc_ecx;
+-	t->regs[2] = mc->mc_edx;
+-	t->regs[3] = mc->mc_ebx;
+-	t->regs[4] = mc->mc_ebp;
+-	t->regs[5] = mc->mc_esi;
+-	t->regs[6] = mc->mc_edi;
+-}
+-
+-/*
+-From /usr/src/lib/libc/i386/gen/_setjmp.S:
+-ENTRY(_setjmp)
+-	movl	4(%esp),%eax
+-	movl	0(%esp),%edx
+-	movl	%edx, 0(%eax)	/ * rta * /
+-	movl	%ebx, 4(%eax)
+-	movl	%esp, 8(%eax)
+-	movl	%ebp,12(%eax)
+-	movl	%esi,16(%eax)
+-	movl	%edi,20(%eax)
+-	fnstcw	24(%eax)
+-	xorl	%eax,%eax
+-	ret
+-
+-typedef JmpBufStruct
+-{
+-	int	edx, // Accumulator for operands and results data.
+-		ebx, // Pointer to data in the DS segment.
+-		esp, // Stack pointer (in the SS segment).
+-		ebp, // Pointer to data on the stack (in the SS segment).
+-		esi, // Pointer to data in the segment pointer to by the DS register; source pointer for string operations.
+-		edi; // Pointer to data (or destination) in the segment pointer to by the ES register; destination pointer for string operations.
+-
+-} JmpBufStruct;
+-
+-
+-void record_jb(sys_thread_t *t, JmpBufStruct *jb)
+-{
+-	t->regs[0] = jb->eax; // What about these two register ? they seem missing in jmp_buf.
+-	t->regs[1] = / *jb->ecx;* / 0;
+-	t->regs[2] = jb->edx; // The rest of these registers are defined...
+-	t->regs[3] = jb->ebx;
+-	t->regs[4] = jb->ebp;
+-	t->regs[5] = jb->esi;
+-	t->regs[6] = jb->edi;
+-}
+-*/
+-
+-#if 0
+-static void
+-finish_suspension(void *arg)
+-{
+-	if (_thread_run->suspended != SUSP_NO)
+-		_thread_kern_sched_state(PS_SUSPENDED, __FILE__, __LINE__);
+-}
+-
+-void _pthread_suspend_np_by_pthread_common(pthread_t thread)
+-{
+-struct timeval  tv;
+-struct timespec current_ts;
+-
+-	switch (thread->state) {
+-	case PS_RUNNING:
+-		/*
+-		 * Remove the thread from the priority queue and
+-		 * set the state to suspended:
+-		 */
+-		PTHREAD_PRIOQ_REMOVE(thread);
+-		PTHREAD_SET_STATE(thread, PS_SUSPENDED);
+-		break;
+-
+-	case PS_SPINBLOCK:
+-	case PS_FDR_WAIT:
+-	case PS_FDW_WAIT:
+-	case PS_POLL_WAIT:
+-	case PS_SELECT_WAIT:
+-		/*
+-		 * Remove these threads from the work queue
+-		 * and mark the operation as interrupted:
+-		 */
+-		if ((thread->flags & PTHREAD_FLAGS_IN_WORKQ) != 0)
+-			PTHREAD_WORKQ_REMOVE(thread);
+-		_thread_seterrno(thread,EINTR);
+-
+-		/* FALLTHROUGH */
+-	case PS_SLEEP_WAIT:
+-		thread->interrupted = 1;
+-
+-		/* FALLTHROUGH */
+-	case PS_SIGTHREAD:
+-	case PS_WAIT_WAIT:
+-	case PS_SIGSUSPEND:
+-	case PS_SIGWAIT:
+-		/*
+-		 * Remove these threads from the waiting queue and
+-		 * set their state to suspended:
+-		 */
+-		PTHREAD_WAITQ_REMOVE(thread);
+-		PTHREAD_SET_STATE(thread, PS_SUSPENDED);
+-		break;
+-
+-	case PS_MUTEX_WAIT:
+-		/* Mark the thread as suspended and still in a queue. */
+-		thread->suspended = SUSP_MUTEX_WAIT;
+-
+-		PTHREAD_SET_STATE(thread, PS_SUSPENDED);
+-		break;
+-	case PS_COND_WAIT:
+-#if 0
+-		/* This is for a pthreads_cond_timedwait() --billh */
+-		if (thread->wakeup_time.tv_sec != -1) {
+-			/* (1) Use to restore the waiting-queue time that's left when the
+-			 * thread is resumed. --billh
+-			 */
+-			_subtract_timespec3(thread, &current_ts, &thread->remaining_wakeup_time);
+-
+-			/* (2) So that it's inserted at the end of the waiting queue and
+-			 * not scanned by the uthreads_kern.c waiting queue logic. It also
+-			 * means to make it wait forever.
+-			 */
+-			thread->wakeup_time.tv_sec  = -1;
+-			thread->wakeup_time.tv_nsec = -1;
+-
+-			/* (3) Remove and reinsert it at the end of waiting-queue
+-			 * (automatic on the insertion attempt when (2)).
+-			 */
+-			PTHREAD_WORKQ_REMOVE(thread);
+-			PTHREAD_WORKQ_INSERT(thread);
+-		}
+-#endif
+-
+-		/* Mark the thread as suspended and still in a queue. */
+-		thread->suspended = SUSP_COND_WAIT;
+-
+-		PTHREAD_SET_STATE(thread, PS_SUSPENDED);
+-		break;
+-	case PS_JOIN:
+-		/* Mark the thread as suspended and joining: */
+-		thread->suspended = SUSP_JOIN;
+-
+-		PTHREAD_NEW_STATE(thread, PS_SUSPENDED);
+-		break;
+-	case PS_FDLR_WAIT:
+-	case PS_FDLW_WAIT:
+-	case PS_FILE_WAIT:
+-		/* Mark the thread as suspended: */
+-		thread->suspended = SUSP_YES;
+-
+-		/*
+-		 * Threads in these states may be in queues.
+-		 * In order to preserve queue integrity, the
+-		 * cancelled thread must remove itself from the
+-		 * queue.  Mark the thread as interrupted and
+-		 * set the state to running.  When the thread
+-		 * resumes, it will remove itself from the queue
+-		 * and call the suspension completion routine.
+-		 */
+-		thread->interrupted = 1;
+-		_thread_seterrno(thread, EINTR);
+-		PTHREAD_NEW_STATE(thread, PS_RUNNING);
+-		thread->continuation = finish_suspension;
+-		break;
+-
+-	case PS_DEAD:
+-	case PS_DEADLOCK:
+-	case PS_STATE_MAX:
+-	case PS_SUSPENDED:
+-		/* Nothing needs to be done: */
+-		break;
+-	}
+-}
+-
+-void _pthread_resume_by_pthread_common(pthread_t thread, enum pthread_susp old_suspended)
+-{
+-struct timeval  tv;
+-struct timespec current_ts,
+-		remaining_spec;
+-
+-	/* Is it currently suspended? */
+-	if (thread->state == PS_SUSPENDED) {
+-		/*
+-		 * Defer signals to protect the scheduling queues
+-		 * from access by the signal handler:
+-		 */
+-		_thread_kern_sig_defer();
+-
+-		switch (old_suspended) {
+-		case SUSP_MUTEX_WAIT:
+-			/* Set the thread's state back. */
+-			PTHREAD_SET_STATE(thread,PS_MUTEX_WAIT);
+-			break;
+-		case SUSP_COND_WAIT:
+-			/* For cases where it was doing a pthread_cond_timedwait()
+-			 * Mark the remaining suspend time.
+-			 * --billh
+-			 */
+-#if 0
+-			if (thread->remaining_wakeup_time.tv_sec != -1) {
+-				GET_CURRENT_TOD(tv);
+-				TIMEVAL_TO_TIMESPEC(&tv, &current_ts);
+-
+-				_subtract_timespec3(remaining_spec, &thread->wakeup_time, &current_ts);
+-				_thread_kern_set_timeout_by_pthread_timespec(thread, &remaining_spec);
+-			}
+-#endif
+-
+-			/* Set the thread's state back. */
+-			PTHREAD_SET_STATE(thread,PS_COND_WAIT);
+-			break;
+-		case SUSP_JOIN:
+-			/* Set the thread's state back. */
+-			PTHREAD_SET_STATE(thread,PS_JOIN);
+-			break;
+-		case SUSP_NOWAIT:
+-			/* Allow the thread to run. */
+-			PTHREAD_SET_STATE(thread,PS_RUNNING);
+-			PTHREAD_WAITQ_REMOVE(thread);
+-			PTHREAD_PRIOQ_INSERT_TAIL(thread);
+-			break;
+-		case SUSP_NO:
+-		case SUSP_YES:
+-			/* Allow the thread to run. */
+-			PTHREAD_SET_STATE(thread,PS_RUNNING);
+-			PTHREAD_PRIOQ_INSERT_TAIL(thread);
+-			break;
+-		}
+-
+-		/*
+-		 * Undefer and handle pending signals, yielding if
+-		 * necessary:
+-		 */
+-		_thread_kern_sig_undefer();
+-	}
+-}
+-
+ #endif