5eb8d1f0b0
and pthread_resume_all_np(). These suspend and resume all threads except the current thread, respectively. The existing functions pthread_single_np() and pthread_multi_np(), which formerly had no effect, now exhibit the same behaviour and pthread_suspend_all_np() and pthread_resume_all_np(). These functions have been added mostly for the native java port. Don't allow the uthread kernel pipe to use the same descriptors as stdio. Mostily submitted by Oswald Buddenhagen <ossi@kde.org>. Correct some minor style nits.
1126 lines
30 KiB
C
1126 lines
30 KiB
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$
|
|
*/
|
|
#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 "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_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("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: */
|
|
__sys_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 *)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_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(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:
|
|
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. 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_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(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;
|
|
}
|
|
|