drm/i915: Set GPU freq to idle_freq initially

[dragonfly.git] / lib / libc_r / uthread / uthread_sig.c

/*
 * Copyright (c) 1995-1998 John Birrell <jb@cimlogic.com.au>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by John Birrell.
 * 4. Neither the name of the author nor the names of any co-contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD: src/lib/libc_r/uthread/uthread_sig.c,v 1.25.2.13 2002/10/22 14:44:03 fjoe Exp $
 * $DragonFly: src/lib/libc_r/uthread/uthread_sig.c,v 1.6 2007/11/25 01:28:23 swildner Exp $
 */
#include <sys/param.h>
#include <sys/types.h>
#include <sys/signalvar.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <setjmp.h>
#include <errno.h>
#include <pthread.h>
#include <string.h>
#include "pthread_private.h"

/* Prototypes: */
static void     thread_sig_add(struct pthread *pthread, int sig, int has_args);
static void     thread_sig_check_state(struct pthread *pthread, int sig);
static struct pthread *thread_sig_find(int sig);
static void     thread_sig_handle_special(int sig);
static void     thread_sigframe_add(struct pthread *thread, int sig,
                    int has_args);
static void     thread_sigframe_save(struct pthread *thread,
                    struct pthread_signal_frame *psf);
static void     thread_sig_invoke_handler(int sig, siginfo_t *info,
                    ucontext_t *ucp);

/*#define DEBUG_SIGNAL*/
#ifdef DEBUG_SIGNAL
#define DBG_MSG         stdout_debug
#else
#define DBG_MSG(x...)
#endif

#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

