Implement zero system call thread switching. Performance of

thread switches should be on par with that under scheduler
activations.

  o Timing is achieved through the use of a fixed interval
    timer (ITIMER_PROF) to count scheduling ticks instead
    of retrieving the time-of-day upon every thread switch
    and calculating elapsed real time.

  o Polling for I/O readiness is performed once for each
    scheduling tick instead of every thread switch.

  o The non-signal saving/restoring versions of setjmp/longjmp
    are used to save and restore thread contexts.  This may
    allow the removal of _THREAD_SAFE macros from setjmp()
    and longjmp() - needs more investigation.

Change signal handling so that signals are handled in the
context of the thread that is receiving the signal.  When
signals are dispatched to a thread, a special signal handling
frame is created on top of the target threads stack.  The
frame contains the threads saved state information and a new
context in which the thread can run.  The applications signal
handler is invoked through a wrapper routine that knows how
to restore the threads saved state and unwind to previous
frames.

Fix interruption of threads due to signals.  Some states
were being improperly interrupted while other states were
not being interrupted.  This should fix several PRs.

Signal handlers, which are invoked as a result of a process
signal (not by pthread_kill()), are now called with the
code (or siginfo_t if SA_SIGINFO was set in sa_flags) and
sigcontext_t as received from the process signal handler.

Modify the search for a thread to which a signal is delivered.
The search algorithm is now:

  o First thread found in sigwait() with signal in wait mask.
  o First thread found sigsuspend()'d on the signal.
  o Current thread if signal is unmasked.
  o First thread found with signal unmasked.

Collapse machine dependent support into macros defined in
pthread_private.h.  These should probably eventually be moved
into separate MD files.

Change the range of settable priorities to be compliant with
POSIX (0-31).  The threads library uses higher priorities
internally for real-time threads (not yet implemented) and
threads executing signal handlers.  Real-time threads and
threads running signal handlers add 64 and 32, respectively,
to a threads base priority.

Some other small changes and cleanups.

PR:		17757 18559 21943
Reviewed by:	jasone

1 files changed, 829 insertions, 413 deletions

diff --git a/lib/libkse/thread/thr_sig.c b/lib/libkse/thread/thr_sig.c
index 86ded7f..8a9aadf 100644
--- a/lib/libkse/thread/thr_sig.c
+++ b/lib/libkse/thread/thr_sig.c
@@ -44,46 +44,47 @@
 #include "pthread_private.h"
 
 /* Prototypes: */
-static void	thread_sig_check_state(pthread_t pthread, int sig);
-static void	thread_sig_finish_longjmp(void *arg);
-static void	handle_state_change(pthread_t pthread);
-
+static void	thread_sig_add(pthread_t pthread, int sig, int has_args);
+static pthread_t thread_sig_find(int sig);
+static void	thread_sig_handle_special(int sig);
+static void	thread_sig_savecontext(pthread_t pthread, ucontext_t *ucp);
+static void	thread_sigframe_add(pthread_t thread, int sig);
+static void	thread_sigframe_leave(pthread_t thread, int frame);
+static void	thread_sigframe_restore(pthread_t thread, struct pthread_signal_frame *psf);
+static void	thread_sigframe_save(pthread_t thread, struct pthread_signal_frame *psf);
+
+/* #define DEBUG_SIGNAL */
+#ifdef DEBUG_SIGNAL
+#define DBG_MSG		stdout_debug
+#else
+#define DBG_MSG(x...)
+#endif
 
-/* Static variables: */
-static spinlock_t	signal_lock = _SPINLOCK_INITIALIZER;
-static unsigned int	pending_sigs[NSIG];
-static unsigned int	handled_sigs[NSIG];
-static int		volatile check_pending = 0;
-static int		volatile check_waiting = 0;
+#if defined(_PTHREADS_INVARIANTS)
+#define SIG_SET_ACTIVE()	_sig_in_handler = 1
+#define SIG_SET_INACTIVE()	_sig_in_handler = 0
+#else
+#define SIG_SET_ACTIVE()
+#define SIG_SET_INACTIVE()
+#endif
 
-/* Initialize signal handling facility: */
 void
