d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ef0b687ced
freebsd-nq/lib/libkse/thread/thr_sig.c
Christian Brueffer 662cac9f23 Fix some "in in" typos in comments. 
PR:		121490
Submitted by:	Anatoly Borodin <anatoly.borodin@gmail.com>
Approved by:	rwatson (mentor), jkoshy
MFC after:	3 days
2008-03-26 07:32:08 +00:00

1256 lines
36 KiB
C
Raw Blame History

/*
* 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. 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 "namespace.h"
#include <sys/param.h>
#include <sys/types.h>
#include <sys/signalvar.h>
#include <signal.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include "un-namespace.h"
#include "thr_private.h"
/* Prototypes: */
static inline void build_siginfo(siginfo_t *info, int signo);
#ifndef SYSTEM_SCOPE_ONLY
static struct pthread *thr_sig_find(struct kse *curkse, int sig,
siginfo_t *info);
#endif
static inline void thr_sigframe_restore(struct pthread *thread,
struct pthread_sigframe *psf);
static inline void thr_sigframe_save(struct pthread *thread,
struct pthread_sigframe *psf);
#define SA_KILL 0x01 /* terminates process by default */
#define SA_STOP 0x02
#define SA_CONT 0x04
static int sigproptbl[NSIG] = {
SA_KILL, /* SIGHUP */
SA_KILL, /* SIGINT */
SA_KILL, /* SIGQUIT */
SA_KILL, /* SIGILL */
SA_KILL, /* SIGTRAP */
SA_KILL, /* SIGABRT */
SA_KILL, /* SIGEMT */
SA_KILL, /* SIGFPE */
SA_KILL, /* SIGKILL */
SA_KILL, /* SIGBUS */
SA_KILL, /* SIGSEGV */
SA_KILL, /* SIGSYS */
SA_KILL, /* SIGPIPE */
SA_KILL, /* SIGALRM */
SA_KILL, /* SIGTERM */
0, /* SIGURG */
SA_STOP, /* SIGSTOP */
SA_STOP, /* SIGTSTP */
SA_CONT, /* SIGCONT */
0, /* SIGCHLD */
SA_STOP, /* SIGTTIN */
SA_STOP, /* SIGTTOU */
0, /* SIGIO */
SA_KILL, /* SIGXCPU */
SA_KILL, /* SIGXFSZ */
SA_KILL, /* SIGVTALRM */
SA_KILL, /* SIGPROF */
0, /* SIGWINCH */
0, /* SIGINFO */
SA_KILL, /* SIGUSR1 */
SA_KILL /* SIGUSR2 */
};
/* #define DEBUG_SIGNAL */
#ifdef DEBUG_SIGNAL
#define DBG_MSG stdout_debug
#else
#define DBG_MSG(x...)
#endif
/*
* Signal setup and delivery.
*
* 1) Delivering signals to threads in the same KSE.
* These signals are sent by upcall events and are set in the
* km_sigscaught field of the KSE mailbox. Since these signals
* are received while operating on the KSE stack, they can be
* delivered either by using signalcontext() to add a stack frame
* to the target thread's stack, or by adding them in the thread's
* pending set and having the thread run them down after it
* 2) Delivering signals to threads in other KSEs/KSEGs.
* 3) Delivering signals to threads in critical regions.
* 4) Delivering signals to threads after they change their signal masks.
*
* Methods of delivering signals.
*
* 1) Add a signal frame to the thread's saved context.
* 2) Add the signal to the thread structure, mark the thread as
* having signals to handle, and let the thread run them down
* after it resumes from the KSE scheduler.
*
* Problem with 1). You can't do this to a running thread or a
* thread in a critical region.
*
* Problem with 2). You can't do this to a thread that doesn't
* yield in some way (explicitly enters the scheduler). A thread
* blocked in the kernel or a CPU hungry thread will not see the
* signal without entering the scheduler.
*
* The solution is to use both 1) and 2) to deliver signals:
*
* o Thread in critical region - use 2). When the thread
* leaves the critical region it will check to see if it
* has pending signals and run them down.
*
* o Thread enters scheduler explicitly - use 2). The thread
* can check for pending signals after it returns from the
* the scheduler.
*
* o Thread is running and not current thread - use 2). When the
* thread hits a condition specified by one of the other bullets,
* the signal will be delivered.
*
* o Thread is running and is current thread (e.g., the thread
* has just changed its signal mask and now sees that it has
* pending signals) - just run down the pending signals.
*
* o Thread is swapped out due to quantum expiration - use 1)
*
* o Thread is blocked in kernel - kse_thr_wakeup() and then
* use 1)
*/
/*
* Rules for selecting threads for signals received:
*
* 1) If the signal is a sychronous signal, it is delivered to
* the generating (current thread). If the thread has the
* signal masked, it is added to the threads pending signal
* set until the thread unmasks it.
*
* 2) A thread in sigwait() where the signal is in the thread's
* waitset.
*
* 3) A thread in sigsuspend() where the signal is not in the
* thread's suspended signal mask.
*
* 4) Any thread (first found/easiest to deliver) that has the
* signal unmasked.
*/
#ifndef SYSTEM_SCOPE_ONLY
static void *
sig_daemon(void *arg __unused)
{
int i;
kse_critical_t crit;
struct timespec ts;
sigset_t set;
struct kse *curkse;
struct pthread *curthread = _get_curthread();
DBG_MSG("signal daemon started(%p)\n", curthread);
curthread->name = strdup("signal thread");
crit = _kse_critical_enter();
curkse = _get_curkse();
/*
* Daemon thread is a bound thread and we must be created with
* all signals masked
*/
#if 0
SIGFILLSET(set);
__sys_sigprocmask(SIG_SETMASK, &set, NULL);
#endif
__sys_sigpending(&set);
ts.tv_sec = 0;
ts.tv_nsec = 0;
while (1) {
KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
_thr_proc_sigpending = set;
KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
for (i = 1; i <= _SIG_MAXSIG; i++) {
if (SIGISMEMBER(set, i) != 0)
_thr_sig_dispatch(curkse, i,
NULL /* no siginfo */);
}
ts.tv_sec = 30;
ts.tv_nsec = 0;
curkse->k_kcb->kcb_kmbx.km_flags =
KMF_NOUPCALL | KMF_NOCOMPLETED | KMF_WAITSIGEVENT;
kse_release(&ts);
curkse->k_kcb->kcb_kmbx.km_flags = 0;
set = curkse->k_kcb->kcb_kmbx.km_sigscaught;
}
return (0);
}
/* Utility function to create signal daemon thread */
int
_thr_start_sig_daemon(void)
{
pthread_attr_t attr;
sigset_t sigset, oldset;
SIGFILLSET(sigset);
_pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
_pthread_attr_init(&attr);
_pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
attr->flags |= THR_SIGNAL_THREAD;
/* sigmask will be inherited */
if (_pthread_create(&_thr_sig_daemon, &attr, sig_daemon, NULL))
PANIC("can not create signal daemon thread!\n");
_pthread_attr_destroy(&attr);
_pthread_sigmask(SIG_SETMASK, &oldset, NULL);
return (0);
}
/*
* This signal handler only delivers asynchronous signals.
* This must be called with upcalls disabled and without
* holding any locks.
*/
void
_thr_sig_dispatch(struct kse *curkse, int sig, siginfo_t *info)
{
struct kse_mailbox *kmbx;
struct pthread *thread;
DBG_MSG(">>> _thr_sig_dispatch(%d)\n", sig);
/* Check if the signal requires a dump of thread information: */
if (_thr_dump_enabled() && (sig == SIGINFO)) {
/* Dump thread information to file: */
_thread_dump_info();
}
while ((thread = thr_sig_find(curkse, sig, info)) != NULL) {
/*
* Setup the target thread to receive the signal:
*/
DBG_MSG("Got signal %d, selecting thread %p\n", sig, thread);
KSE_SCHED_LOCK(curkse, thread->kseg);
if ((thread->state == PS_DEAD) ||
(thread->state == PS_DEADLOCK) ||
THR_IS_EXITING(thread) || THR_IS_SUSPENDED(thread)) {
KSE_SCHED_UNLOCK(curkse, thread->kseg);
_thr_ref_delete(NULL, thread);
} else if (SIGISMEMBER(thread->sigmask, sig)) {
KSE_SCHED_UNLOCK(curkse, thread->kseg);
_thr_ref_delete(NULL, thread);
} else {
kmbx = _thr_sig_add(thread, sig, info);
KSE_SCHED_UNLOCK(curkse, thread->kseg);
_thr_ref_delete(NULL, thread);
if (kmbx != NULL)
kse_wakeup(kmbx);
break;
}
}
DBG_MSG("<<< _thr_sig_dispatch\n");
}
#endif /* ! SYSTEM_SCOPE_ONLY */
static __inline int
sigprop(int sig)
{
if (sig > 0 && sig < NSIG)
return (sigproptbl[_SIG_IDX(sig)]);
return (0);
}
typedef void (*ohandler)(int sig, int code,
struct sigcontext *scp, char *addr, __sighandler_t *catcher);
void
_thr_sig_handler(int sig, siginfo_t *info, void *ucp_arg)
{
struct pthread_sigframe psf;
__siginfohandler_t *sigfunc;
struct pthread *curthread;
struct kse *curkse;
ucontext_t *ucp;
struct sigaction act;
int sa_flags, err_save;
err_save = errno;
ucp = (ucontext_t *)ucp_arg;
DBG_MSG(">>> _thr_sig_handler(%d)\n", sig);
curthread = _get_curthread();
if (curthread == NULL)
PANIC("No current thread.\n");
if (!(curthread->attr.flags & PTHREAD_SCOPE_SYSTEM))
PANIC("Thread is not system scope.\n");
if (curthread->flags & THR_FLAGS_EXITING) {
errno = err_save;
return;
}
curkse = _get_curkse();
/*
* If thread is in critical region or if thread is on
* the way of state transition, then latch signal into buffer.
*/
if (_kse_in_critical() || THR_IN_CRITICAL(curthread) ||
curthread->state != PS_RUNNING) {
DBG_MSG(">>> _thr_sig_handler(%d) in critical\n", sig);
curthread->siginfo[sig-1] = *info;
curthread->check_pending = 1;
curkse->k_sigseqno++;
SIGADDSET(curthread->sigpend, sig);
/*
* If the kse is on the way to idle itself, but
* we have signal ready, we should prevent it
* to sleep, kernel will latch the wakeup request,
* so kse_release will return from kernel immediately.
*/
if (KSE_IS_IDLE(curkse))
kse_wakeup(&curkse->k_kcb->kcb_kmbx);
errno = err_save;
return;
}
/* Check if the signal requires a dump of thread information: */
if (_thr_dump_enabled() && (sig == SIGINFO)) {
/* Dump thread information to file: */
_thread_dump_info();
}
/* Check the threads previous state: */
curthread->critical_count++;
if (curthread->sigbackout != NULL)
curthread->sigbackout((void *)curthread);
curthread->critical_count--;
thr_sigframe_save(curthread, &psf);
THR_ASSERT(!(curthread->sigbackout), "sigbackout was not cleared.");
_kse_critical_enter();
/* Get a fresh copy of signal mask */
__sys_sigprocmask(SIG_BLOCK, NULL, &curthread->sigmask);
KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
sigfunc = _thread_sigact[sig - 1].sa_sigaction;
sa_flags = _thread_sigact[sig - 1].sa_flags;
if (sa_flags & SA_RESETHAND) {
act.sa_handler = SIG_DFL;
act.sa_flags = SA_RESTART;
SIGEMPTYSET(act.sa_mask);
__sys_sigaction(sig, &act, NULL);
__sys_sigaction(sig, NULL, &_thread_sigact[sig - 1]);
}
KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
_kse_critical_leave(&curthread->tcb->tcb_tmbx);
/* Now invoke real handler */
if (((__sighandler_t *)sigfunc != SIG_DFL) &&
((__sighandler_t *)sigfunc != SIG_IGN) &&
(sigfunc != (__siginfohandler_t *)_thr_sig_handler)) {
if ((sa_flags & SA_SIGINFO) != 0 || info == NULL)
(*(sigfunc))(sig, info, ucp);
else {
((ohandler)(*sigfunc))(
sig, info->si_code, (struct sigcontext *)ucp,
info->si_addr, (__sighandler_t *)sigfunc);
}
} else {
if ((__sighandler_t *)sigfunc == SIG_DFL) {
if (sigprop(sig) & SA_KILL) {
if (_kse_isthreaded())
kse_thr_interrupt(NULL,
KSE_INTR_SIGEXIT, sig);
else
kill(getpid(), sig);
}
#ifdef NOTYET
else if (sigprop(sig) & SA_STOP)
kse_thr_interrupt(NULL, KSE_INTR_JOBSTOP, sig);
#endif
}
}
_kse_critical_enter();
curthread->sigmask = ucp->uc_sigmask;
SIG_CANTMASK(curthread->sigmask);
_kse_critical_leave(&curthread->tcb->tcb_tmbx);
thr_sigframe_restore(curthread, &psf);
DBG_MSG("<<< _thr_sig_handler(%d)\n", sig);
errno = err_save;
}
struct sighandle_info {
__siginfohandler_t *sigfunc;
int sa_flags;
int sig;
siginfo_t *info;
ucontext_t *ucp;
};
static void handle_signal(struct pthread *curthread,
struct sighandle_info *shi);
static void handle_signal_altstack(struct pthread *curthread,
struct sighandle_info *shi);
/* Must be called with signal lock and schedule lock held in order */
static void
thr_sig_invoke_handler(struct pthread *curthread, int sig, siginfo_t *info,
ucontext_t *ucp)
{
__siginfohandler_t *sigfunc;
sigset_t sigmask;
int sa_flags;
int onstack;
struct sigaction act;
struct kse *curkse;
struct sighandle_info shi;
/*
* Invoke the signal handler without going through the scheduler:
*/
DBG_MSG("Got signal %d, calling handler for current thread %p\n",
sig, curthread);
if (!_kse_in_critical())
PANIC("thr_sig_invoke_handler without in critical\n");
curkse = curthread->kse;
/*
* Check that a custom handler is installed and if
* the signal is not blocked:
*/
sigfunc = _thread_sigact[sig - 1].sa_sigaction;
sa_flags = _thread_sigact[sig - 1].sa_flags;
sigmask = curthread->sigmask;
SIGSETOR(curthread->sigmask, _thread_sigact[sig - 1].sa_mask);
if (!(sa_flags & (SA_NODEFER | SA_RESETHAND)))
SIGADDSET(curthread->sigmask, sig);
if ((sig != SIGILL) && (sa_flags & SA_RESETHAND)) {
act.sa_handler = SIG_DFL;
act.sa_flags = SA_RESTART;
SIGEMPTYSET(act.sa_mask);
__sys_sigaction(sig, &act, NULL);
__sys_sigaction(sig, NULL, &_thread_sigact[sig - 1]);
}
KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
KSE_SCHED_UNLOCK(curkse, curkse->k_kseg);
/*
* We are processing buffered signals, synchronize working
* signal mask into kernel.
*/
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
__sys_sigprocmask(SIG_SETMASK, &curthread->sigmask, NULL);
onstack = _thr_sigonstack(&sigfunc);
ucp->uc_stack = curthread->sigstk;
ucp->uc_stack.ss_flags = (curthread->sigstk.ss_flags & SS_DISABLE)
? SS_DISABLE : ((onstack) ? SS_ONSTACK : 0);
if (curthread->oldsigmask) {
ucp->uc_sigmask = *(curthread->oldsigmask);
curthread->oldsigmask = NULL;
} else
ucp->uc_sigmask = sigmask;
shi.sigfunc = sigfunc;
shi.sig = sig;
shi.sa_flags = sa_flags;
shi.info = info;
shi.ucp = ucp;
if ((curthread->sigstk.ss_flags & SS_DISABLE) == 0) {
/* Deliver signal on alternative stack */
if (sa_flags & SA_ONSTACK && !onstack)
handle_signal_altstack(curthread, &shi);
else
handle_signal(curthread, &shi);
} else {
handle_signal(curthread, &shi);
}
_kse_critical_enter();
/* Don't trust after critical leave/enter */
curkse = curthread->kse;
/*
* Restore the thread's signal mask.
*/
curthread->sigmask = ucp->uc_sigmask;
SIG_CANTMASK(curthread->sigmask);
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
__sys_sigprocmask(SIG_SETMASK, &ucp->uc_sigmask, NULL);
KSE_SCHED_LOCK(curkse, curkse->k_kseg);
KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
DBG_MSG("Got signal %d, handler returned %p\n", sig, curthread);
}
static void
handle_signal(struct pthread *curthread, struct sighandle_info *shi)
{
_kse_critical_leave(&curthread->tcb->tcb_tmbx);
/* Check if the signal requires a dump of thread information: */
if (_thr_dump_enabled() && (shi->sig == SIGINFO)) {
/* Dump thread information to file: */
_thread_dump_info();
}
if (((__sighandler_t *)shi->sigfunc != SIG_DFL) &&
((__sighandler_t *)shi->sigfunc != SIG_IGN)) {
if ((shi->sa_flags & SA_SIGINFO) != 0 || shi->info == NULL)
(*(shi->sigfunc))(shi->sig, shi->info, shi->ucp);
else {
((ohandler)(*shi->sigfunc))(
shi->sig, shi->info->si_code,
(struct sigcontext *)shi->ucp,
shi->info->si_addr,
(__sighandler_t *)shi->sigfunc);
}
} else {
if ((__sighandler_t *)shi->sigfunc == SIG_DFL) {
if (sigprop(shi->sig) & SA_KILL) {
if (_kse_isthreaded())
kse_thr_interrupt(NULL,
KSE_INTR_SIGEXIT, shi->sig);
else
kill(getpid(), shi->sig);
}
#ifdef NOTYET
else if (sigprop(shi->sig) & SA_STOP)
kse_thr_interrupt(NULL, KSE_INTR_JOBSTOP,
shi->sig);
#endif
}
}
}
static void
handle_signal_wrapper(struct pthread *curthread, ucontext_t *ret_uc,
struct sighandle_info *shi)
{
shi->ucp->uc_stack.ss_flags = SS_ONSTACK;
handle_signal(curthread, shi);
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
setcontext(ret_uc);
else {
/* Work around for ia64, THR_SETCONTEXT does not work */
_kse_critical_enter();
curthread->tcb->tcb_tmbx.tm_context = *ret_uc;
_thread_switch(curthread->kse->k_kcb, curthread->tcb, 1);
/* THR_SETCONTEXT */
}
}
/*
* Jump to stack set by sigaltstack before invoking signal handler
*/
static void
handle_signal_altstack(struct pthread *curthread, struct sighandle_info *shi)
{
volatile int once;
ucontext_t uc1, *uc2;
THR_ASSERT(_kse_in_critical(), "Not in critical");
once = 0;
THR_GETCONTEXT(&uc1);
if (once == 0) {
once = 1;
/* XXX
* We are still in critical region, it is safe to operate thread
* context
*/
uc2 = &curthread->tcb->tcb_tmbx.tm_context;
uc2->uc_stack = curthread->sigstk;
makecontext(uc2, (void (*)(void))handle_signal_wrapper,
3, curthread, &uc1, shi);
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
setcontext(uc2);
else {
_thread_switch(curthread->kse->k_kcb, curthread->tcb, 1);
/* THR_SETCONTEXT(uc2); */
}
}
}
int
_thr_getprocsig(int sig, siginfo_t *siginfo)
{
kse_critical_t crit;
struct kse *curkse;
int ret;
DBG_MSG(">>> _thr_getprocsig\n");
crit = _kse_critical_enter();
curkse = _get_curkse();
KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
ret = _thr_getprocsig_unlocked(sig, siginfo);
KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
_kse_critical_leave(crit);
DBG_MSG("<<< _thr_getprocsig\n");
return (ret);
}
int
_thr_getprocsig_unlocked(int sig, siginfo_t *siginfo)
{
sigset_t sigset;
struct timespec ts;
/* try to retrieve signal from kernel */
SIGEMPTYSET(sigset);
SIGADDSET(sigset, sig);
ts.tv_sec = 0;
ts.tv_nsec = 0;
SIGDELSET(_thr_proc_sigpending, sig);
if (__sys_sigtimedwait(&sigset, siginfo, &ts) > 0)
return (sig);
return (0);
}
#ifndef SYSTEM_SCOPE_ONLY
/*
* Find a thread that can handle the signal. This must be called
* with upcalls disabled.
*/
struct pthread *
thr_sig_find(struct kse *curkse, int sig, siginfo_t *info __unused)
{
struct kse_mailbox *kmbx = NULL;
struct pthread *pthread;
struct pthread *suspended_thread, *signaled_thread;
__siginfohandler_t *sigfunc;
siginfo_t si;
DBG_MSG("Looking for thread to handle signal %d\n", sig);
/*
* 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 a sigsuspend. Third
* preference will be the current thread. If none of the
* above, then the signal is delivered to the first thread
* that is found. Note that if a custom handler is not
* installed, the signal only affects threads in sigwait.
*/
suspended_thread = NULL;
signaled_thread = NULL;
KSE_LOCK_ACQUIRE(curkse, &_thread_list_lock);
TAILQ_FOREACH(pthread, &_thread_list, tle) {
if (pthread == _thr_sig_daemon)
continue;
/* Signal delivering to bound thread is done by kernel */
if (pthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
continue;
/* Take the scheduling lock. */
KSE_SCHED_LOCK(curkse, pthread->kseg);
if ((pthread->state == PS_DEAD) ||
(pthread->state == PS_DEADLOCK) ||
THR_IS_EXITING(pthread) ||
THR_IS_SUSPENDED(pthread)) {
; /* Skip this thread. */
} else if (pthread->state == PS_SIGWAIT &&
SIGISMEMBER(*(pthread->data.sigwait->waitset), sig)) {
/*
* retrieve signal from kernel, if it is job control
* signal, and sigaction is SIG_DFL, then we will
* be stopped in kernel, we hold lock here, but that
* does not matter, because that's job control, and
* whole process should be stopped.
*/
if (_thr_getprocsig(sig, &si)) {
DBG_MSG("Waking thread %p in sigwait"
" with signal %d\n", pthread, sig);
/* where to put siginfo ? */
*(pthread->data.sigwait->siginfo) = si;
kmbx = _thr_setrunnable_unlocked(pthread);
}
KSE_SCHED_UNLOCK(curkse, pthread->kseg);
/*
* 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.
*/
KSE_LOCK_RELEASE(curkse, &_thread_list_lock);
if (kmbx != NULL)
kse_wakeup(kmbx);
if (suspended_thread != NULL)
_thr_ref_delete(NULL, suspended_thread);
if (signaled_thread != NULL)
_thr_ref_delete(NULL, signaled_thread);
return (NULL);
} else if (!SIGISMEMBER(pthread->sigmask, sig)) {
/*
* If debugger is running, we don't quick exit,
* and give it a chance to check the signal.
*/
if (_libkse_debug == 0) {
sigfunc = _thread_sigact[sig - 1].sa_sigaction;
if ((__sighandler_t *)sigfunc == SIG_DFL) {
if (sigprop(sig) & SA_KILL) {
kse_thr_interrupt(NULL,
KSE_INTR_SIGEXIT, sig);
/* Never reach */
}
}
}
if (pthread->state == PS_SIGSUSPEND) {
if (suspended_thread == NULL) {
suspended_thread = pthread;
suspended_thread->refcount++;
}
} else if (signaled_thread == NULL) {
signaled_thread = pthread;
signaled_thread->refcount++;
}
}
KSE_SCHED_UNLOCK(curkse, pthread->kseg);
}
KSE_LOCK_RELEASE(curkse, &_thread_list_lock);
if (suspended_thread != NULL) {
pthread = suspended_thread;
if (signaled_thread)
_thr_ref_delete(NULL, signaled_thread);
} else if (signaled_thread) {
pthread = signaled_thread;
} else {
pthread = NULL;
}
return (pthread);
}
#endif /* ! SYSTEM_SCOPE_ONLY */
static inline void
build_siginfo(siginfo_t *info, int signo)
{
bzero(info, sizeof(*info));
info->si_signo = signo;
info->si_pid = _thr_pid;
}
/*
* This is called by a thread when it has pending signals to deliver.
* It should only be called from the context of the thread.
*/
void
_thr_sig_rundown(struct pthread *curthread, ucontext_t *ucp)
{
struct pthread_sigframe psf;
siginfo_t siginfo;
int i, err_save;
kse_critical_t crit;
struct kse *curkse;
sigset_t sigmask;
err_save = errno;
DBG_MSG(">>> thr_sig_rundown (%p)\n", curthread);
/* Check the threads previous state: */
curthread->critical_count++;
if (curthread->sigbackout != NULL)
curthread->sigbackout((void *)curthread);
curthread->critical_count--;
THR_ASSERT(!(curthread->sigbackout), "sigbackout was not cleared.");
THR_ASSERT((curthread->state == PS_RUNNING), "state is not PS_RUNNING");
thr_sigframe_save(curthread, &psf);
/*
* Lower the priority before calling the handler in case
* it never returns (longjmps back):
*/
crit = _kse_critical_enter();
curkse = curthread->kse;
KSE_SCHED_LOCK(curkse, curkse->k_kseg);
KSE_LOCK_ACQUIRE(curkse, &_thread_signal_lock);
curthread->active_priority &= ~THR_SIGNAL_PRIORITY;
SIGFILLSET(sigmask);
while (1) {
/*
* For bound thread, we mask all signals and get a fresh
* copy of signal mask from kernel
*/
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM) {
__sys_sigprocmask(SIG_SETMASK, &sigmask,
&curthread->sigmask);
}
for (i = 1; i <= _SIG_MAXSIG; i++) {
if (SIGISMEMBER(curthread->sigmask, i))
continue;
if (SIGISMEMBER(curthread->sigpend, i)) {
SIGDELSET(curthread->sigpend, i);
siginfo = curthread->siginfo[i-1];
break;
}
if (!(curthread->attr.flags & PTHREAD_SCOPE_SYSTEM)
&& SIGISMEMBER(_thr_proc_sigpending, i)) {
if (_thr_getprocsig_unlocked(i, &siginfo))
break;
}
}
if (i <= _SIG_MAXSIG)
thr_sig_invoke_handler(curthread, i, &siginfo, ucp);
else {
if (curthread->attr.flags & PTHREAD_SCOPE_SYSTEM) {
__sys_sigprocmask(SIG_SETMASK,
&curthread->sigmask, NULL);
}
break;
}
}
/* Don't trust after signal handling */
curkse = curthread->kse;
KSE_LOCK_RELEASE(curkse, &_thread_signal_lock);
KSE_SCHED_UNLOCK(curkse, curkse->k_kseg);
_kse_critical_leave(&curthread->tcb->tcb_tmbx);
/* repost masked signal to kernel, it hardly happens in real world */
if ((curthread->attr.flags & PTHREAD_SCOPE_SYSTEM) &&
!SIGISEMPTY(curthread->sigpend)) { /* dirty read */
__sys_sigprocmask(SIG_SETMASK, &sigmask, &curthread->sigmask);
for (i = 1; i <= _SIG_MAXSIG; ++i) {
if (SIGISMEMBER(curthread->sigpend, i)) {
SIGDELSET(curthread->sigpend, i);
if (!_kse_isthreaded())
kill(getpid(), i);
else
kse_thr_interrupt(
&curthread->tcb->tcb_tmbx,
KSE_INTR_SENDSIG,
i);
}
}
__sys_sigprocmask(SIG_SETMASK, &curthread->sigmask, NULL);
}
DBG_MSG("<<< thr_sig_rundown (%p)\n", curthread);
thr_sigframe_restore(curthread, &psf);
errno = err_save;
}
/*
* This checks pending signals for the current thread. It should be
* called whenever a thread changes its signal mask. Note that this
* is called from a thread (using its stack).
*
* XXX - We might want to just check to see if there are pending
* signals for the thread here, but enter the UTS scheduler
* to actually install the signal handler(s).
*/
void
_thr_sig_check_pending(struct pthread *curthread)
{
ucontext_t uc;
volatile int once;
int errsave;
/*
* If the thread is in critical region, delay processing signals.
* If the thread state is not PS_RUNNING, it might be switching
* into UTS and but a THR_LOCK_RELEASE saw check_pending, and it
* goes here, in the case we delay processing signals, lets UTS
* process complicated things, normally UTS will call _thr_sig_add
* to resume the thread, so we needn't repeat doing it here.
*/
if (THR_IN_CRITICAL(curthread) || curthread->state != PS_RUNNING)
return;
errsave = errno;
once = 0;
THR_GETCONTEXT(&uc);
if (once == 0) {
once = 1;
curthread->check_pending = 0;
_thr_sig_rundown(curthread, &uc);
}
errno = errsave;
}
/*
* 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.
*
* This must be called with the thread's scheduling lock held.
*/
struct kse_mailbox *
_thr_sig_add(struct pthread *pthread, int sig, siginfo_t *info)
{
siginfo_t siginfo;
struct kse *curkse;
struct kse_mailbox *kmbx = NULL;
struct pthread *curthread = _get_curthread();
int restart;
int suppress_handler = 0;
int fromproc = 0;
__sighandler_t *sigfunc;
DBG_MSG(">>> _thr_sig_add %p (%d)\n", pthread, sig);
curkse = _get_curkse();
restart = _thread_sigact[sig - 1].sa_flags & SA_RESTART;
sigfunc = _thread_sigact[sig - 1].sa_handler;
fromproc = (curthread == _thr_sig_daemon);
if (pthread->state == PS_DEAD || pthread->state == PS_DEADLOCK ||
pthread->state == PS_STATE_MAX)
return (NULL); /* return false */
if ((pthread->attr.flags & PTHREAD_SCOPE_SYSTEM) &&
(curthread != pthread)) {
PANIC("Please use _thr_send_sig for bound thread");
return (NULL);
}
if (pthread->state != PS_SIGWAIT &&
SIGISMEMBER(pthread->sigmask, sig)) {
/* signal is masked, just add signal to thread. */
if (!fromproc) {
SIGADDSET(pthread->sigpend, sig);
if (info == NULL)
build_siginfo(&pthread->siginfo[sig-1], sig);
else if (info != &pthread->siginfo[sig-1])
memcpy(&pthread->siginfo[sig-1], info,
sizeof(*info));
} else {
if (!_thr_getprocsig(sig, &pthread->siginfo[sig-1]))
return (NULL);
SIGADDSET(pthread->sigpend, sig);
}
}
else {
/* if process signal not exists, just return */
if (fromproc) {
if (!_thr_getprocsig(sig, &siginfo))
return (NULL);
info = &siginfo;
}
if (pthread->state != PS_SIGWAIT && sigfunc == SIG_DFL &&
(sigprop(sig) & SA_KILL)) {
kse_thr_interrupt(NULL, KSE_INTR_SIGEXIT, sig);
/* Never reach */
}
/*
* Process according to thread state:
*/
switch (pthread->state) {
case PS_DEAD:
case PS_DEADLOCK:
case PS_STATE_MAX:
return (NULL); /* XXX return false */
case PS_LOCKWAIT:
case PS_SUSPENDED:
/*
* You can't call a signal handler for threads in these
* states.
*/
suppress_handler = 1;
break;
case PS_RUNNING:
if ((pthread->flags & THR_FLAGS_IN_RUNQ)) {
THR_RUNQ_REMOVE(pthread);
pthread->active_priority |= THR_SIGNAL_PRIORITY;
THR_RUNQ_INSERT_TAIL(pthread);
} else {
/* Possible not in RUNQ and has curframe ? */
pthread->active_priority |= THR_SIGNAL_PRIORITY;
}
break;
/*
* States which cannot be interrupted but still require the
* signal handler to run:
*/
case PS_COND_WAIT:
case PS_MUTEX_WAIT:
break;
case PS_SLEEP_WAIT:
/*
* Unmasked signals always cause sleep to terminate
* early regardless of SA_RESTART:
*/
pthread->interrupted = 1;
break;
case PS_JOIN:
break;
case PS_SIGSUSPEND:
pthread->interrupted = 1;
break;
case PS_SIGWAIT:
if (info == NULL)
build_siginfo(&pthread->siginfo[sig-1], sig);
else if (info != &pthread->siginfo[sig-1])
memcpy(&pthread->siginfo[sig-1], info,
sizeof(*info));
/*
* The signal handler is not called for threads in
* SIGWAIT.
*/
suppress_handler = 1;
/* Wake up the thread if the signal is not blocked. */
if (SIGISMEMBER(*(pthread->data.sigwait->waitset), sig)) {
/* Return the signal number: */
*(pthread->data.sigwait->siginfo) = pthread->siginfo[sig-1];
/* Make the thread runnable: */
kmbx = _thr_setrunnable_unlocked(pthread);
} else {
/* Increment the pending signal count. */
SIGADDSET(pthread->sigpend, sig);
if (!SIGISMEMBER(pthread->sigmask, sig)) {
if (sigfunc == SIG_DFL &&
sigprop(sig) & SA_KILL) {
kse_thr_interrupt(NULL,
KSE_INTR_SIGEXIT,
sig);
/* Never reach */
}
pthread->check_pending = 1;
pthread->interrupted = 1;
kmbx = _thr_setrunnable_unlocked(pthread);
}
}
return (kmbx);
}
SIGADDSET(pthread->sigpend, sig);
if (info == NULL)
build_siginfo(&pthread->siginfo[sig-1], sig);
else if (info != &pthread->siginfo[sig-1])
memcpy(&pthread->siginfo[sig-1], info, sizeof(*info));
pthread->check_pending = 1;
if (!(pthread->attr.flags & PTHREAD_SCOPE_SYSTEM) &&
(pthread->blocked != 0) && !THR_IN_CRITICAL(pthread))
kse_thr_interrupt(&pthread->tcb->tcb_tmbx,
restart ? KSE_INTR_RESTART : KSE_INTR_INTERRUPT, 0);
if (suppress_handler == 0) {
/*
* Setup a signal frame and save the current threads
* state:
*/
if (pthread->state != PS_RUNNING) {
if (pthread->flags & THR_FLAGS_IN_RUNQ)
THR_RUNQ_REMOVE(pthread);
pthread->active_priority |= THR_SIGNAL_PRIORITY;
kmbx = _thr_setrunnable_unlocked(pthread);
}
}
}
return (kmbx);
}
/*
* Send a signal to a specific thread (ala pthread_kill):
*/
void
_thr_sig_send(struct pthread *pthread, int sig)
{
struct pthread *curthread = _get_curthread();
struct kse_mailbox *kmbx;
if (pthread->attr.flags & PTHREAD_SCOPE_SYSTEM) {
kse_thr_interrupt(&pthread->tcb->tcb_tmbx, KSE_INTR_SENDSIG, sig);
return;
}
/* Lock the scheduling queue of the target thread. */
THR_SCHED_LOCK(curthread, pthread);
if (_thread_sigact[sig - 1].sa_handler != SIG_IGN) {
kmbx = _thr_sig_add(pthread, sig, NULL);
/* Add a preemption point. */
if (kmbx == NULL && (curthread->kseg == pthread->kseg) &&
(pthread->active_priority > curthread->active_priority))
curthread->critical_yield = 1;
THR_SCHED_UNLOCK(curthread, pthread);
if (kmbx != NULL)
kse_wakeup(kmbx);
/* XXX
* If thread sent signal to itself, check signals now.
* It is not really needed, _kse_critical_leave should
* have already checked signals.
*/
if (pthread == curthread && curthread->check_pending)
_thr_sig_check_pending(curthread);
} else {
THR_SCHED_UNLOCK(curthread, pthread);
}
}
static inline void
thr_sigframe_restore(struct pthread *curthread, struct pthread_sigframe *psf)
{
kse_critical_t crit;
struct kse *curkse;
THR_THREAD_LOCK(curthread, curthread);
curthread->cancelflags = psf->psf_cancelflags;
crit = _kse_critical_enter();
curkse = curthread->kse;
KSE_SCHED_LOCK(curkse, curthread->kseg);
curthread->flags = psf->psf_flags;
curthread->interrupted = psf->psf_interrupted;
curthread->timeout = psf->psf_timeout;
curthread->data = psf->psf_wait_data;
curthread->wakeup_time = psf->psf_wakeup_time;
curthread->continuation = psf->psf_continuation;
KSE_SCHED_UNLOCK(curkse, curthread->kseg);
_kse_critical_leave(crit);
THR_THREAD_UNLOCK(curthread, curthread);
}
static inline void
thr_sigframe_save(struct pthread *curthread, struct pthread_sigframe *psf)
{
kse_critical_t crit;
struct kse *curkse;
THR_THREAD_LOCK(curthread, curthread);
psf->psf_cancelflags = curthread->cancelflags;
crit = _kse_critical_enter();
curkse = curthread->kse;
KSE_SCHED_LOCK(curkse, curthread->kseg);
/* This has to initialize all members of the sigframe. */
psf->psf_flags = (curthread->flags & (THR_FLAGS_PRIVATE | THR_FLAGS_EXITING));
psf->psf_interrupted = curthread->interrupted;
psf->psf_timeout = curthread->timeout;
psf->psf_wait_data = curthread->data;
psf->psf_wakeup_time = curthread->wakeup_time;
psf->psf_continuation = curthread->continuation;
KSE_SCHED_UNLOCK(curkse, curthread->kseg);
_kse_critical_leave(crit);
THR_THREAD_UNLOCK(curthread, curthread);
}
void
_thr_signal_init(void)
{
struct sigaction act;
__siginfohandler_t *sigfunc;
int i;
sigset_t sigset;
SIGFILLSET(sigset);
__sys_sigprocmask(SIG_SETMASK, &sigset, &_thr_initial->sigmask);
/* Enter a loop to get the existing signal status: */
for (i = 1; i <= _SIG_MAXSIG; i++) {
/* Get the signal handler details: */
if (__sys_sigaction(i, NULL, &_thread_sigact[i - 1]) != 0) {
/*
* Abort this process if signal
* initialisation fails:
*/
PANIC("Cannot read signal handler info");
}
/* Intall wrapper if handler was set */
sigfunc = _thread_sigact[i - 1].sa_sigaction;
if (((__sighandler_t *)sigfunc) != SIG_DFL &&
((__sighandler_t *)sigfunc) != SIG_IGN) {
act = _thread_sigact[i - 1];
act.sa_flags |= SA_SIGINFO;
act.sa_sigaction =
(__siginfohandler_t *)_thr_sig_handler;
__sys_sigaction(i, &act, NULL);
}
}
if (_thr_dump_enabled()) {
/*
* Install the signal handler for SIGINFO. It isn't
* really needed, but it is nice to have for debugging
* purposes.
*/
_thread_sigact[SIGINFO - 1].sa_flags = SA_SIGINFO | SA_RESTART;
SIGEMPTYSET(act.sa_mask);
act.sa_flags = SA_SIGINFO | SA_RESTART;
act.sa_sigaction = (__siginfohandler_t *)&_thr_sig_handler;
if (__sys_sigaction(SIGINFO, &act, NULL) != 0) {
__sys_sigprocmask(SIG_SETMASK, &_thr_initial->sigmask,
NULL);
/*
* Abort this process if signal initialisation fails:
*/
PANIC("Cannot initialize signal handler");
}
}
__sys_sigprocmask(SIG_SETMASK, &_thr_initial->sigmask, NULL);
__sys_sigaltstack(NULL, &_thr_initial->sigstk);
}
void
_thr_signal_deinit(void)
{
int i;
struct pthread *curthread = _get_curthread();
/* Clear process pending signals. */
sigemptyset(&_thr_proc_sigpending);
/* Enter a loop to get the existing signal status: */
for (i = 1; i <= _SIG_MAXSIG; i++) {
/* Check for signals which cannot be trapped: */
if (i == SIGKILL || i == SIGSTOP) {
}
/* Set the signal handler details: */
else if (__sys_sigaction(i, &_thread_sigact[i - 1],
NULL) != 0) {
/*
* Abort this process if signal
* initialisation fails:
*/
PANIC("Cannot set signal handler info");
}
}
__sys_sigaltstack(&curthread->sigstk, NULL);
}
Reference in New Issue View Git Blame Copy Permalink