void
_thread_sig_handler(int sig, siginfo_t *info, ucontext_t *ucp)
{
        struct pthread  *curthread = _get_curthread();
        struct pthread  *pthread, *pthread_h;
        int             in_sched = _thread_kern_in_sched;
        char            c;

        if (ucp == NULL)
                PANIC("Thread signal handler received null context");
        DBG_MSG("Got signal %d, current thread %p\n", sig, curthread);

        /* Check if an interval timer signal: */
        if (sig == _SCHED_SIGNAL) {
                /* Update the scheduling clock: */
                gettimeofday((struct timeval *)&_sched_tod, NULL);
                _sched_ticks++;

                if (in_sched != 0) {
                        /*
                         * The scheduler is already running; ignore this
                         * signal.
                         */
                }
                /*
                 * Check if the scheduler interrupt has come when
                 * the currently running thread has deferred thread
                 * signals.
                 */
                else if (curthread->sig_defer_count > 0)
                        curthread->yield_on_sig_undefer = 1;
                else {
                        /* Schedule the next thread: */
                        _thread_kern_sched(ucp);

                        /*
                         * This point should not be reached, so abort the
                         * process:
                         */
                        PANIC("Returned to signal function from scheduler");
                }
        }
        /*
         * Check if the kernel has been interrupted while the scheduler
         * is accessing the scheduling queues or if there is a currently
         * running thread that has deferred signals.
         */
        else if ((in_sched != 0) || (curthread->sig_defer_count > 0)) {
                /* Cast the signal number to a character variable: */
                c = sig;

                /*
                 * Write the signal number to the kernel pipe so that it will
                 * be ready to read when this signal handler returns.
                 */
                if (_queue_signals != 0) {
                        __sys_extpwrite(_thread_kern_pipe[1], &c, 1, O_FBLOCKING, -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; */

                        /*
                         * 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;
                }
                /* 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.
                 *
                 * Ignore subsequent occurrences of this signal
                 * until the current signal is handled:
                 */
                _thread_sigq[sig - 1].blocked = 1;

                /* This signal will be handled; clear the pending flag: */
                _thread_sigq[sig - 1].pending = 0;

                /*
                 * Save 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));
                SIG_SET_ACTIVE();

                /* Handle special signals: */
                thread_sig_handle_special(sig);

                pthread_h = NULL;
                if ((pthread = thread_sig_find(sig)) == NULL)
                        DBG_MSG("No thread to handle signal %d\n", sig);
                else if (pthread == curthread) {
                        /*
                         * Unblock the signal and restore the process signal
                         * mask in case we don't return from the handler:
                         */
                        _thread_sigq[sig - 1].blocked = 0;
                        __sys_sigprocmask(SIG_SETMASK, &_process_sigmask, NULL);

                        /* Call the signal handler for the current thread: */
                        thread_sig_invoke_handler(sig, info, ucp);

                        /*
                         * Set the process signal mask in the context; it
                         * could have changed by the handler.
                         */
                        ucp->uc_sigmask = _process_sigmask;
 
                        /* Resume the interrupted thread: */
                        sigreturn(ucp);
                } else {
                        DBG_MSG("Got signal %d, adding frame to thread %p\n",
                            sig, pthread);

                        /* 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_h = PTHREAD_PRIOQ_FIRST();
                        DBG_MSG("Finished adding frame, head of prio list %p\n",
                            pthread_h);
                }
                SIG_SET_INACTIVE();

                /*
                 * 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 ((pthread_h != NULL) &&
                    (pthread_h->active_priority > curthread->active_priority)) {
                        /* Enter the kernel scheduler: */
                        _thread_kern_sched(ucp);
                }
        }
        else {
                SIG_SET_ACTIVE();
                thread_sig_handle_special(sig);
                SIG_SET_INACTIVE();
        }
}

static void
thread_sig_invoke_handler(int sig, siginfo_t *info, ucontext_t *ucp)
 {
        struct pthread  *curthread = _get_curthread();
        void (*sigfunc)(int, siginfo_t *, void *);
        int             saved_seqno;
        sigset_t        saved_sigmask;

        /* Invoke the signal handler without going through the scheduler:
         */
        DBG_MSG("Got signal %d, calling handler for current thread %p\n",
            sig, curthread);

        /* Save the threads signal mask: */
        saved_sigmask = curthread->sigmask;
        saved_seqno = curthread->sigmask_seqno;
 
        /* Setup the threads signal mask: */
        SIGSETOR(curthread->sigmask, _thread_sigact[sig - 1].sa_mask);
        sigaddset(&curthread->sigmask, sig);
 
        /*
         * Check that a custom handler is installed and if
         * the signal is not blocked:
         */
        sigfunc = _thread_sigact[sig - 1].sa_sigaction;
        if (((__sighandler_t *)sigfunc != SIG_DFL) &&
            ((__sighandler_t *)sigfunc != SIG_IGN)) {
                if (((_thread_sigact[sig - 1].sa_flags & SA_SIGINFO) != 0) ||
                    (info == NULL))
                        (*(sigfunc))(sig, info, ucp);
                else
                        (*(sigfunc))(sig, (siginfo_t *)(intptr_t)info->si_code, ucp);
        }
        /*
         * Only restore the signal mask if it hasn't been changed by the
         * application during invocation of the signal handler:
         */
        if (curthread->sigmask_seqno == saved_seqno)
                curthread->sigmask = saved_sigmask;
}

/*
 * Find a thread that can handle the signal.
 */
struct pthread *
thread_sig_find(int sig)
{
        struct pthread  *curthread = _get_curthread();
        int             handler_installed;
        struct pthread  *pthread, *pthread_next;
        struct pthread  *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: */
                _thread_dump_info();

                /* Unblock this signal to allow further dumps: */
                _thread_sigq[sig - 1].blocked = 0;
        }
        /* Check if an interval timer signal: */
        else if (sig == _SCHED_SIGNAL) {
                /*
                 * This shouldn't ever occur (should this panic?).
                 */
        } else {
                /*
                 * 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.  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;
                if ((curthread != &_thread_kern_thread) &&
                    !sigismember(&curthread->sigmask, sig))
                        signaled_thread = curthread;
                else
                        signaled_thread = NULL;
                if ((_thread_sigact[sig - 1].sa_handler == SIG_IGN) ||
                    (_thread_sigact[sig - 1].sa_handler == SIG_DFL))
                        handler_installed = 0;
                else
                        handler_installed = 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);

                        if ((pthread->state == PS_SIGWAIT) &&
                            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;

                                /*
                                 * POSIX doesn't doesn't specify which thread
                                 * will get the signal if there are multiple
                                 * waiters, so we give it to the first thread
                                 * we find.
                                 *
                                 * Do not attempt to deliver this signal
                                 * to other threads and do not add the signal
                                 * to the process pending set.
                                 */
                                return (NULL);
                        }
                        else if ((handler_installed != 0) &&
                            !sigismember(&pthread->sigmask, sig) &&
                            ((pthread->flags & PTHREAD_FLAGS_SUSPENDED) == 0)) {
                                if (pthread->state == PS_SIGSUSPEND) {
                                        if (suspended_thread == NULL)
                                                suspended_thread = pthread;
                                } else if (signaled_thread == NULL)
                                        signaled_thread = pthread;
                        }
                }

                /*
                 * Only perform wakeups and signal delivery if there is a
                 * custom handler installed:
                 */
                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:
                         */
                        if (suspended_thread == NULL &&
                            signaled_thread == NULL) {
                                /*
                                 * Enter a loop to look for other threads
                                 * capable of receiving the signal:
                                 */
                                TAILQ_FOREACH(pthread, &_thread_list, tle) {
                                        if (!sigismember(&pthread->sigmask,
                                            sig)) {
                                                signaled_thread = pthread;
                                                break;
                                        }
                                }
                        }

                        if (suspended_thread == NULL &&
                            signaled_thread == NULL)
                                /*
                                 * Add it to the set of signals pending
                                 * on the process:
                                 */
                                sigaddset(&_process_sigpending, sig);
                        else {
                                /*
                                 * We only deliver the signal to one thread;
                                 * give preference to the suspended thread:
                                 */
                                if (suspended_thread != NULL)
                                        pthread = suspended_thread;
                                else
                                        pthread = signaled_thread;
                                return (pthread);
                        }
                }
        }

        /* Returns nothing. */
        return (NULL);
}

