freebsd-dev/lib/libkse/thread/thr_sig.c

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

/* Prototypes: */
static void	thread_sig_handle_special(int sig);

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_sigframe_add(struct pthread *thread, int sig,
		    int has_args);
static void	thread_sigframe_save(struct pthread *thread,
		    struct pthread_state_data *psd);
static void	thread_sigframe_restore(struct pthread *thread,
		    struct pthread_state_data *psd);

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

/*
 * Dispatch a signal to a thread, if appropriate.
 */
void
_thread_sig_dispatch(int sig)
{
	struct pthread	*pthread;

	DBG_MSG(">>> _thread_sig_dispatch(%d)\n", sig);

	thread_sig_handle_special(sig);
	if (sigismember(&_thread_sigmask, sig))
		/* Don't deliver the signal if it's masked. */
		return;
	/* Mask the signal until it's handled.  */
	sigaddset(&_thread_sigmask, sig);
	/* This signal will be handled; clear the pending flag. */
	sigdelset(&_thread_sigpending, sig);

	/*
	 * Deliver the signal to a thread.
	 */
	if ((pthread = thread_sig_find(sig)) == NULL) {
		DBG_MSG("No thread to handle signal %d\n", sig);
		return;
	}
	DBG_MSG("Got signal %d, selecting thread %p\n", sig, pthread);
	thread_sig_add(pthread, sig, /*has_args*/ 1);
}

/*
 * Find a thread that can handle the signal.
 */
static struct pthread *
thread_sig_find(int sig)
{
	struct pthread	*curthread = _get_curthread();
	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: */
		sigdelset(&_thread_sigmask, 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 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->mailbox.tm_context.uc_sigmask, sig))
		signaled_thread = curthread;
	else
		signaled_thread = NULL;

	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.
			 */
			sigdelset(&_thread_sigmask, sig);
			sigdelset(&_thread_sigpending, sig);

			/* 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);
		}
		if (!sigismember(
			&pthread->mailbox.tm_context.uc_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;
		}
	}

	/*
	 * 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->mailbox.tm_context.uc_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(&_thread_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);
}

#if __XXX_NOT_YET__
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, _thread_sigpending);
	SIGSETNAND(sigset, pthread->sigmask);
	SIGSETNAND(sigset, _thread_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(&_thread_sigpending, i);
				}
			}
		}
	}
}
#endif

#if __XXX_NOT_YET__
/*
 * 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		sig;

	/*
	 * Check the array of pending signals:
	 */
	for (sig = 1; sig <= NSIG; sig++) {
		if (sigismember(&_thread_sigpending, sig)) {
			/* This signal is no longer pending. */
			sigdelset(&_thread_sigpending, sig);
			/* Some signals need special handling. */
			thread_sig_handle_special(sig);
			/* Deliver the signal. */
			if (sigismember(&_thread_sigmask, sig)) {
				sigaddset(&_thread_sigmask, sig);
				if ((pthread = thread_sig_find(sig)) != NULL) {
					/*
					 * Setup the target thread to receive
					 * the signal:
					 */
					thread_sig_add(pthread, sig,
					    /*has_args*/ 1);
				}
			}
		}
	}
}
#endif

/*
 * Do special processing to the thread states before we deliver
 * a signal to the application.
 */
static void
thread_sig_handle_special(int sig)
{
	struct pthread	*pthread, *pthread_next;
	int		i;

	switch (sig) {
	case SIGCHLD:
		/*
		 * 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	suppress_handler = 0;

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

	case PS_SLEEP_WAIT:
		/*
		 * Unmasked signals always cause 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;
	}

	DBG_MSG(">>> suppress_handler = %d\n", suppress_handler);

	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
			PTHREAD_PRIOQ_INSERT_TAIL(pthread);
	}
}

#if __XXX_NOT_YET__
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_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;
	}
}
#endif

#if __XXX_NOT_YET__
/*
 * 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();
		}
	}
}
#endif

/*
 * User thread signal handler wrapper.
 *
 *   thread - current running thread
 */
void
_thread_sig_wrapper(int sig, siginfo_t *info, ucontext_t *context)
{
	struct pthread_state_data psd;
	struct pthread	*thread = _get_curthread();
	__siginfohandler_t *handler;

	/* Save the thread's previous state. */
	thread_sigframe_save(thread, &psd);

	/* Check the threads previous state: */
	if (psd.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 (psd.psd_state) {
		case PS_COND_WAIT:
			_cond_wait_backout(thread);
			psd.psd_state = PS_RUNNING;
			break;

		case PS_MUTEX_WAIT:
			_mutex_lock_backout(thread);
			psd.psd_state = PS_RUNNING;
			break;

		default:
			break;
		}
	}

	/* Unblock the signal in case we don't return from the handler. */
	/*
 	 * XXX - This is totally bogus. We need to lock the signal mask
         * somehow.
	 */
	sigdelset(&_thread_sigmask, sig);

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

	if (_thread_sigact[sig -1].sa_handler != NULL) {
		handler = (__siginfohandler_t *)
			_thread_sigact[sig - 1].sa_handler;
		handler(sig, info, context);
	}

        /* Restore the signal frame. */
        thread_sigframe_restore(thread, &psd);

        /* The signal mask was restored; check for any pending signals. */
        /* XXX - thread->check_pending = 1; */
}

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

	/* Add a signal frame to the stack, pointing to our signal wrapper. */
	signalcontext(&thread->mailbox.tm_context, sig,
	    (__sighandler_t *)_thread_sig_wrapper);

	/* Setup the new signal mask. */
	SIGSETOR(thread->mailbox.tm_context.uc_sigmask,
	    _thread_sigact[sig - 1].sa_mask);
	sigaddset(&thread->mailbox.tm_context.uc_sigmask, sig);
}

static void
thread_sigframe_restore(struct pthread *thread, struct pthread_state_data *psd)
{
	thread->wakeup_time = psd->psd_wakeup_time;
	thread->data = psd->psd_wait_data;
	thread->state = psd->psd_state;
	thread->flags = psd->psd_flags;
	thread->interrupted = psd->psd_interrupted;
	thread->sig_defer_count = psd->psd_sig_defer_count;
}

static void
thread_sigframe_save(struct pthread *thread, struct pthread_state_data *psd)
{
	psd->psd_wakeup_time = thread->wakeup_time;
	psd->psd_wait_data = thread->data;
	psd->psd_state = thread->state;
	psd->psd_flags = thread->flags &
	    (PTHREAD_FLAGS_PRIVATE | PTHREAD_FLAGS_TRACE);
	psd->psd_interrupted = thread->interrupted;
	psd->psd_sig_defer_count = thread->sig_defer_count;
}

void
_thread_sig_handler(int sig, siginfo_t *info, ucontext_t *context)
{

	/* Nothing. */
}