diff options
Diffstat (limited to 'lib/libc_r/uthread/uthread_sig.c')
| -rw-r--r-- | lib/libc_r/uthread/uthread_sig.c | 1120 |
1 files changed, 1120 insertions, 0 deletions
diff --git a/lib/libc_r/uthread/uthread_sig.c b/lib/libc_r/uthread/uthread_sig.c new file mode 100644 index 0000000..a855a61 --- /dev/null +++ b/lib/libc_r/uthread/uthread_sig.c @@ -0,0 +1,1120 @@ +/* + * 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$ + */ +#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> +#ifdef _THREAD_SAFE +#include <pthread.h> +#include "pthread_private.h" + +/* Prototypes: */ +static void thread_sig_add(pthread_t pthread, int sig, int has_args); +static void thread_sig_check_state(pthread_t pthread, int sig); +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, int has_args); +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 + +#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) +{ + pthread_t pthread, pthread_h; + void *stackp; + int in_sched = 0; + char c; + + if (ucp == NULL) + PANIC("Thread signal handler received null context"); + DBG_MSG("Got signal %d, current thread %p\n", sig, _thread_run); + + if (_thread_kern_in_sched != 0) + in_sched = 1; + else { + stackp = (void *)GET_STACK_UC(ucp); + if ((stackp >= _thread_kern_sched_stack) && + (stackp <= _thread_kern_sched_stack + SCHED_STACK_SIZE)) + in_sched = 1; + } + /* 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 (_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(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) || (_thread_run->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) { + _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; */ + + /* + * 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("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_h = PTHREAD_PRIOQ_FIRST(); + DBG_MSG("Finished adding frame, head of prio list %p\n", + pthread_h); + } + else + DBG_MSG("No thread to handle signal %d\n", sig); + 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 == _thread_run) || ((pthread_h != NULL) && + (pthread_h->active_priority > _thread_run->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_savecontext(pthread_t pthread, ucontext_t *ucp) +{ + memcpy(&pthread->ctx.uc, ucp, sizeof(*ucp)); + + /* XXX - Save FP registers too? */ + FP_SAVE_UC(&pthread->ctx.uc); + + /* Mark the context saved as a ucontext: */ + pthread->ctxtype = CTX_UC; +} + +/* + * Find a thread that can handle the signal. + */ +pthread_t +thread_sig_find(int sig) +{ + 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: */ + _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 ((_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; + 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)) { + 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(pthread_t 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) +{ + pthread_t 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) +{ + pthread_t 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: + */ + _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; + } + } + 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(pthread_t pthread, int sig, int has_args) +{ + int restart; + int suppress_handler = 0; + + restart = _thread_sigact[sig - 1].sa_flags & SA_RESTART; + + /* + * 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); + 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_JOIN: + /* Only set the interrupted flag for PS_JOIN: */ + pthread->interrupted = 1; + /* FALLTHROUGH */ + 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; + + /* + * 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); + 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. + */ + pthread->active_priority |= PTHREAD_SIGNAL_PRIORITY; + if (pthread != _thread_run) + PTHREAD_PRIOQ_INSERT_TAIL(pthread); + } +} + +static void +thread_sig_check_state(pthread_t 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_FILE_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(pthread_t pthread, int sig) +{ + /* 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 (pthread == _thread_run) { + /* Add the signal to the pending set: */ + sigaddset(&pthread->sigpend, 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 if (!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); + } + } +} + +/* + * User thread signal handler wrapper. + * + * thread - current running thread + */ +void +_thread_sig_wrapper(void) +{ + void (*sigfunc)(int, siginfo_t *, void *); + struct pthread_signal_frame *psf; + pthread_t thread; + + thread = _thread_run; + + /* Get the current frame and state: */ + psf = thread->curframe; + thread->curframe = NULL; + PTHREAD_ASSERT(psf != NULL, "Invalid signal frame in signal handler"); + + /* 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_FILE_WAIT: + _flockfile_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_JOIN: + _join_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; + + /* + * 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)) { + DBG_MSG("_thread_sig_wrapper: Calling signal handler for " + "thread 0x%p\n", thread); + /* + * 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, &psf->siginfo, &psf->uc); + else + (*(sigfunc))(psf->signo, + (siginfo_t *)psf->siginfo.si_code, &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(pthread_t thread, int sig, int has_args) +{ + struct pthread_signal_frame *psf = NULL; + unsigned long stackp = 0; + + /* Get the top of the threads stack: */ + switch (thread->ctxtype) { + case CTX_JB: + case CTX_JB_NOSIG: + stackp = GET_STACK_JB(thread->ctx.jb); + break; + case CTX_SJB: + stackp = GET_STACK_SJB(thread->ctx.sigjb); + break; + case CTX_UC: + stackp = GET_STACK_UC(&thread->ctx.uc); + break; + default: + PANIC("Invalid thread context type"); + break; + } + + /* + * 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->ctxtype = CTX_JB_NOSIG; + thread->longjmp_val = 1; + 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(pthread_t thread, struct pthread_signal_frame *psf) +{ + thread->ctxtype = psf->ctxtype; + memcpy(&thread->ctx.uc, &psf->ctx.uc, sizeof(thread->ctx.uc)); + /* + * 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->longjmp_val = psf->saved_state.psd_longjmp_val; + thread->signo = psf->saved_state.psd_signo; + thread->sig_defer_count = psf->saved_state.psd_sig_defer_count; +} + +static void +thread_sigframe_save(pthread_t thread, struct pthread_signal_frame *psf) +{ + psf->ctxtype = thread->ctxtype; + memcpy(&psf->ctx.uc, &thread->ctx.uc, sizeof(thread->ctx.uc)); + 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_longjmp_val = thread->longjmp_val; + 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; +} + +#endif |