void
_thread_sig_check_pending(struct pthread *pthread)
{
        sigset_t        sigset;
        int             i;

        /*
         * Check if there are pending signals for the running
         * thread or process that aren't blocked:
         */
        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)
{
        struct pthread  *pthread;
        int             i, sig;

        PTHREAD_ASSERT(_thread_kern_in_sched != 0,
            "_thread_sig_handle_pending called from outside kernel schedule");
        /*
         * Check the array of pending signals:
         */
        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
thread_sig_handle_special(int sig)
{
        struct pthread  *pthread, *pthread_next;
        int             i;

        switch (sig) {
        case 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:
                                 */
                                __sys_fcntl(i, F_SETFL,
                                    _thread_fd_getflags(i) | 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;
                        }
                }
                break;

        /*
         * 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.
 * 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_add(struct pthread *pthread, int sig, int has_args)
{
        int     restart;
        int     suppress_handler = 0;
        int     thread_is_active = 0;

        restart = _thread_sigact[sig - 1].sa_flags & SA_RESTART;

        /* Make sure this signal isn't still in the pending set: */
        sigdelset(&pthread->sigpend, sig);

        /*
         * Process according to thread state:
         */
        switch (pthread->state) {
        /*
         * States which do not change when a signal is trapped:
         */
        case PS_DEAD:
        case PS_DEADLOCK:
        case PS_STATE_MAX:
        case PS_SIGTHREAD:
                /*
                 * 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);
                else
                        /*
                         * This thread is running; avoid placing it in
                         * the run queue:
                         */
                        thread_is_active = 1;
                break;

        case PS_SUSPENDED:
                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);

                        /* Return the signal number: */
                        pthread->signo = sig;
                } else
                        /* Increment the pending signal count. */
                        sigaddset(&pthread->sigpend, sig);
                break;

        /*
         * The wait state is a special case due to the handling of
         * SIGCHLD signals.
         */
        case PS_WAIT_WAIT:
                if (sig == SIGCHLD) {
                        /* Change the state of the thread to run: */
                        PTHREAD_WAITQ_REMOVE(pthread);
                        PTHREAD_SET_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;

        /*
         * States which cannot be interrupted but still require the
         * signal handler to run:
         */
        case PS_COND_WAIT:
        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;

        case PS_JOIN:
                /*
                 * 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);
                /* Make the thread runnable: */
                PTHREAD_SET_STATE(pthread, PS_RUNNING);
                break;

        /*
         * 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:
                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);
                break;

        /*
         * States which are interruptible:
         */
        case PS_FDR_WAIT:
        case PS_FDW_WAIT:
                if (restart == 0) {
                        /*
                         * Flag the operation as interrupted and
                         * set the state to running:
                         */
                        pthread->interrupted = 1;
                        PTHREAD_SET_STATE(pthread, PS_RUNNING);
                }
                PTHREAD_WORKQ_REMOVE(pthread);
                PTHREAD_WAITQ_REMOVE(pthread);
                break;

        case PS_POLL_WAIT:
        case PS_SELECT_WAIT:
        case PS_SLEEP_WAIT:
                /*
                 * Unmasked signals always cause poll, select, and sleep
                 * to terminate early, regardless of SA_RESTART:
                 */
                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;

        case PS_SIGSUSPEND:
                PTHREAD_WAITQ_REMOVE(pthread);
                PTHREAD_SET_STATE(pthread, PS_RUNNING);
                break;
        }

        if (suppress_handler == 0) {
                /* Setup a signal frame and save the current threads state: */
                thread_sigframe_add(pthread, sig, has_args);

                /*
                 * Signals are deferred until just before the threads
                 * signal handler is invoked:
                 */
                pthread->sig_defer_count = 1;

                /* 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.  It is also possible
                 * for a signal to be sent to a suspended thread,
                 * mostly via pthread_kill().  If a thread is suspended,
                 * don't insert it into the priority queue; just set
                 * its state to suspended and it will run the signal
                 * handler when it is resumed.
                 */
                pthread->active_priority |= PTHREAD_SIGNAL_PRIORITY;
                if ((pthread->flags & PTHREAD_FLAGS_SUSPENDED) != 0)
                        PTHREAD_SET_STATE(pthread, PS_SUSPENDED);
                else if (thread_is_active == 0)
                        PTHREAD_PRIOQ_INSERT_TAIL(pthread);
        }
}