-_thread_sig_init(void)
+_thread_sig_handler(int sig, siginfo_t *info, ucontext_t *ucp)
 {
-	int i;
+	pthread_t	pthread;
+	int		current_frame;
+	char		c;
 
-	/* Clear pending and handled signal counts: */
-	for (i = 1; i < NSIG; i++) {
-		pending_sigs[i - 1] = 0;
-		handled_sigs[i - 1] = 0;
-	}
-
-	/* Clear the lock: */
-	signal_lock.access_lock = 0;
-
-	/* Clear the process pending signals: */
-	sigemptyset(&_process_sigpending);
-}
-
-void
-_thread_sig_handler(int sig, int code, ucontext_t * scp)
-{
-	pthread_t pthread, pthread_next;
-	int	i;
-	char	c;
+	if (ucp == NULL)
+		PANIC("Thread signal handler received null context");
+	DBG_MSG("Got signal %d, current thread %p\n", sig, _thread_run);
 
 	/* Check if an interval timer signal: */
 	if (sig == _SCHED_SIGNAL) {
+		/* Update the scheduling clock: */
+		gettimeofday((struct timeval *)&_sched_tod, NULL);
+		_sched_ticks++;
+
 		if (_thread_kern_in_sched != 0) {
 			/*
 			 * The scheduler is already running; ignore this
@@ -97,14 +98,18 @@ _thread_sig_handler(int sig, int code, ucontext_t * scp)
 		 */
 		else if (_thread_run->sig_defer_count > 0)
 			_thread_run->yield_on_sig_undefer = 1;
-
 		else {
 			/*
+			 * Save the context of the currently running thread:
+			 */
+			thread_sig_savecontext(_thread_run, ucp);
+
+			/*
 			 * Schedule the next thread. This function is not
 			 * expected to return because it will do a longjmp
 			 * instead. 
 			 */
-			_thread_kern_sched(scp);
+			_thread_kern_sched(ucp);
 
 			/*
 			 * This point should not be reached, so abort the
@@ -118,8 +123,8 @@ _thread_sig_handler(int sig, int code, ucontext_t * scp)
 	 * is accessing the scheduling queues or if there is a currently
 	 * running thread that has deferred signals.
 	 */
-	else if ((_queue_signals != 0) || ((_thread_kern_in_sched == 0) &&
-	    (_thread_run->sig_defer_count > 0))) {
+	else if ((_thread_kern_in_sched != 0) ||
+	    (_thread_run->sig_defer_count > 0)) {
 		/* Cast the signal number to a character variable: */
 		c = sig;
 
@@ -127,117 +132,150 @@ _thread_sig_handler(int sig, int code, ucontext_t * scp)
 		 * Write the signal number to the kernel pipe so that it will
 		 * be ready to read when this signal handler returns.
 		 */
-		_thread_sys_write(_thread_kern_pipe[1], &c, 1);
+		if (_queue_signals != 0) {
+			_thread_sys_write(_thread_kern_pipe[1], &c, 1);
+			DBG_MSG("Got signal %d, queueing to kernel pipe\n", sig);
+		}
+		if (_thread_sigq[sig - 1].blocked == 0) {
+			DBG_MSG("Got signal %d, adding to _thread_sigq\n", sig);
+			/*
+			 * Do not block this signal; it will be blocked
+			 * when the pending signals are run down.
+			 */
+			/* _thread_sigq[sig - 1].blocked = 1; */
 
-		/* Indicate that there are queued signals in the pipe. */
-		_sigq_check_reqd = 1;
-	} else {
-		if (_atomic_lock(&signal_lock.access_lock)) {
-			/* There is another signal handler running: */
-			pending_sigs[sig - 1]++;
-			check_pending = 1;
+			/*
+			 * Queue the signal, saving siginfo and sigcontext
+			 * (ucontext).
+			 *
+			 * XXX - Do we need to copy siginfo and ucp?
+			 */
+			_thread_sigq[sig - 1].signo = sig;
+			if (info != NULL)
+				memcpy(&_thread_sigq[sig - 1].siginfo, info,
+				    sizeof(*info));
+			memcpy(&_thread_sigq[sig - 1].uc, ucp, sizeof(*ucp));
+
+			/* Indicate that there are queued signals: */
+			_thread_sigq[sig - 1].pending = 1;
+			_sigq_check_reqd = 1;
 		}
-		else {
-			/* It's safe to handle the signal now. */
-			pthread = _thread_sig_handle(sig, scp);
+		/* These signals need special handling: */
+		else if (sig == SIGCHLD || sig == SIGTSTP ||
+		    sig == SIGTTIN || sig == SIGTTOU) {
+			_thread_sigq[sig - 1].pending = 1;
+			_thread_sigq[sig - 1].signo = sig;
+			_sigq_check_reqd = 1;
+		}
+		else
+			DBG_MSG("Got signal %d, ignored.\n", sig);
+	}
+	/*
+	 * The signal handlers should have been installed so that they
+	 * cannot be interrupted by other signals.
+	 */
+	else if (_thread_sigq[sig - 1].blocked == 0) {
+		/* The signal is not blocked; handle the signal: */
+		current_frame = _thread_run->sigframe_count;
 
-			/* Reset the pending and handled count back to 0: */
-			pending_sigs[sig - 1] = 0;
-			handled_sigs[sig - 1] = 0;
+		/*
+		 * Ignore subsequent occurrences of this signal
+		 * until the current signal is handled:
+		 */
+		_thread_sigq[sig - 1].blocked = 1;
 
-			if (pthread == NULL)
-				signal_lock.access_lock = 0;
-			else {
-				sigaddset(&pthread->sigmask, sig);
+		/* This signal will be handled; clear the pending flag: */
+		_thread_sigq[sig - 1].pending = 0;
 
-				/*
-				 * Make sure not to deliver the same signal to
-				 * the thread twice.  sigpend is potentially
-				 * modified by the call chain
-				 * _thread_sig_handle() -->
-				 * thread_sig_check_state(), which can happen
-				 * just above.
-				 */
-				if (sigismember(&pthread->sigpend, sig))
-					sigdelset(&pthread->sigpend, sig);
+		/*
+		 * Save siginfo and sigcontext (ucontext).
+		 *
+		 * XXX - Do we need to copy siginfo and ucp?
+		 */
+		_thread_sigq[sig - 1].signo = sig;
 
-				signal_lock.access_lock = 0;
-				_thread_sig_deliver(pthread, sig);
-				sigdelset(&pthread->sigmask, sig);
-			}
-		}
+		if (info != NULL)
+			memcpy(&_thread_sigq[sig - 1].siginfo, info,
+			    sizeof(*info));
+		memcpy(&_thread_sigq[sig - 1].uc, ucp, sizeof(*ucp));
+		SIG_SET_ACTIVE();
 
-		/* Enter a loop to process pending signals: */
-		while ((check_pending != 0) &&
-		    (_atomic_lock(&signal_lock.access_lock) == 0)) {
-			check_pending = 0;
-			for (i = 1; i < NSIG; i++) {
-				if (pending_sigs[i - 1] > handled_sigs[i - 1]) {
-					pending_sigs[i - 1] = handled_sigs[i - 1];
-					pthread = _thread_sig_handle(i, scp);
-					if (pthread != NULL) {
-						sigaddset(&pthread->sigmask, i);
-						/* Save the old state: */
-						pthread->oldstate = pthread->state;
-						signal_lock.access_lock = 0;
-						_thread_sig_deliver(pthread, i);
-						sigdelset(&pthread->sigmask, i);
-						if (_atomic_lock(&signal_lock.access_lock)) {
-							check_pending = 1;
-							/*
-							 * Have the lock holder take care
-							 * of any state changes:
-							 */
-							if (pthread->state != pthread->oldstate)
-								check_waiting = 1;
-							return;
-						}
-						if (pthread->state != pthread->oldstate)
-							handle_state_change(pthread);
-					}
-				}
-			}
-			while (check_waiting != 0) {
-				check_waiting = 0;
-				/*
-				 * Enter a loop to wake up all threads waiting
-				 * for a process to complete:
-				 */
-				for (pthread = TAILQ_FIRST(&_waitingq);
-				    pthread != NULL; pthread = pthread_next) {
-					pthread_next = TAILQ_NEXT(pthread, pqe);
-					if (pthread->state == PS_RUNNING)
-						handle_state_change(pthread);
-				}
-			}
-			/* Release the lock: */
-			signal_lock.access_lock = 0;
+		/* Handle special signals: */
+		thread_sig_handle_special(sig);
+
+		if ((pthread = thread_sig_find(sig)) != NULL) {
+			DBG_MSG("Got signal %d, adding frame to thread %p\n",
+			    sig, pthread);
+			/*
+			 * A thread was found that can handle the signal.
+			 * Save the context of the currently running thread
+			 * so that we can switch to another thread without
+			 * losing track of where the current thread left off.
+			 * This also applies if the current thread is the
+			 * thread to be signaled.
+			 */
+			thread_sig_savecontext(_thread_run, ucp);
+
+			/* Setup the target thread to receive the signal: */
+			thread_sig_add(pthread, sig, /*has_args*/ 1);
+
+			/* Take a peek at the next ready to run thread: */
+			pthread = PTHREAD_PRIOQ_FIRST();
+			DBG_MSG("Finished adding frame, head of prio list %p\n",
+			    pthread);
 		}
+		else
+			DBG_MSG("No thread to handle signal %d\n", sig);
+		SIG_SET_INACTIVE();
 
 		/*
-		 * Check to see if the current thread performed a
-		 * [sig|_]longjmp() out of a signal handler.
+		 * Switch to a different context if the currently running
+		 * thread takes a signal, or if another thread takes a
+		 * signal and the currently running thread is not in a
+		 * signal handler.
 		 */
-		if ((_thread_run->jmpflags & (JMPFLAGS_LONGJMP |
-		    JMPFLAGS__LONGJMP)) != 0) {
-			_thread_run->jmpflags = JMPFLAGS_NONE;
-			__longjmp(_thread_run->nested_jmp.jmp,
-			    _thread_run->longjmp_val);
-		} else if ((_thread_run->jmpflags & JMPFLAGS_SIGLONGJMP) != 0) {
-			_thread_run->jmpflags = JMPFLAGS_NONE;
-			__siglongjmp(_thread_run->nested_jmp.sigjmp,
-			    _thread_run->longjmp_val);
+		if ((_thread_run->sigframe_count > current_frame) ||
+		    ((pthread != NULL) &&
+		    (pthread->active_priority > _thread_run->active_priority))) {
+			/* Enter the kernel scheduler: */
+			DBG_MSG("Entering scheduler from signal handler\n");
+			_thread_kern_sched(ucp);
 		}
 	}
+	else {
+		SIG_SET_ACTIVE();
+		thread_sig_handle_special(sig);
+		SIG_SET_INACTIVE();
+	}
 }
 
+static void
+thread_sig_savecontext(pthread_t pthread, ucontext_t *ucp)
+{
+	struct pthread_signal_frame	*psf;
+
+	psf = _thread_run->curframe;
+
+	memcpy(&psf->ctx.uc, ucp, sizeof(*ucp));
+
+	/* XXX - Save FP registers too? */
+	FP_SAVE_UC(&psf->ctx.uc);
+
+	/* Mark the context saved as a ucontext: */
+	psf->ctxtype = CTX_UC;
+}
+
+/*
+ * Find a thread that can handle the signal.
+ */
 pthread_t
-_thread_sig_handle(int sig, ucontext_t * scp)
+thread_sig_find(int sig)
 {
-	int		i, handler_installed;
+	int		handler_installed;
 	pthread_t	pthread, pthread_next;
 	pthread_t	suspended_thread, signaled_thread;
 
+	DBG_MSG("Looking for thread to handle signal %d\n", sig);
 	/* Check if the signal requires a dump of thread information: */
 	if (sig == SIGINFO)
 		/* Dump thread information to file: */
@@ -249,77 +287,22 @@ _thread_sig_handle(int sig, ucontext_t * scp)
 		 * This shouldn't ever occur (should this panic?).
 		 */
 	} else {
-		/* Check if a child has terminated: */
-		if (sig == SIGCHLD) {
-			/*
-			 * Go through the file list and set all files
-			 * to non-blocking again in case the child
-			 * set some of them to block. Sigh.
-			 */
-			for (i = 0; i < _thread_dtablesize; i++) {
-				/* Check if this file is used: */
-				if (_thread_fd_table[i] != NULL) {
-					/*
-					 * Set the file descriptor to
-					 * non-blocking:
-					 */
-					_thread_sys_fcntl(i, F_SETFL,
-					    _thread_fd_table[i]->flags |
-					    O_NONBLOCK);
-				}
-			}
-			/*
-			 * Enter a loop to wake up all threads waiting
-			 * for a process to complete:
-			 */
-			for (pthread = TAILQ_FIRST(&_waitingq);
-			    pthread != NULL; pthread = pthread_next) {
-				/*
-				 * Grab the next thread before possibly
-				 * destroying the link entry:
-				 */
-				pthread_next = TAILQ_NEXT(pthread, pqe);
-
-				/*
-				 * If this thread is waiting for a child
-				 * process to complete, wake it up:
-				 */
-				if (pthread->state == PS_WAIT_WAIT) {
-					/* Make the thread runnable: */
-					PTHREAD_NEW_STATE(pthread,PS_RUNNING);
-
-					/* Return the signal number: */
-					pthread->signo = sig;
-				}
-			}
-		}
-
-		/*
-		 * POSIX says that pending SIGCONT signals are
-		 * discarded when one of these signals occurs.
-		 */
-		if (sig == SIGTSTP || sig == SIGTTIN || sig == SIGTTOU) {
-			/*
-			 * Enter a loop to discard pending SIGCONT
-			 * signals:
-			 */
-			TAILQ_FOREACH(pthread, &_thread_list, tle) {
-				sigdelset(&pthread->sigpend,SIGCONT);
-			}
-		}
-
 		/*
 		 * Enter a loop to look for threads that have the signal
 		 * unmasked.  POSIX specifies that a thread in a sigwait
 		 * will get the signal over any other threads.  Second
-		 * preference will be threads in in a sigsuspend.  If
-		 * none of the above, then the signal is delivered to the
-		 * first thread we find.  Note that if a custom handler
-		 * is not installed, the signal only affects threads in
-		 * sigwait.
+		 * preference will be threads in in a sigsuspend.  Third
+		 * preference will be the current thread.  If none of the
+		 * above, then the signal is delivered to the first thread
+		 * that is found.  Note that if a custom handler is not
+		 * installed, the signal only affects threads in sigwait.
 		 */
 		suspended_thread = NULL;
-		signaled_thread = NULL;
+		if ((_thread_run != &_thread_kern_thread) &&
+		    !sigismember(&_thread_run->sigmask, sig))
+			signaled_thread = _thread_run;
+		else
+			signaled_thread = NULL;
 		if ((_thread_sigact[sig - 1].sa_handler == SIG_IGN) ||
 		    (_thread_sigact[sig - 1].sa_handler == SIG_DFL))
 			handler_installed = 0;
@@ -338,6 +321,13 @@ _thread_sig_handle(int sig, ucontext_t * scp)
 			    sigismember(pthread->data.sigwait, sig)) {
 				/* Change the state of the thread to run: */
 				PTHREAD_NEW_STATE(pthread,PS_RUNNING);
+				/*
+				 * A signal handler is not invoked for threads
+				 * in sigwait.  Clear the blocked and pending
+				 * flags.
+				 */ 
+				_thread_sigq[sig - 1].blocked = 0;
+				_thread_sigq[sig - 1].pending = 0;
 
 				/* Return the signal number: */
 				pthread->signo = sig;
@@ -349,7 +339,8 @@ _thread_sig_handle(int sig, ucontext_t * scp)
 				 * we find.
 				 *
 				 * Do not attempt to deliver this signal
-				 * to other threads.
+				 * to other threads and do not add the signal
+				 * to the process pending set.
 				 */
 				return (NULL);
 			}
@@ -367,7 +358,14 @@ _thread_sig_handle(int sig, ucontext_t * scp)
 		 * Only perform wakeups and signal delivery if there is a
 		 * custom handler installed:
 		 */
-		if (handler_installed != 0) {
+		if (handler_installed == 0) {
+			/*
+			 * There is no handler installed.  Unblock the
+			 * signal so that if a handler _is_ installed, any
+			 * subsequent signals can be handled.
+			 */
+			_thread_sigq[sig - 1].blocked = 0;
+		} else {
 			/*
 			 * If we didn't find a thread in the waiting queue,
 			 * check the all threads queue:
@@ -403,12 +401,6 @@ _thread_sig_handle(int sig, ucontext_t * scp)
 					pthread = suspended_thread;
 				else
 					pthread = signaled_thread;
-
-				/*
-				 * Perform any state changes due to signal
-				 * arrival:
-				 */
-				thread_sig_check_state(pthread, sig);
 				return (pthread);
 			}
 		}
@@ -418,100 +410,166 @@ _thread_sig_handle(int sig, ucontext_t * scp)
 	return (NULL);
 }
 
-static void
-thread_sig_finish_longjmp(void *arg)
+void
+_thread_sig_check_pending(pthread_t pthread)
 {
+	sigset_t	sigset;
+	int		i;
+
 	/*
-	 * Check to see if the current thread performed a [_]longjmp() out of a
-	 * signal handler.
+	 * Check if there are pending signals for the running
+	 * thread or process that aren't blocked:
 	 */
-	if ((_thread_run->jmpflags & (JMPFLAGS_LONGJMP | JMPFLAGS__LONGJMP))
-	    != 0) {
-		_thread_run->jmpflags = JMPFLAGS_NONE;
-		_thread_run->continuation = NULL;
-		__longjmp(_thread_run->nested_jmp.jmp,
-		    _thread_run->longjmp_val);
+	sigset = pthread->sigpend;
+	SIGSETOR(sigset, _process_sigpending);
+	SIGSETNAND(sigset, pthread->sigmask);
+	if (SIGNOTEMPTY(sigset)) {
+		for (i = 1; i < NSIG; i++) {
+			if (sigismember(&sigset, i) != 0) {
+				if (sigismember(&pthread->sigpend, i) != 0)
+					thread_sig_add(pthread, i,
+					    /*has_args*/ 0);
+				else {
+					thread_sig_add(pthread, i,
+					    /*has_args*/ 1);
+					sigdelset(&_process_sigpending, i);
+				}
+			}
+		}
 	}
+}
+
+/*
+ * This can only be called from the kernel scheduler.  It assumes that
+ * all thread contexts are saved and that a signal frame can safely be
+ * added to any user thread.
+ */
+void
+_thread_sig_handle_pending(void)
+{
+	pthread_t	pthread;
+	int		i, sig;
+
+	PTHREAD_ASSERT(_thread_kern_in_sched != 0,
+	    "_thread_sig_handle_pending called from outside kernel schedule");
 	/*
-	 * Check to see if the current thread performed a siglongjmp
-	 * out of a signal handler:
+	 * Check the array of pending signals:
 	 */
-	else if ((_thread_run->jmpflags & JMPFLAGS_SIGLONGJMP) != 0) {
-		_thread_run->jmpflags = JMPFLAGS_NONE;
-		_thread_run->continuation = NULL;
-		__siglongjmp(_thread_run->nested_jmp.sigjmp,
-		    _thread_run->longjmp_val);
+	for (i = 0; i < NSIG; i++) {
+		if (_thread_sigq[i].pending != 0) {
+			/* This signal is no longer pending. */
+			_thread_sigq[i].pending = 0;
+
+			sig = _thread_sigq[i].signo;
+
+			/* Some signals need special handling: */
+			thread_sig_handle_special(sig);
+
+			if (_thread_sigq[i].blocked == 0) {
+				/*
+				 * Block future signals until this one
+				 * is handled:
+				 */
+				_thread_sigq[i].blocked = 1;
+
+				if ((pthread = thread_sig_find(sig)) != NULL) {
+					/*
+					 * Setup the target thread to receive
+					 * the signal:
+					 */
+					thread_sig_add(pthread, sig,
+					    /*has_args*/ 1);
+				}
+			}
+		}
 	}
 }
 
 static void
-handle_state_change(pthread_t pthread)
+thread_sig_handle_special(int sig)
 {
-	/*
-	 * We should only need to handle threads whose state was
-	 * changed to running:
-	 */
-	if (pthread->state == PS_RUNNING) {
-		switch (pthread->oldstate) {
+	pthread_t	pthread, pthread_next;
+	int		i;
+
+	switch (sig) {
+	case SIGCHLD:
 		/*
-		 * States which do not change when a signal is trapped:
+		 * Go through the file list and set all files
+		 * to non-blocking again in case the child
+		 * set some of them to block. Sigh.
 		 */
-		case PS_DEAD:
-		case PS_DEADLOCK:
-		case PS_RUNNING:
-		case PS_SIGTHREAD:
-		case PS_STATE_MAX:
-		case PS_SUSPENDED:
-			break;
-
+		for (i = 0; i < _thread_dtablesize; i++) {
+			/* Check if this file is used: */
+			if (_thread_fd_table[i] != NULL) {
+				/*
+				 * Set the file descriptor to non-blocking:
+				 */
+				_thread_sys_fcntl(i, F_SETFL,
+				    _thread_fd_table[i]->flags | O_NONBLOCK);
+			}
+		}
 		/*
-		 * States which need to return to critical sections
-		 * before they can switch contexts:
+		 * Enter a loop to wake up all threads waiting
+		 * for a process to complete:
 		 */
-		case PS_COND_WAIT:
-		case PS_FDLR_WAIT:
-		case PS_FDLW_WAIT:
-		case PS_FILE_WAIT:
-		case PS_JOIN:
-		case PS_MUTEX_WAIT:
-			/* Indicate that the thread was interrupted: */
-			pthread->interrupted = 1;
+		for (pthread = TAILQ_FIRST(&_waitingq);
+		    pthread != NULL; pthread = pthread_next) {
+			/*
+			 * Grab the next thread before possibly
+			 * destroying the link entry:
+			 */
+			pthread_next = TAILQ_NEXT(pthread, pqe);
+
 			/*
-			 * Defer the [sig|_]longjmp until leaving the critical
-			 * region:
+			 * If this thread is waiting for a child
+			 * process to complete, wake it up:
 			 */
-			pthread->jmpflags |= JMPFLAGS_DEFERRED;
-
-			/* Set the continuation routine: */
-			pthread->continuation = thread_sig_finish_longjmp;
-			/* FALLTHROUGH */
-		case PS_FDR_WAIT:
-		case PS_FDW_WAIT:
-		case PS_POLL_WAIT:
-		case PS_SELECT_WAIT:
-		case PS_SIGSUSPEND:
-		case PS_SIGWAIT:
-		case PS_SLEEP_WAIT:
-		case PS_SPINBLOCK:
-		case PS_WAIT_WAIT:
-			if ((pthread->flags & PTHREAD_FLAGS_IN_WAITQ) != 0) {
-				PTHREAD_WAITQ_REMOVE(pthread);
-				if (pthread->flags & PTHREAD_FLAGS_IN_WORKQ)
-					PTHREAD_WORKQ_REMOVE(pthread);
+			if (pthread->state == PS_WAIT_WAIT) {
+				/* Make the thread runnable: */
+				PTHREAD_NEW_STATE(pthread,PS_RUNNING);
+
+				/* Return the signal number: */
+				pthread->signo = sig;
 			}
-			break;
 		}
+		break;
 
-		if ((pthread->flags & PTHREAD_FLAGS_IN_PRIOQ) == 0)
-			PTHREAD_PRIOQ_INSERT_TAIL(pthread);
+	/*
+	 * POSIX says that pending SIGCONT signals are
+	 * discarded when one of these signals occurs.
+	 */
+	case SIGTSTP:
+	case SIGTTIN:
+	case SIGTTOU:
+		/*
+		 * Enter a loop to discard pending SIGCONT
+		 * signals:
+		 */
+		TAILQ_FOREACH(pthread, &_thread_list, tle) {
+			sigdelset(&pthread->sigpend, SIGCONT);
+		}
+		break;
+
+	default:
+		break;
 	}
 }
 
-
-/* Perform thread specific actions in response to a signal: */
+/*
+ * Perform thread specific actions in response to a signal.
+ * This function is only called if there is a handler installed
+ * for the signal, and if the target thread has the signal
+ * unmasked.
+ */
 static void
-thread_sig_check_state(pthread_t pthread, int sig)
+thread_sig_add(pthread_t pthread, int sig, int has_args)
 {
+	int	restart, frame;
+	int	block_signals = 0;
+	int	suppress_handler = 0;
+
+	restart = _thread_sigact[sig - 1].sa_flags & SA_RESTART;
+
 	/*
 	 * Process according to thread state:
 	 */
@@ -519,32 +577,54 @@ thread_sig_check_state(pthread_t pthread, int sig)
 	/*
 	 * States which do not change when a signal is trapped:
 	 */
-	case PS_COND_WAIT:
 	case PS_DEAD:
 	case PS_DEADLOCK:
-	case PS_FILE_WAIT:
-	case PS_JOIN:
-	case PS_MUTEX_WAIT:
-	case PS_RUNNING:
 	case PS_STATE_MAX:
 	case PS_SIGTHREAD:
-	case PS_SPINBLOCK:
+		/*
+		 * You can't call a signal handler for threads in these
+		 * states.
+		 */
+		suppress_handler = 1;
+		break;
+
+	/*
+	 * States which do not need any cleanup handling when signals
+	 * occur:
+	 */
+	case PS_RUNNING:
+		/*
+		 * Remove the thread from the queue before changing its
+		 * priority:
+		 */
+		if ((pthread->flags & PTHREAD_FLAGS_IN_PRIOQ) != 0)
+			PTHREAD_PRIOQ_REMOVE(pthread);
+		break;
+
 	case PS_SUSPENDED:
-		/* Increment the pending signal count. */
-		sigaddset(&pthread->sigpend,sig);
+		break;
+
+	case PS_SPINBLOCK:
+		/* Remove the thread from the workq and waitq: */
+		PTHREAD_WORKQ_REMOVE(pthread);
+		PTHREAD_WAITQ_REMOVE(pthread);
+		/* Make the thread runnable: */
+		PTHREAD_SET_STATE(pthread, PS_RUNNING);
 		break;
 
 	case PS_SIGWAIT:
+		/* The signal handler is not called for threads in SIGWAIT. */
+		suppress_handler = 1;
 		/* Wake up the thread if the signal is blocked. */
 		if (sigismember(pthread->data.sigwait, sig)) {
 			/* Change the state of the thread to run: */
-			PTHREAD_NEW_STATE(pthread,PS_RUNNING);
+			PTHREAD_NEW_STATE(pthread, PS_RUNNING);
 
 			/* Return the signal number: */
 			pthread->signo = sig;
 		} else
 			/* Increment the pending signal count. */
-			sigaddset(&pthread->sigpend,sig);
+			sigaddset(&pthread->sigpend, sig);
 		break;
 
 	/*
@@ -552,64 +632,142 @@ thread_sig_check_state(pthread_t pthread, int sig)
 	 * SIGCHLD signals.
 	 */
 	case PS_WAIT_WAIT:
-		/*
-		 * Check for signals other than the death of a child
-		 * process:
-		 */
-		if (sig != SIGCHLD)
-			/* Flag the operation as interrupted: */
-			pthread->interrupted = 1;
+		if (sig == SIGCHLD) {
+			/* Change the state of the thread to run: */
+			PTHREAD_WAITQ_REMOVE(pthread);
+			PTHREAD_SET_STATE(pthread, PS_RUNNING);
 
-		/* Change the state of the thread to run: */
-		PTHREAD_NEW_STATE(pthread,PS_RUNNING);
+			/* Return the signal number: */
+			pthread->signo = sig;
+		}
+		else {
+			/*
+			 * Mark the thread as interrupted only if the
+			 * restart flag is not set on the signal action:
+			 */
+			if (restart == 0)
+				pthread->interrupted = 1;
+			PTHREAD_WAITQ_REMOVE(pthread);
+			PTHREAD_SET_STATE(pthread, PS_RUNNING);
+		}
+		break;
 
-		/* Return the signal number: */
-		pthread->signo = sig;
+	/*
+	 * States which cannot be interrupted but still require the
+	 * signal handler to run:
+	 */
+	case PS_COND_WAIT:
+	case PS_JOIN:
+	case PS_MUTEX_WAIT:
+		/*
+		 * Remove the thread from the wait queue.  It will
+		 * be added back to the wait queue once all signal
+		 * handlers have been invoked.
+		 */
+		PTHREAD_WAITQ_REMOVE(pthread);
 		break;
 
 	/*
-	 * States that are interrupted by the occurrence of a signal
-	 * other than the scheduling alarm: 
+	 * States which are interruptible but may need to be removed
+	 * from queues before any signal handler is called.
+	 *
+	 * XXX - We may not need to handle this condition, but will
+	 *       mark it as a potential problem.
 	 */
 	case PS_FDLR_WAIT:
 	case PS_FDLW_WAIT:
+	case PS_FILE_WAIT:
+		if (restart == 0)
+			pthread->interrupted = 1;
+		/*
+		 * Remove the thread from the wait queue.  Our
+		 * signal handler hook will remove this thread
+		 * from the fd or file queue before invoking
+		 * the actual handler.
+		 */
+		PTHREAD_WAITQ_REMOVE(pthread);
+		/*
+		 * To ensure the thread is removed from the fd and file
+		 * queues before any other signal interrupts it, set the
+		 * signal mask to block all signals.  As soon as the thread
+		 * is removed from the queue the signal mask will be
+		 * restored.
+		 */
+		block_signals = 1;
+		break;
+
+	/*
+	 * States which are interruptible:
+	 */
 	case PS_FDR_WAIT:
 	case PS_FDW_WAIT:
-	case PS_POLL_WAIT:
-	case PS_SLEEP_WAIT:
-	case PS_SELECT_WAIT:
-		if ((_thread_sigact[sig - 1].sa_flags & SA_RESTART) == 0) {
-			/* Flag the operation as interrupted: */
+		if (restart == 0) {
+			/*
+			 * Flag the operation as interrupted and
+			 * set the state to running:
+			 */
 			pthread->interrupted = 1;
-
-			if (pthread->flags & PTHREAD_FLAGS_IN_WORKQ)
-				PTHREAD_WORKQ_REMOVE(pthread);
-
-			/* Change the state of the thread to run: */
-			PTHREAD_NEW_STATE(pthread,PS_RUNNING);
-
-			/* Return the signal number: */
-			pthread->signo = sig;
+			PTHREAD_SET_STATE(pthread, PS_RUNNING);
 		}
+		PTHREAD_WORKQ_REMOVE(pthread);
+		PTHREAD_WAITQ_REMOVE(pthread);
 		break;
 
-	case PS_SIGSUSPEND:
+	case PS_POLL_WAIT:
+	case PS_SELECT_WAIT:
+	case PS_SLEEP_WAIT:
 		/*
-		 * Only wake up the thread if there is a handler installed
-		 * for the signal.
+		 * Unmasked signals always cause poll, select, and sleep
+		 * to terminate early, regardless of SA_RESTART:
 		 */
-		if (_thread_sigact[sig - 1].sa_handler != SIG_DFL) {
-			/* Change the state of the thread to run: */
-			PTHREAD_NEW_STATE(pthread,PS_RUNNING);
+		pthread->interrupted = 1;
+		/* Remove threads in poll and select from the workq: */
+		if ((pthread->flags & PTHREAD_FLAGS_IN_WORKQ) != 0)
+			PTHREAD_WORKQ_REMOVE(pthread);
+		PTHREAD_WAITQ_REMOVE(pthread);
+		PTHREAD_SET_STATE(pthread, PS_RUNNING);
+		break;
 
-			/* Return the signal number: */
-			pthread->signo = sig;
-		}
+	case PS_SIGSUSPEND:
+		PTHREAD_WAITQ_REMOVE(pthread);
+		PTHREAD_SET_STATE(pthread, PS_RUNNING);
 		break;
 	}
+
+	if (suppress_handler == 0) {
+		/*
+		 * Save the current state of the thread and add a
+		 * new signal frame.
+		 */
+		frame = pthread->sigframe_count;
+		thread_sigframe_save(pthread, pthread->curframe);
+		thread_sigframe_add(pthread, sig);
+		pthread->sigframes[frame + 1]->sig_has_args = has_args;
+		SIGSETOR(pthread->sigmask, _thread_sigact[sig - 1].sa_mask);
+		if (block_signals != 0) {
+			/* Save the signal mask and block all signals: */
+			pthread->sigframes[frame + 1]->saved_state.psd_sigmask =
+			    pthread->sigmask;
+			sigfillset(&pthread->sigmask);
+		}
+		
+		/* Make sure the thread is runnable: */
+		if (pthread->state != PS_RUNNING)
+			PTHREAD_SET_STATE(pthread, PS_RUNNING);
+		/*
+		 * The thread should be removed from all scheduling
+		 * queues at this point.  Raise the priority and place
+		 * the thread in the run queue.
+		 */
+		pthread->active_priority |= PTHREAD_SIGNAL_PRIORITY;
+		if (pthread != _thread_run)
+			PTHREAD_PRIOQ_INSERT_TAIL(pthread);
+	}
 }
 
-/* Send a signal to a specific thread (ala pthread_kill): */
+/*
+ * Send a signal to a specific thread (ala pthread_kill):
+ */
 void
 _thread_sig_send(pthread_t pthread, int sig)
 {
@@ -620,142 +778,400 @@ _thread_sig_send(pthread_t pthread, int sig)
 		if (pthread->state == PS_SIGWAIT &&
 		    sigismember(pthread->data.sigwait, sig)) {
 			/* Change the state of the thread to run: */
-			PTHREAD_NEW_STATE(pthread,PS_RUNNING);
+			PTHREAD_NEW_STATE(pthread, PS_RUNNING);
 
 			/* Return the signal number: */
 			pthread->signo = sig;
-		} else if (pthread->state != PS_SIGWAIT &&
-		    !sigismember(&pthread->sigmask, sig)) {
-			/* Perform any state changes due to signal arrival: */
-			thread_sig_check_state(pthread, sig);
-			/* Increment the pending signal count. */
-			sigaddset(&pthread->sigpend,sig);
+		} else if (pthread == _thread_run) {
+			/* Add the signal to the pending set: */
+			sigaddset(&pthread->sigpend, sig);
+			/*
+			 * Deliver the signal to the process if a
+			 * handler is not installed:
+			 */
+			if (_thread_sigact[sig - 1].sa_handler == SIG_DFL)
+				kill(getpid(), sig);
+			if (!sigismember(&pthread->sigmask, sig)) {
+				/*
+				 * Call the kernel scheduler which will safely
+				 * install a signal frame for this thread:
+				 */
+				_thread_kern_sched_sig();
+			}
 		} else {
-			/* Increment the pending signal count. */
-			sigaddset(&pthread->sigpend,sig);
+			if (pthread->state != PS_SIGWAIT &&
+		 	   !sigismember(&pthread->sigmask, sig)) {
+				/* Protect the scheduling queues: */
+				_thread_kern_sig_defer();
+				/*
+				 * Perform any state changes due to signal
+				 * arrival:
+				 */
+				thread_sig_add(pthread, sig, /* has args */ 0);
+				/* Unprotect the scheduling queues: */
+				_thread_kern_sig_undefer();
+			}
+			else
+				/* Increment the pending signal count. */
+				sigaddset(&pthread->sigpend,sig);
+
+			/*
+			 * Deliver the signal to the process if a
+			 * handler is not installed:
+			 */
+			if (_thread_sigact[sig - 1].sa_handler == SIG_DFL)
+				kill(getpid(), sig);
 		}
 	}
 }
 
-/* Dispatch pending signals to the running thread: */
+/*
+ * User thread signal handler wrapper.
+ *
+ *   thread - current running thread
+ */
 void
-_dispatch_signals()
+_thread_sig_wrapper(void)
 {
-	sigset_t sigset;
-	int i;
+	void (*sigfunc)(int, siginfo_t *, void *);
+	struct pthread_signal_frame *psf;
+	pthread_t thread;
+	int	dead = 0;
+	int	i, sig, has_args;
+	int	frame, dst_frame;
+
+	thread = _thread_run;
+
+	/* Get the current frame and state: */
+	frame = thread->sigframe_count;
+	PTHREAD_ASSERT(frame > 0, "Invalid signal frame in signal handler");
+	psf = thread->curframe;
+
+	/* Check the threads previous state: */ 
+	if (psf->saved_state.psd_state != PS_RUNNING) {
+		/*
+		 * Do a little cleanup handling for those threads in
+		 * queues before calling the signal handler.  Signals
+		 * for these threads are temporarily blocked until
+		 * after cleanup handling.
+		 */
+		switch (psf->saved_state.psd_state) {
+		case PS_FDLR_WAIT:
+		case PS_FDLW_WAIT:
+			_fd_lock_backout(thread);
+			psf->saved_state.psd_state = PS_RUNNING;
+			/* Reenable signals: */
+			thread->sigmask = psf->saved_state.psd_sigmask;
+			break;
+
+		case PS_FILE_WAIT:
+			_flockfile_backout(thread);
+			psf->saved_state.psd_state = PS_RUNNING;
+			/* Reenable signals: */
+			thread->sigmask = psf->saved_state.psd_sigmask;
+			break;
+
+		default:
+			break;
+		}
+	}
 
 	/*
-	 * Check if there are pending signals for the running
-	 * thread or process that aren't blocked:
+	 * Unless the thread exits or longjmps out of the signal handler,
+	 * return to the previous frame:
 	 */
-	sigset = _thread_run->sigpend;
-	SIGSETOR(sigset, _process_sigpending);
-	SIGSETNAND(sigset, _thread_run->sigmask);
-	if (SIGNOTEMPTY(sigset)) {
+	dst_frame = frame - 1;
+
+	/*
+	 * Check that a custom handler is installed and if the signal
+	 * is not blocked:
+	 */
+	sigfunc = _thread_sigact[psf->signo - 1].sa_sigaction;
+	if (((__sighandler_t *)sigfunc != SIG_DFL) &&
+	    ((__sighandler_t *)sigfunc != SIG_IGN)) {
 		/*
-		 * Enter a loop to calculate deliverable pending signals
-		 * before actually delivering them.  The pending signals
-		 * must be removed from the pending signal sets before
-		 * calling the signal handler because the handler may
-		 * call library routines that again check for and deliver
-		 * pending signals.
+		 * The signal jump buffer is allocated off the stack.
+		 * If the signal handler tries to [_][sig]longjmp() or
+		 * setcontext(), our wrapped versions of these routines
+		 * will copy the user supplied jump buffer or context
+		 * to the destination signal frame, set the destination
+		 * signal frame in psf->dst_frame, and _longjmp() back
+		 * to here.
 		 */
-		for (i = 1; i < NSIG; i++) {
+		jmp_buf	jb;
+
+		/*
+		 * Set up the context for abnormal returns out of signal
+		 * handlers.
+		 */
+		psf->sig_jb = &jb;
+		if (_setjmp(jb) == 0) {
+			DBG_MSG("_thread_sig_wrapper: Entering frame %d, "
+			    "stack 0x%lx\n", frame, GET_STACK_JB(jb));
 			/*
-			 * Check that a custom handler is installed
-			 * and if the signal is not blocked:
+			 * Invalidate the destination frame before calling
+			 * the signal handler.
 			 */
-			if (_thread_sigact[i - 1].sa_handler != SIG_DFL &&
-			    _thread_sigact[i - 1].sa_handler != SIG_IGN &&
-			    sigismember(&sigset, i)) {
-				if (sigismember(&_thread_run->sigpend,i))
-					/* Clear the thread pending signal: */
-					sigdelset(&_thread_run->sigpend,i);
-				else
-					/* Clear the process pending signal: */
-					sigdelset(&_process_sigpending,i);
-			}
+			psf->dst_frame = -1;
+
+			/*
+			 * Dispatch the signal via the custom signal
+			 * handler:
+			 */
+			if (psf->sig_has_args == 0)
+				(*(sigfunc))(psf->signo, NULL, NULL);
+			else if ((_thread_sigact[psf->signo - 1].sa_flags &
+			    SA_SIGINFO) != 0)
+				(*(sigfunc))(psf->signo,
+				    &_thread_sigq[psf->signo - 1].siginfo,
+				    &_thread_sigq[psf->signo - 1].uc);
 			else
-				/* Remove the signal if it can't be handled: */
-				sigdelset(&sigset, i);
+				(*(sigfunc))(psf->signo,
+				    (siginfo_t *)_thread_sigq[psf->signo - 1].siginfo.si_code,
+				    &_thread_sigq[psf->signo - 1].uc);
 		}
+		else {
+			/*
+			 * The return from _setjmp() should only be non-zero
+			 * when the signal handler wants to xxxlongjmp() or
+			 * setcontext() to a different context, or if the
+			 * thread has exited (via pthread_exit).
+			 */
+			/*
+			 * Grab a copy of the destination frame before it
+			 * gets clobbered after unwinding.
+			 */
+			dst_frame = psf->dst_frame;
+			DBG_MSG("Abnormal exit from handler for signal %d, "
+			    "frame %d\n", psf->signo, frame);
+
+			/* Has the thread exited? */
+			if ((dead = thread->flags & PTHREAD_EXITING) != 0)
+				/* When exiting, unwind to frame 0. */
+				dst_frame = 0;
+			else if ((dst_frame < 0) || (dst_frame > frame))
+				PANIC("Attempt to unwind to invalid "
+				    "signal frame");
+
+			/* Unwind to the target frame: */
+			for (i = frame; i > dst_frame; i--) {
+				DBG_MSG("Leaving frame %d, signal %d\n", i,
+				    thread->sigframes[i]->signo);
+				/* Leave the current signal frame: */
+				thread_sigframe_leave(thread, i);
 
-		/* Now deliver the signals: */
-		for (i = 1; i < NSIG; i++) {
-			if (sigismember(&sigset, i))
-				/* Deliver the signal to the running thread: */
-				_thread_sig_deliver(_thread_run, i);
+				/*
+				 * Save whatever is needed out of the state
+				 * data; as soon as the frame count is
+				 * is decremented, another signal can arrive
+				 * and corrupt this view of the state data.
+				 */
+				sig = thread->sigframes[i]->signo;
+				has_args = thread->sigframes[i]->sig_has_args;
+
+				/*
+				 * We're done with this signal frame:
+				 */
+				thread->curframe = thread->sigframes[i - 1];
+				thread->sigframe_count = i - 1;
+
+				/*
+				 * Only unblock the signal if it was a
+				 * process signal as opposed to a signal
+				 * generated by pthread_kill().
+				 */
+				if (has_args != 0)
+					_thread_sigq[sig - 1].blocked = 0;
+			}
 		}
 	}
+
+	/*
+	 * Call the kernel scheduler to schedule the next
+	 * thread.
+	 */
+	if (dead == 0) {
+		/* Restore the threads state: */
+		thread_sigframe_restore(thread, thread->sigframes[dst_frame]);
+		_thread_kern_sched_frame(dst_frame);
+	}
+	else {
+		PTHREAD_ASSERT(dst_frame == 0,
+		    "Invalid signal frame for dead thread");
+
+		/* Perform any necessary cleanup before exiting. */
+		thread_sigframe_leave(thread, 0);
+
+		/* This should never return: */
+		_thread_exit_finish();
+		PANIC("Return from _thread_exit_finish in signal wrapper");
+	}
 }
 
-/* Deliver a signal to a thread: */
-void
-_thread_sig_deliver(pthread_t pthread, int sig)
+static void
+thread_sigframe_add(pthread_t thread, int sig)
 {
-	sigset_t	mask;
-	pthread_t	pthread_saved;
-	jmp_buf		jb, *saved_sighandler_jmp_buf;
+	unsigned long	stackp = 0;
+
+	/* Get the top of the threads stack: */
+	switch (thread->curframe->ctxtype) {
+	case CTX_JB:
+	case CTX_JB_NOSIG:
+		stackp = GET_STACK_JB(thread->curframe->ctx.jb);
+		break;
+	case CTX_SJB:
+		stackp = GET_STACK_SJB(thread->curframe->ctx.sigjb);
+		break;
+	case CTX_UC:
+		stackp = GET_STACK_UC(&thread->curframe->ctx.uc);
+		break;
+	default:
+		PANIC("Invalid thread context type");
+		break;
+	}
 
 	/*
-	 * Check that a custom handler is installed
-	 * and if the signal is not blocked:
+	 * Leave a little space on the stack and round down to the
+	 * nearest aligned word:
 	 */
-	if (_thread_sigact[sig - 1].sa_handler != SIG_DFL &&
-	    _thread_sigact[sig - 1].sa_handler != SIG_IGN) {
-		/* Save the current thread: */
-		pthread_saved = _thread_run;
+	stackp -= sizeof(double);
+	stackp &= ~0x3UL;
+
+	/* Allocate room on top of the stack for a new signal frame: */
+	stackp -= sizeof(struct pthread_signal_frame);
+
+	/* Set up the new frame: */
+	thread->sigframe_count++;
+	thread->sigframes[thread->sigframe_count] =
+	   (struct pthread_signal_frame *) stackp;
+	thread->curframe = thread->sigframes[thread->sigframe_count];
+	thread->curframe->stackp = stackp;
+	thread->curframe->ctxtype = CTX_JB;
+	thread->curframe->longjmp_val = 1;
+	thread->curframe->signo = sig;
 
-		/* Save the threads signal mask: */
-		mask = pthread->sigmask;
-
-		/*
-		 * Add the current signal and signal handler
-		 * mask to the thread's current signal mask:
-		 */
-		SIGSETOR(pthread->sigmask, _thread_sigact[sig - 1].sa_mask);
-		sigaddset(&pthread->sigmask, sig);
+	/*
+	 * Set up the context:
+	 */
+	_setjmp(thread->curframe->ctx.jb);
+	SET_STACK_JB(thread->curframe->ctx.jb, stackp);
+	SET_RETURN_ADDR_JB(thread->curframe->ctx.jb, _thread_sig_wrapper);
+}
 
-		/* Current thread inside critical region? */
-		if (_thread_run->sig_defer_count > 0)
-			pthread->sig_defer_count++;
+/*
+ * Locate the signal frame from the specified stack pointer.
+ */
+int
+_thread_sigframe_find(pthread_t pthread, void *stackp)
+{
+	int	frame;
 
-		/* Increment the number of nested signals being handled. */
-		pthread->signal_nest_level++;
+	/*
+	 * Find the destination of the target frame based on the
+	 * given stack pointer.
+	 */
+	for (frame = pthread->sigframe_count; frame >= 0; frame--) {
+		if (stackp < (void *)pthread->sigframes[frame]->stackp)
+			break;
+	}
+	return (frame);
+}
+ 
+void
+thread_sigframe_leave(pthread_t thread, int frame)
+{
+	struct pthread_state_data	*psd;
 
-		/*
-		 * The jump buffer is allocated off the stack and the current
-		 * jump buffer is saved.  If the signal handler tries to
-		 * [sig|_]longjmp(), our version of [sig|_]longjmp() will copy
-		 * the user supplied jump buffer into
-		 * _thread_run->nested_jmp.[sig]jmp and _longjmp() back to here.
-		 */
-		saved_sighandler_jmp_buf = pthread->sighandler_jmp_buf;
-		pthread->sighandler_jmp_buf = &jb;
+	psd = &thread->sigframes[frame]->saved_state;
 
-		_thread_run = pthread;
+	/*
+	 * Perform any necessary cleanup for this signal frame:
+	 */
+	switch (psd->psd_state) {
+	case PS_DEAD:
+	case PS_DEADLOCK:
+	case PS_RUNNING:
+	case PS_SIGTHREAD:
+	case PS_STATE_MAX:
+	case PS_SUSPENDED:
+		break;
 
-		if (_setjmp(jb) == 0) {
-			/*
-			 * Dispatch the signal via the custom signal
-			 * handler:
-			 */
-			(*(_thread_sigact[sig - 1].sa_handler))(sig);
-		}
+	/*
+	 * Threads in the following states need to be removed
+	 * from queues.
+	 */
+	case PS_COND_WAIT:
+		_cond_wait_backout(thread);
+		if ((psd->psd_flags & PTHREAD_FLAGS_IN_WAITQ) != 0)
+			PTHREAD_WAITQ_REMOVE(thread);
+		break;
 
-		_thread_run = pthread_saved;
+	case PS_FDLR_WAIT:
+	case PS_FDLW_WAIT:
+		_fd_lock_backout(thread);
+		if ((psd->psd_flags & PTHREAD_FLAGS_IN_WAITQ) != 0)
+			PTHREAD_WAITQ_REMOVE(thread);
+		break;
 
-		pthread->sighandler_jmp_buf = saved_sighandler_jmp_buf;
+	case PS_FILE_WAIT:
+		_flockfile_backout(thread);
+		if ((psd->psd_flags & PTHREAD_FLAGS_IN_WAITQ) != 0)
+			PTHREAD_WAITQ_REMOVE(thread);
+		break;
 
-		/* Decrement the signal nest level. */
-		pthread->signal_nest_level--;
+	case PS_JOIN:
+		_join_backout(thread);
+		if ((psd->psd_flags & PTHREAD_FLAGS_IN_WAITQ) != 0)
+			PTHREAD_WAITQ_REMOVE(thread);
+		break;
 
-		/* Current thread inside critical region? */
-		if (_thread_run->sig_defer_count > 0)
-			pthread->sig_defer_count--;
+	case PS_MUTEX_WAIT:
+		_mutex_lock_backout(thread);
+		if ((psd->psd_flags & PTHREAD_FLAGS_IN_WAITQ) != 0)
+			PTHREAD_WAITQ_REMOVE(thread);
+		break;
 
-		/* Restore the threads signal mask: */
-		pthread->sigmask = mask;
+	case PS_FDR_WAIT:
+	case PS_FDW_WAIT:
+	case PS_POLL_WAIT:
+	case PS_SELECT_WAIT:
+	case PS_SIGSUSPEND:
+	case PS_SIGWAIT:
+	case PS_SLEEP_WAIT:
+	case PS_SPINBLOCK:
+	case PS_WAIT_WAIT:
+		if ((psd->psd_flags & PTHREAD_FLAGS_IN_WAITQ) != 0) {
+			PTHREAD_WAITQ_REMOVE(thread);
+			if ((psd->psd_flags & PTHREAD_FLAGS_IN_WORKQ) != 0)
+				PTHREAD_WORKQ_REMOVE(thread);
+		}
+		break;
 	}
 }
+
+static void
+thread_sigframe_restore(pthread_t thread, struct pthread_signal_frame *psf)
+{
+	thread->interrupted = psf->saved_state.psd_interrupted;
+	thread->sigmask = psf->saved_state.psd_sigmask;
+	thread->state = psf->saved_state.psd_state;
+	thread->flags = psf->saved_state.psd_flags;
+	thread->wakeup_time = psf->saved_state.psd_wakeup_time;
+	thread->data = psf->saved_state.psd_wait_data;
+}
+
+static void
+thread_sigframe_save(pthread_t thread, struct pthread_signal_frame *psf)
+{
+	psf->saved_state.psd_interrupted = thread->interrupted;
+	psf->saved_state.psd_sigmask = thread->sigmask;
+	psf->saved_state.psd_state = thread->state;
+	psf->saved_state.psd_flags = thread->flags;
+	thread->flags &= PTHREAD_FLAGS_PRIVATE | PTHREAD_FLAGS_TRACE |
+	    PTHREAD_FLAGS_IN_CONDQ | PTHREAD_FLAGS_IN_MUTEXQ |
+	    PTHREAD_FLAGS_IN_JOINQ;
+	psf->saved_state.psd_wakeup_time = thread->wakeup_time;
+	psf->saved_state.psd_wait_data = thread->data;
+}
+
 #endif