/* *  linux/kernel/signal.c * *  Copyright (C) 1991, 1992  Linus Torvalds * *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson */#include <linux/config.h>#include <linux/slab.h>#include <linux/module.h>#include <linux/unistd.h>#include <linux/smp_lock.h>#include <linux/init.h>#include <linux/sched.h>#include <linux/trace.h>#include <asm/uaccess.h>/* * SLAB caches for signal bits. */#define DEBUG_SIG 0#if DEBUG_SIG#define SIG_SLAB_DEBUG	(SLAB_DEBUG_FREE | SLAB_RED_ZONE /* | SLAB_POISON */)#else#define SIG_SLAB_DEBUG	0#endifstatic kmem_cache_t *sigqueue_cachep;atomic_t nr_queued_signals;int max_queued_signals = 1024;void __init signals_init(void){	sigqueue_cachep =		kmem_cache_create("sigqueue",				  sizeof(struct sigqueue),				  __alignof__(struct sigqueue),				  SIG_SLAB_DEBUG, NULL, NULL);	if (!sigqueue_cachep)		panic("signals_init(): cannot create sigqueue SLAB cache");}/* Given the mask, find the first available signal that should be serviced. */static intnext_signal(struct task_struct *tsk, sigset_t *mask){	unsigned long i, *s, *m, x;	int sig = 0;		s = tsk->pending.signal.sig;	m = mask->sig;	switch (_NSIG_WORDS) {	default:		for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)			if ((x = *s &~ *m) != 0) {				sig = ffz(~x) + i*_NSIG_BPW + 1;				break;			}		break;	case 2: if ((x = s[0] &~ m[0]) != 0)			sig = 1;		else if ((x = s[1] &~ m[1]) != 0)			sig = _NSIG_BPW + 1;		else			break;		sig += ffz(~x);		break;	case 1: if ((x = *s &~ *m) != 0)			sig = ffz(~x) + 1;		break;	}		return sig;}static void flush_sigqueue(struct sigpending *queue){	struct sigqueue *q, *n;	sigemptyset(&queue->signal);	q = queue->head;	queue->head = NULL;	queue->tail = &queue->head;	while (q) {		n = q->next;		kmem_cache_free(sigqueue_cachep, q);		atomic_dec(&nr_queued_signals);		q = n;	}}/* * Flush all pending signals for a task. */voidflush_signals(struct task_struct *t){	t->sigpending = 0;	flush_sigqueue(&t->pending);}void exit_sighand(struct task_struct *tsk){	struct signal_struct * sig = tsk->sig;	spin_lock_irq(&tsk->sigmask_lock);	if (sig) {		tsk->sig = NULL;		if (atomic_dec_and_test(&sig->count))			kmem_cache_free(sigact_cachep, sig);	}	tsk->sigpending = 0;	flush_sigqueue(&tsk->pending);	spin_unlock_irq(&tsk->sigmask_lock);}/* * Flush all handlers for a task. */voidflush_signal_handlers(struct task_struct *t){	int i;	struct k_sigaction *ka = &t->sig->action[0];	for (i = _NSIG ; i != 0 ; i--) {		if (ka->sa.sa_handler != SIG_IGN)			ka->sa.sa_handler = SIG_DFL;		ka->sa.sa_flags = 0;		sigemptyset(&ka->sa.sa_mask);		ka++;	}}/* * sig_exit - cause the current task to exit due to a signal. */voidsig_exit(int sig, int exit_code, struct siginfo *info){	struct task_struct *t;	sigaddset(&current->pending.signal, sig);	recalc_sigpending(current);	current->flags |= PF_SIGNALED;	/* Propagate the signal to all the tasks in	 *  our thread group	 */	if (info && (unsigned long)info != 1	    && info->si_code != SI_TKILL) {		read_lock(&tasklist_lock);		for_each_thread(t) {			force_sig_info(sig, info, t);		}		read_unlock(&tasklist_lock);	}	do_exit(exit_code);	/* NOTREACHED */}/* Notify the system that a driver wants to block all signals for this * process, and wants to be notified if any signals at all were to be * sent/acted upon.  If the notifier routine returns non-zero, then the * signal will be acted upon after all.  If the notifier routine returns 0, * then then signal will be blocked.  Only one block per process is * allowed.  priv is a pointer to private data that the notifier routine * can use to determine if the signal should be blocked or not.  */voidblock_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask){	unsigned long flags;	spin_lock_irqsave(&current->sigmask_lock, flags);	current->notifier_mask = mask;	current->notifier_data = priv;	current->notifier = notifier;	spin_unlock_irqrestore(&current->sigmask_lock, flags);}/* Notify the system that blocking has ended. */voidunblock_all_signals(void){	unsigned long flags;	spin_lock_irqsave(&current->sigmask_lock, flags);	current->notifier = NULL;	current->notifier_data = NULL;	recalc_sigpending(current);	spin_unlock_irqrestore(&current->sigmask_lock, flags);}static int collect_signal(int sig, struct sigpending *list, siginfo_t *info){	if (sigismember(&list->signal, sig)) {		/* Collect the siginfo appropriate to this signal.  */		struct sigqueue *q, **pp;		pp = &list->head;		while ((q = *pp) != NULL) {			if (q->info.si_signo == sig)				goto found_it;			pp = &q->next;		}		/* Ok, it wasn't in the queue.  We must have		   been out of queue space.  So zero out the		   info.  */		sigdelset(&list->signal, sig);		info->si_signo = sig;		info->si_errno = 0;		info->si_code = 0;		info->si_pid = 0;		info->si_uid = 0;		return 1;found_it:		if ((*pp = q->next) == NULL)			list->tail = pp;		/* Copy the sigqueue information and free the queue entry */		copy_siginfo(info, &q->info);		kmem_cache_free(sigqueue_cachep,q);		atomic_dec(&nr_queued_signals);		/* Non-RT signals can exist multiple times.. */		if (sig >= SIGRTMIN) {			while ((q = *pp) != NULL) {				if (q->info.si_signo == sig)					goto found_another;				pp = &q->next;			}		}		sigdelset(&list->signal, sig);found_another:		return 1;	}	return 0;}/* * Dequeue a signal and return the element to the caller, which is  * expected to free it. * * All callers must be holding current->sigmask_lock. */intdequeue_signal(sigset_t *mask, siginfo_t *info){	int sig = 0;#if DEBUG_SIGprintk("SIG dequeue (%s:%d): %d ", current->comm, current->pid,	signal_pending(current));#endif	sig = next_signal(current, mask);	if (sig) {		if (current->notifier) {			if (sigismember(current->notifier_mask, sig)) {				if (!(current->notifier)(current->notifier_data)) {					current->sigpending = 0;					return 0;				}			}		}		if (!collect_signal(sig, &current->pending, info))			sig = 0;						/* XXX: Once POSIX.1b timers are in, if si_code == SI_TIMER,		   we need to xchg out the timer overrun values.  */	}	recalc_sigpending(current);#if DEBUG_SIGprintk(" %d -> %d\n", signal_pending(current), sig);#endif	return sig;}static int rm_from_queue(int sig, struct sigpending *s){	struct sigqueue *q, **pp;	if (!sigismember(&s->signal, sig))		return 0;	sigdelset(&s->signal, sig);	pp = &s->head;	while ((q = *pp) != NULL) {		if (q->info.si_signo == sig) {			if ((*pp = q->next) == NULL)				s->tail = pp;			kmem_cache_free(sigqueue_cachep,q);			atomic_dec(&nr_queued_signals);			continue;		}		pp = &q->next;	}	return 1;}/* * Remove signal sig from t->pending. * Returns 1 if sig was found. * * All callers must be holding t->sigmask_lock. */static int rm_sig_from_queue(int sig, struct task_struct *t){	return rm_from_queue(sig, &t->pending);}/* * Bad permissions for sending the signal */int bad_signal(int sig, struct siginfo *info, struct task_struct *t){	return (!info || ((unsigned long)info != 1 && SI_FROMUSER(info)))	    && ((sig != SIGCONT) || (current->session != t->session))	    && (current->euid ^ t->suid) && (current->euid ^ t->uid)	    && (current->uid ^ t->suid) && (current->uid ^ t->uid)	    && !capable(CAP_KILL);}/* * Signal type: *    < 0 : global action (kill - spread to all non-blocked threads) *    = 0 : ignored *    > 0 : wake up. */static int signal_type(int sig, struct signal_struct *signals){	unsigned long handler;	if (!signals)		return 0;		handler = (unsigned long) signals->action[sig-1].sa.sa_handler;	if (handler > 1)		return 1;	/* "Ignore" handler.. Illogical, but that has an implicit handler for SIGCHLD */	if (handler == 1)		return sig == SIGCHLD;	/* Default handler. Normally lethal, but.. */	switch (sig) {	/* Ignored */	case SIGCONT: case SIGWINCH:	case SIGCHLD: case SIGURG:		return 0;	/* Implicit behaviour */	case SIGTSTP: case SIGTTIN: case SIGTTOU:		return 1;	/* Implicit actions (kill or do special stuff) */	default:		return -1;	}}		/* * Determine whether a signal should be posted or not. * * Signals with SIG_IGN can be ignored, except for the * special case of a SIGCHLD.  * * Some signals with SIG_DFL default to a non-action. */static int ignored_signal(int sig, struct task_struct *t){	/* Don't ignore traced or blocked signals */	if ((t->ptrace & PT_PTRACED) || sigismember(&t->blocked, sig))		return 0;	return signal_type(sig, t->sig) == 0;}/* * Handle TASK_STOPPED cases etc implicit behaviour * of certain magical signals. * * SIGKILL gets spread out to every thread.  */static void handle_stop_signal(int sig, struct task_struct *t){	switch (sig) {	case SIGKILL: case SIGCONT:		/* Wake up the process if stopped.  */		if (t->state == TASK_STOPPED)			wake_up_process(t);		t->exit_code = 0;		rm_sig_from_queue(SIGSTOP, t);		rm_sig_from_queue(SIGTSTP, t);		rm_sig_from_queue(SIGTTOU, t);		rm_sig_from_queue(SIGTTIN, t);		break;	case SIGSTOP: case SIGTSTP:	case SIGTTIN: case SIGTTOU:		/* If we're stopping again, cancel SIGCONT */		rm_sig_from_queue(SIGCONT, t);		break;	}}static int send_signal(int sig, struct siginfo *info, struct sigpending *signals){	struct sigqueue * q = NULL;	/* Real-time signals must be queued if sent by sigqueue, or	   some other real-time mechanism.  It is implementation	   defined whether kill() does so.  We attempt to do so, on	   the principle of least surprise, but since kill is not	   allowed to fail with EAGAIN when low on memory we just	   make sure at least one signal gets delivered and don't	   pass on the info struct.  */	if (atomic_read(&nr_queued_signals) < max_queued_signals) {		q = kmem_cache_alloc(sigqueue_cachep, GFP_ATOMIC);	}	if (q) {		atomic_inc(&nr_queued_signals);		q->next = NULL;		*signals->tail = q;		signals->tail = &q->next;		switch ((unsigned long) info) {			case 0:				q->info.si_signo = sig;				q->info.si_errno = 0;				q->info.si_code = SI_USER;				q->info.si_pid = current->pid;				q->info.si_uid = current->uid;				break;			case 1:				q->info.si_signo = sig;				q->info.si_errno = 0;				q->info.si_code = SI_KERNEL;				q->info.si_pid = 0;				q->info.si_uid = 0;				break;			default:				copy_siginfo(&q->info, info);				break;		}	} else if (sig >= SIGRTMIN && info && (unsigned long)info != 1		   && info->si_code != SI_USER) {		/*		 * Queue overflow, abort.  We may abort if the signal was rt		 * and sent by user using something other than kill().		 */		return -EAGAIN;	}	sigaddset(&signals->signal, sig);	return 0;}/* * Tell a process that it has a new active signal.. * * NOTE! we rely on the previous spin_lock to * lock interrupts for us! We can only be called with * "sigmask_lock" held, and the local interrupt must * have been disabled when that got acquired! * * No need to set need_resched since signal event passing * goes through ->blocked */static inline void signal_wake_up(struct task_struct *t){	t->sigpending = 1;#ifdef CONFIG_SMP	/*	 * If the task is running on a different CPU 	 * force a reschedule on the other CPU to make	 * it notice the new signal quickly.	 *	 * The code below is a tad loose and might occasionally	 * kick the wrong CPU if we catch the process in the	 * process of changing - but no harm is done by that	 * other than doing an extra (lightweight) IPI interrupt.	 */	if ((t->state == TASK_RUNNING) && (t->cpu != cpu()))		kick_if_running(t);#endif	if (t->state & TASK_INTERRUPTIBLE) {		wake_up_process(t);		return;	}}static int deliver_signal(int sig, struct siginfo *info, struct task_struct *t){	int retval = send_signal(sig, info, &t->pending);	if (!retval && !sigismember(&t->blocked, sig))		signal_wake_up(t);	return retval;}intsend_sig_info(int sig, struct siginfo *info, struct task_struct *t){	unsigned long flags;	int ret;#if DEBUG_SIGprintk("SIG queue (%s:%d): %d ", t->comm, t->pid, sig);#endif	ret = -EINVAL;	if (sig < 0 || sig > _NSIG)		goto out_nolock;	/* The somewhat baroque permissions check... */	ret = -EPERM;	if (bad_signal(sig, info, t))		goto out_nolock;	/* The null signal is a permissions and process existence probe.	   No signal is actually delivered.  Same goes for zombies. */	ret = 0;	if (!sig || !t->sig)		goto out_nolock;	spin_lock_irqsave(&t->sigmask_lock, flags);	handle_stop_signal(sig, t);	/* Optimize away the signal, if it's a signal that can be	   handled immediately (ie non-blocked and untraced) and	   that is ignored (either explicitly or by default).  */	if (ignored_signal(sig, t))		goto out;	/* Support queueing exactly one non-rt signal, so that we	   can get more detailed information about the cause of	   the signal. */	if (sig < SIGRTMIN && sigismember(&t->pending.signal, sig))		goto out;	TRACE_PROCESS(TRACE_EV_PROCESS_SIGNAL, sig, t->pid);	ret = deliver_signal(sig, info, t);out:	spin_unlock_irqrestore(&t->sigmask_lock, flags);out_nolock:#if DEBUG_SIGprintk(" %d -> %d\n", signal_pending(t), ret);#endif	return ret;}/* * Force a signal that the process can't ignore: if necessary * we unblock the signal and change any SIG_IGN to SIG_DFL. */intforce_sig_info(int sig, struct siginfo *info, struct task_struct *t){	unsigned long int flags;	spin_lock_irqsave(&t->sigmask_lock, flags);	if (t->sig == NULL) {		spin_unlock_irqrestore(&t->sigmask_lock, flags);		return -ESRCH;	}	if (t->sig->action[sig-1].sa.sa_handler == SIG_IGN)		t->sig->action[sig-1].sa.sa_handler = SIG_DFL;	sigdelset(&t->blocked, sig);	recalc_sigpending(t);	spin_unlock_irqrestore(&t->sigmask_lock, flags);	return send_sig_info(sig, info, t);}/* * kill_pg_info() sends a signal to a process group: this is what the tty * control characters do (^C, ^Z etc) */intkill_pg_info(int sig, struct siginfo *info, pid_t pgrp){	int retval = -EINVAL;	if (pgrp > 0) {		struct task_struct *p;		retval = -ESRCH;		read_lock(&tasklist_lock);		for_each_task(p) {			if (p->pgrp == pgrp && thread_group_leader(p)) {				int err = send_sig_info(sig, info, p);				if (retval)					retval = err;			}		}		read_unlock(&tasklist_lock);	}	return retval;}/* * kill_sl_info() sends a signal to the session leader: this is used * to send SIGHUP to the controlling process of a terminal when * the connection is lost. */intkill_sl_info(int sig, struct siginfo *info, pid_t sess){	int retval = -EINVAL;	if (sess > 0) {		struct task_struct *p;		retval = -ESRCH;		read_lock(&tasklist_lock);		for_each_task(p) {			if (p->leader && p->session == sess) {				int err = send_sig_info(sig, info, p);				if (retval)					retval = err;			}		}		read_unlock(&tasklist_lock);	}	return retval;}