static void
thread_sig_check_state(struct pthread *pthread, int sig)
{
        /*
         * Process according to thread state:
         */
        switch (pthread->state) {
        /*
         * States which do not change when a signal is trapped:
         */
        case PS_DEAD:
        case PS_DEADLOCK:
        case PS_STATE_MAX:
        case PS_SIGTHREAD:
        case PS_RUNNING:
        case PS_SUSPENDED:
        case PS_SPINBLOCK:
        case PS_COND_WAIT:
        case PS_JOIN:
        case PS_MUTEX_WAIT:
                break;

        case PS_SIGWAIT:
                /* 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);

                        /* Return the signal number: */
                        pthread->signo = sig;
                } else
                        /* Increment the pending signal count. */
                        sigaddset(&pthread->sigpend, sig);
                break;

        /*
         * The wait state is a special case due to the handling of
         * SIGCHLD signals.
         */
        case PS_WAIT_WAIT:
                if (sig == SIGCHLD) {
                        /*
                         * Remove the thread from the wait queue and
                         * make it runnable:
                         */
                        PTHREAD_NEW_STATE(pthread, PS_RUNNING);

                        /* Return the signal number: */
                        pthread->signo = sig;
                }
                break;

        case PS_FDLR_WAIT:
        case PS_FDLW_WAIT:
        case PS_SIGSUSPEND:
        case PS_SLEEP_WAIT:
                /*
                 * Remove the thread from the wait queue and make it
                 * runnable:
                 */
                PTHREAD_NEW_STATE(pthread, PS_RUNNING);

                /* Flag the operation as interrupted: */
                pthread->interrupted = 1;
                break;

        /*
         * These states are additionally in the work queue:
         */
        case PS_FDR_WAIT:
        case PS_FDW_WAIT:
        case PS_POLL_WAIT:
        case PS_SELECT_WAIT:
                /*
                 * Remove the thread from the wait and work queues, and
                 * make it runnable:
                 */
                PTHREAD_WORKQ_REMOVE(pthread);
                PTHREAD_NEW_STATE(pthread, PS_RUNNING);

                /* Flag the operation as interrupted: */
                pthread->interrupted = 1;
                break;
        }
}

/*
 * Send a signal to a specific thread (ala pthread_kill):
 */
void
_thread_sig_send(struct pthread *pthread, int sig)
{
        struct pthread  *curthread = _get_curthread();

        /* Check for signals whose actions are SIG_DFL: */
        if (_thread_sigact[sig - 1].sa_handler == SIG_DFL) {
                /*
                 * Check to see if a temporary signal handler is
                 * installed for sigwaiters:
                 */
                if (_thread_dfl_count[sig] == 0)
                        /*
                         * Deliver the signal to the process if a handler
                         * is not installed:
                         */
                        kill(getpid(), sig);
                /*
                 * Assuming we're still running after the above kill(),
                 * make any necessary state changes to the thread:
                 */
                thread_sig_check_state(pthread, sig);
        }
        /*
         * Check that the signal is not being ignored:
         */
        else if (_thread_sigact[sig - 1].sa_handler != SIG_IGN) {
                if (pthread->state == PS_SIGWAIT &&
                    sigismember(pthread->data.sigwait, sig)) {
                        /* Change the state of the thread to run: */
                        PTHREAD_NEW_STATE(pthread, PS_RUNNING);
        
                        /* Return the signal number: */
                        pthread->signo = sig;
                } else if (sigismember(&pthread->sigmask, sig))
                        /* Add the signal to the pending set: */
                        sigaddset(&pthread->sigpend, sig);
                else if (pthread == curthread)
                        /* Call the signal handler for the current thread: */
                        thread_sig_invoke_handler(sig, NULL, NULL);
                else {
                        /* 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();
                }
        }
}

/*
 * User thread signal handler wrapper.
 *
 *   thread - current running thread
 */
void
_thread_sig_wrapper(void)
{
        struct pthread_signal_frame *psf;
        struct pthread  *thread = _get_curthread();

        /* Get the current frame and state: */
        psf = thread->curframe;
        thread->curframe = NULL;
        PTHREAD_ASSERT(psf != NULL, "Invalid signal frame in signal handler");

        /*
         * We're coming from the kernel scheduler; clear the in
         * scheduler flag:
         */
        _thread_kern_in_sched = 0;

        /* 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;
                        break;

                case PS_COND_WAIT:
                        _cond_wait_backout(thread);
                        psf->saved_state.psd_state = PS_RUNNING;
                        break;

                case PS_MUTEX_WAIT:
                        _mutex_lock_backout(thread);
                        psf->saved_state.psd_state = PS_RUNNING;
                        break;

                default:
                        break;
                }
        }

        /* Unblock the signal in case we don't return from the handler: */
        _thread_sigq[psf->signo - 1].blocked = 0;

        /*
         * Lower the priority before calling the handler in case
         * it never returns (longjmps back):
         */
        thread->active_priority &= ~PTHREAD_SIGNAL_PRIORITY;

        /*
         * Reenable interruptions without checking for the need to
         * context switch:
         */
        thread->sig_defer_count = 0;

        /*
         * Dispatch the signal via the custom signal handler:
         */
        if (psf->sig_has_args == 0)
                thread_sig_invoke_handler(psf->signo, NULL, NULL);
        else
                thread_sig_invoke_handler(psf->signo, &psf->siginfo, &psf->uc);

        /*
         * Call the kernel scheduler to safely restore the frame and
         * schedule the next thread:
         */
        _thread_kern_sched_frame(psf);
}

static void
thread_sigframe_add(struct pthread *thread, int sig, int has_args)
{
        struct pthread_signal_frame *psf = NULL;
        unsigned long   stackp;

        /* Get the top of the threads stack: */
        stackp = GET_STACK_JB(thread->ctx.jb);

        /*
         * Leave a little space on the stack and round down to the
         * nearest aligned word:
         */
        stackp -= sizeof(double);
        stackp &= ~0x3UL;

        /* Allocate room on top of the stack for a new signal frame: */
        stackp -= sizeof(struct pthread_signal_frame);

        psf = (struct pthread_signal_frame *) stackp;

        /* Save the current context in the signal frame: */
        thread_sigframe_save(thread, psf);

        /* Set handler specific information: */
        psf->sig_has_args = has_args;
        psf->signo = sig;
        if (has_args) {
                /* Copy the signal handler arguments to the signal frame: */
                memcpy(&psf->uc, &_thread_sigq[psf->signo - 1].uc,
                    sizeof(psf->uc));
                memcpy(&psf->siginfo, &_thread_sigq[psf->signo - 1].siginfo,
                    sizeof(psf->siginfo));
        }

        /* Setup the signal mask: */
        SIGSETOR(thread->sigmask, _thread_sigact[sig - 1].sa_mask);
        sigaddset(&thread->sigmask, sig);

        /* Set up the new frame: */
        thread->curframe = psf;
        thread->flags &= PTHREAD_FLAGS_PRIVATE | PTHREAD_FLAGS_TRACE |
            PTHREAD_FLAGS_IN_SYNCQ;
        /*
         * Set up the context:
         */
        stackp -= sizeof(double);
        _setjmp(thread->ctx.jb);
        SET_STACK_JB(thread->ctx.jb, stackp);
        SET_RETURN_ADDR_JB(thread->ctx.jb, _thread_sig_wrapper);
}

void
_thread_sigframe_restore(struct pthread *thread,
    struct pthread_signal_frame *psf)
{
        memcpy(&thread->ctx, &psf->ctx, sizeof(thread->ctx));
        /*
         * Only restore the signal mask if it hasn't been changed
         * by the application during invocation of the signal handler:
         */
        if (thread->sigmask_seqno == psf->saved_state.psd_sigmask_seqno)
                thread->sigmask = psf->saved_state.psd_sigmask;
        thread->curframe = psf->saved_state.psd_curframe;
        thread->wakeup_time = psf->saved_state.psd_wakeup_time;
        thread->data = psf->saved_state.psd_wait_data;
        thread->state = psf->saved_state.psd_state;
        thread->flags = psf->saved_state.psd_flags;
        thread->interrupted = psf->saved_state.psd_interrupted;
        thread->signo = psf->saved_state.psd_signo;
        thread->sig_defer_count = psf->saved_state.psd_sig_defer_count;
}

static void
thread_sigframe_save(struct pthread *thread, struct pthread_signal_frame *psf)
{
        memcpy(&psf->ctx, &thread->ctx, sizeof(thread->ctx));
        psf->saved_state.psd_sigmask = thread->sigmask;
        psf->saved_state.psd_curframe = thread->curframe;
        psf->saved_state.psd_wakeup_time = thread->wakeup_time;
        psf->saved_state.psd_wait_data = thread->data;
        psf->saved_state.psd_state = thread->state;
        psf->saved_state.psd_flags = thread->flags &
            (PTHREAD_FLAGS_PRIVATE | PTHREAD_FLAGS_TRACE);
        psf->saved_state.psd_interrupted = thread->interrupted;
        psf->saved_state.psd_sigmask_seqno = thread->sigmask_seqno;
        psf->saved_state.psd_signo = thread->signo;
        psf->saved_state.psd_sig_defer_count = thread->sig_defer_count;
}