2 * linux/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/smp_lock.h>
16 #include <linux/init.h>
17 #include <linux/sched.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/security.h>
22 #include <linux/syscalls.h>
23 #include <linux/ptrace.h>
24 #include <linux/signal.h>
25 #include <linux/capability.h>
26 #include <asm/param.h>
27 #include <asm/uaccess.h>
28 #include <asm/unistd.h>
29 #include <asm/siginfo.h>
30 #include "audit.h" /* audit_signal_info() */
33 * SLAB caches for signal bits.
36 static kmem_cache_t *sigqueue_cachep;
39 * In POSIX a signal is sent either to a specific thread (Linux task)
40 * or to the process as a whole (Linux thread group). How the signal
41 * is sent determines whether it's to one thread or the whole group,
42 * which determines which signal mask(s) are involved in blocking it
43 * from being delivered until later. When the signal is delivered,
44 * either it's caught or ignored by a user handler or it has a default
45 * effect that applies to the whole thread group (POSIX process).
47 * The possible effects an unblocked signal set to SIG_DFL can have are:
48 * ignore - Nothing Happens
49 * terminate - kill the process, i.e. all threads in the group,
50 * similar to exit_group. The group leader (only) reports
51 * WIFSIGNALED status to its parent.
52 * coredump - write a core dump file describing all threads using
53 * the same mm and then kill all those threads
54 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
56 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
57 * Other signals when not blocked and set to SIG_DFL behaves as follows.
58 * The job control signals also have other special effects.
60 * +--------------------+------------------+
61 * | POSIX signal | default action |
62 * +--------------------+------------------+
63 * | SIGHUP | terminate |
64 * | SIGINT | terminate |
65 * | SIGQUIT | coredump |
66 * | SIGILL | coredump |
67 * | SIGTRAP | coredump |
68 * | SIGABRT/SIGIOT | coredump |
69 * | SIGBUS | coredump |
70 * | SIGFPE | coredump |
71 * | SIGKILL | terminate(+) |
72 * | SIGUSR1 | terminate |
73 * | SIGSEGV | coredump |
74 * | SIGUSR2 | terminate |
75 * | SIGPIPE | terminate |
76 * | SIGALRM | terminate |
77 * | SIGTERM | terminate |
78 * | SIGCHLD | ignore |
79 * | SIGCONT | ignore(*) |
80 * | SIGSTOP | stop(*)(+) |
81 * | SIGTSTP | stop(*) |
82 * | SIGTTIN | stop(*) |
83 * | SIGTTOU | stop(*) |
85 * | SIGXCPU | coredump |
86 * | SIGXFSZ | coredump |
87 * | SIGVTALRM | terminate |
88 * | SIGPROF | terminate |
89 * | SIGPOLL/SIGIO | terminate |
90 * | SIGSYS/SIGUNUSED | coredump |
91 * | SIGSTKFLT | terminate |
92 * | SIGWINCH | ignore |
93 * | SIGPWR | terminate |
94 * | SIGRTMIN-SIGRTMAX | terminate |
95 * +--------------------+------------------+
96 * | non-POSIX signal | default action |
97 * +--------------------+------------------+
98 * | SIGEMT | coredump |
99 * +--------------------+------------------+
101 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
102 * (*) Special job control effects:
103 * When SIGCONT is sent, it resumes the process (all threads in the group)
104 * from TASK_STOPPED state and also clears any pending/queued stop signals
105 * (any of those marked with "stop(*)"). This happens regardless of blocking,
106 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
107 * any pending/queued SIGCONT signals; this happens regardless of blocking,
108 * catching, or ignored the stop signal, though (except for SIGSTOP) the
109 * default action of stopping the process may happen later or never.
113 #define M_SIGEMT M(SIGEMT)
118 #if SIGRTMIN > BITS_PER_LONG
119 #define M(sig) (1ULL << ((sig)-1))
121 #define M(sig) (1UL << ((sig)-1))
123 #define T(sig, mask) (M(sig) & (mask))
125 #define SIG_KERNEL_ONLY_MASK (\
126 M(SIGKILL) | M(SIGSTOP) )
128 #define SIG_KERNEL_STOP_MASK (\
129 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
131 #define SIG_KERNEL_COREDUMP_MASK (\
132 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
133 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
134 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
136 #define SIG_KERNEL_IGNORE_MASK (\
137 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
139 #define sig_kernel_only(sig) \
140 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
141 #define sig_kernel_coredump(sig) \
142 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
143 #define sig_kernel_ignore(sig) \
144 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
145 #define sig_kernel_stop(sig) \
146 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
148 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
150 #define sig_user_defined(t, signr) \
151 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
152 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
154 #define sig_fatal(t, signr) \
155 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
156 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
158 static int sig_ignored(struct task_struct *t, int sig)
160 void __user * handler;
163 * Tracers always want to know about signals..
165 if (t->ptrace & PT_PTRACED)
169 * Blocked signals are never ignored, since the
170 * signal handler may change by the time it is
173 if (sigismember(&t->blocked, sig))
176 /* Is it explicitly or implicitly ignored? */
177 handler = t->sighand->action[sig-1].sa.sa_handler;
178 return handler == SIG_IGN ||
179 (handler == SIG_DFL && sig_kernel_ignore(sig));
183 * Re-calculate pending state from the set of locally pending
184 * signals, globally pending signals, and blocked signals.
186 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
191 switch (_NSIG_WORDS) {
193 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
194 ready |= signal->sig[i] &~ blocked->sig[i];
197 case 4: ready = signal->sig[3] &~ blocked->sig[3];
198 ready |= signal->sig[2] &~ blocked->sig[2];
199 ready |= signal->sig[1] &~ blocked->sig[1];
200 ready |= signal->sig[0] &~ blocked->sig[0];
203 case 2: ready = signal->sig[1] &~ blocked->sig[1];
204 ready |= signal->sig[0] &~ blocked->sig[0];
207 case 1: ready = signal->sig[0] &~ blocked->sig[0];
212 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
214 fastcall void recalc_sigpending_tsk(struct task_struct *t)
216 if (t->signal->group_stop_count > 0 ||
218 PENDING(&t->pending, &t->blocked) ||
219 PENDING(&t->signal->shared_pending, &t->blocked))
220 set_tsk_thread_flag(t, TIF_SIGPENDING);
222 clear_tsk_thread_flag(t, TIF_SIGPENDING);
225 void recalc_sigpending(void)
227 recalc_sigpending_tsk(current);
230 /* Given the mask, find the first available signal that should be serviced. */
233 next_signal(struct sigpending *pending, sigset_t *mask)
235 unsigned long i, *s, *m, x;
238 s = pending->signal.sig;
240 switch (_NSIG_WORDS) {
242 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
243 if ((x = *s &~ *m) != 0) {
244 sig = ffz(~x) + i*_NSIG_BPW + 1;
249 case 2: if ((x = s[0] &~ m[0]) != 0)
251 else if ((x = s[1] &~ m[1]) != 0)
258 case 1: if ((x = *s &~ *m) != 0)
266 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
269 struct sigqueue *q = NULL;
271 atomic_inc(&t->user->sigpending);
272 if (override_rlimit ||
273 atomic_read(&t->user->sigpending) <=
274 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
275 q = kmem_cache_alloc(sigqueue_cachep, flags);
276 if (unlikely(q == NULL)) {
277 atomic_dec(&t->user->sigpending);
279 INIT_LIST_HEAD(&q->list);
281 q->user = get_uid(t->user);
286 static void __sigqueue_free(struct sigqueue *q)
288 if (q->flags & SIGQUEUE_PREALLOC)
290 atomic_dec(&q->user->sigpending);
292 kmem_cache_free(sigqueue_cachep, q);
295 void flush_sigqueue(struct sigpending *queue)
299 sigemptyset(&queue->signal);
300 while (!list_empty(&queue->list)) {
301 q = list_entry(queue->list.next, struct sigqueue , list);
302 list_del_init(&q->list);
308 * Flush all pending signals for a task.
310 void flush_signals(struct task_struct *t)
314 spin_lock_irqsave(&t->sighand->siglock, flags);
315 clear_tsk_thread_flag(t,TIF_SIGPENDING);
316 flush_sigqueue(&t->pending);
317 flush_sigqueue(&t->signal->shared_pending);
318 spin_unlock_irqrestore(&t->sighand->siglock, flags);
322 * Flush all handlers for a task.
326 flush_signal_handlers(struct task_struct *t, int force_default)
329 struct k_sigaction *ka = &t->sighand->action[0];
330 for (i = _NSIG ; i != 0 ; i--) {
331 if (force_default || ka->sa.sa_handler != SIG_IGN)
332 ka->sa.sa_handler = SIG_DFL;
334 sigemptyset(&ka->sa.sa_mask);
339 EXPORT_SYMBOL_GPL(flush_signal_handlers);
341 /* Notify the system that a driver wants to block all signals for this
342 * process, and wants to be notified if any signals at all were to be
343 * sent/acted upon. If the notifier routine returns non-zero, then the
344 * signal will be acted upon after all. If the notifier routine returns 0,
345 * then then signal will be blocked. Only one block per process is
346 * allowed. priv is a pointer to private data that the notifier routine
347 * can use to determine if the signal should be blocked or not. */
350 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
354 spin_lock_irqsave(¤t->sighand->siglock, flags);
355 current->notifier_mask = mask;
356 current->notifier_data = priv;
357 current->notifier = notifier;
358 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
361 /* Notify the system that blocking has ended. */
364 unblock_all_signals(void)
368 spin_lock_irqsave(¤t->sighand->siglock, flags);
369 current->notifier = NULL;
370 current->notifier_data = NULL;
372 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
375 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
377 struct sigqueue *q, *first = NULL;
378 int still_pending = 0;
380 if (unlikely(!sigismember(&list->signal, sig)))
384 * Collect the siginfo appropriate to this signal. Check if
385 * there is another siginfo for the same signal.
387 list_for_each_entry(q, &list->list, list) {
388 if (q->info.si_signo == sig) {
397 list_del_init(&first->list);
398 copy_siginfo(info, &first->info);
399 __sigqueue_free(first);
401 sigdelset(&list->signal, sig);
404 /* Ok, it wasn't in the queue. This must be
405 a fast-pathed signal or we must have been
406 out of queue space. So zero out the info.
408 sigdelset(&list->signal, sig);
409 info->si_signo = sig;
418 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
423 sig = next_signal(pending, mask);
425 if (current->notifier) {
426 if (sigismember(current->notifier_mask, sig)) {
427 if (!(current->notifier)(current->notifier_data)) {
428 clear_thread_flag(TIF_SIGPENDING);
434 if (!collect_signal(sig, pending, info))
444 * Dequeue a signal and return the element to the caller, which is
445 * expected to free it.
447 * All callers have to hold the siglock.
449 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
451 int signr = __dequeue_signal(&tsk->pending, mask, info);
453 signr = __dequeue_signal(&tsk->signal->shared_pending,
455 if (signr && unlikely(sig_kernel_stop(signr))) {
457 * Set a marker that we have dequeued a stop signal. Our
458 * caller might release the siglock and then the pending
459 * stop signal it is about to process is no longer in the
460 * pending bitmasks, but must still be cleared by a SIGCONT
461 * (and overruled by a SIGKILL). So those cases clear this
462 * shared flag after we've set it. Note that this flag may
463 * remain set after the signal we return is ignored or
464 * handled. That doesn't matter because its only purpose
465 * is to alert stop-signal processing code when another
466 * processor has come along and cleared the flag.
468 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
469 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
472 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
473 info->si_sys_private){
475 * Release the siglock to ensure proper locking order
476 * of timer locks outside of siglocks. Note, we leave
477 * irqs disabled here, since the posix-timers code is
478 * about to disable them again anyway.
480 spin_unlock(&tsk->sighand->siglock);
481 do_schedule_next_timer(info);
482 spin_lock(&tsk->sighand->siglock);
488 * Tell a process that it has a new active signal..
490 * NOTE! we rely on the previous spin_lock to
491 * lock interrupts for us! We can only be called with
492 * "siglock" held, and the local interrupt must
493 * have been disabled when that got acquired!
495 * No need to set need_resched since signal event passing
496 * goes through ->blocked
498 void signal_wake_up(struct task_struct *t, int resume)
502 set_tsk_thread_flag(t, TIF_SIGPENDING);
505 * For SIGKILL, we want to wake it up in the stopped/traced case.
506 * We don't check t->state here because there is a race with it
507 * executing another processor and just now entering stopped state.
508 * By using wake_up_state, we ensure the process will wake up and
509 * handle its death signal.
511 mask = TASK_INTERRUPTIBLE;
513 mask |= TASK_STOPPED | TASK_TRACED;
514 if (!wake_up_state(t, mask))
519 * Remove signals in mask from the pending set and queue.
520 * Returns 1 if any signals were found.
522 * All callers must be holding the siglock.
524 * This version takes a sigset mask and looks at all signals,
525 * not just those in the first mask word.
527 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
529 struct sigqueue *q, *n;
532 sigandsets(&m, mask, &s->signal);
533 if (sigisemptyset(&m))
536 signandsets(&s->signal, &s->signal, mask);
537 list_for_each_entry_safe(q, n, &s->list, list) {
538 if (sigismember(mask, q->info.si_signo)) {
539 list_del_init(&q->list);
546 * Remove signals in mask from the pending set and queue.
547 * Returns 1 if any signals were found.
549 * All callers must be holding the siglock.
551 static int rm_from_queue(unsigned long mask, struct sigpending *s)
553 struct sigqueue *q, *n;
555 if (!sigtestsetmask(&s->signal, mask))
558 sigdelsetmask(&s->signal, mask);
559 list_for_each_entry_safe(q, n, &s->list, list) {
560 if (q->info.si_signo < SIGRTMIN &&
561 (mask & sigmask(q->info.si_signo))) {
562 list_del_init(&q->list);
570 * Bad permissions for sending the signal
572 static int check_kill_permission(int sig, struct siginfo *info,
573 struct task_struct *t)
578 if (!valid_signal(sig))
581 user = ((info == SEND_SIG_NOINFO) ||
582 (!is_si_special(info) && SI_FROMUSER(info)));
585 if (user && ((sig != SIGCONT) ||
586 (current->signal->session != t->signal->session))
587 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
588 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
589 && !capable(CAP_KILL))
593 if (user && !vx_check(vx_task_xid(t), VX_ADMIN|VX_IDENT))
596 error = security_task_kill(t, info, sig, 0);
598 audit_signal_info(sig, t); /* Let audit system see the signal */
603 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
606 * Handle magic process-wide effects of stop/continue signals.
607 * Unlike the signal actions, these happen immediately at signal-generation
608 * time regardless of blocking, ignoring, or handling. This does the
609 * actual continuing for SIGCONT, but not the actual stopping for stop
610 * signals. The process stop is done as a signal action for SIG_DFL.
612 static void handle_stop_signal(int sig, struct task_struct *p)
614 struct task_struct *t;
616 if (p->signal->flags & SIGNAL_GROUP_EXIT)
618 * The process is in the middle of dying already.
622 if (sig_kernel_stop(sig)) {
624 * This is a stop signal. Remove SIGCONT from all queues.
626 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
629 rm_from_queue(sigmask(SIGCONT), &t->pending);
632 } else if (sig == SIGCONT) {
634 * Remove all stop signals from all queues,
635 * and wake all threads.
637 if (unlikely(p->signal->group_stop_count > 0)) {
639 * There was a group stop in progress. We'll
640 * pretend it finished before we got here. We are
641 * obliged to report it to the parent: if the
642 * SIGSTOP happened "after" this SIGCONT, then it
643 * would have cleared this pending SIGCONT. If it
644 * happened "before" this SIGCONT, then the parent
645 * got the SIGCHLD about the stop finishing before
646 * the continue happened. We do the notification
647 * now, and it's as if the stop had finished and
648 * the SIGCHLD was pending on entry to this kill.
650 p->signal->group_stop_count = 0;
651 p->signal->flags = SIGNAL_STOP_CONTINUED;
652 spin_unlock(&p->sighand->siglock);
653 do_notify_parent_cldstop(p, CLD_STOPPED);
654 spin_lock(&p->sighand->siglock);
656 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
660 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
663 * If there is a handler for SIGCONT, we must make
664 * sure that no thread returns to user mode before
665 * we post the signal, in case it was the only
666 * thread eligible to run the signal handler--then
667 * it must not do anything between resuming and
668 * running the handler. With the TIF_SIGPENDING
669 * flag set, the thread will pause and acquire the
670 * siglock that we hold now and until we've queued
671 * the pending signal.
673 * Wake up the stopped thread _after_ setting
676 state = TASK_STOPPED;
677 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
678 set_tsk_thread_flag(t, TIF_SIGPENDING);
679 state |= TASK_INTERRUPTIBLE;
681 wake_up_state(t, state);
686 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
688 * We were in fact stopped, and are now continued.
689 * Notify the parent with CLD_CONTINUED.
691 p->signal->flags = SIGNAL_STOP_CONTINUED;
692 p->signal->group_exit_code = 0;
693 spin_unlock(&p->sighand->siglock);
694 do_notify_parent_cldstop(p, CLD_CONTINUED);
695 spin_lock(&p->sighand->siglock);
698 * We are not stopped, but there could be a stop
699 * signal in the middle of being processed after
700 * being removed from the queue. Clear that too.
702 p->signal->flags = 0;
704 } else if (sig == SIGKILL) {
706 * Make sure that any pending stop signal already dequeued
707 * is undone by the wakeup for SIGKILL.
709 p->signal->flags = 0;
713 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
714 struct sigpending *signals)
716 struct sigqueue * q = NULL;
720 * fast-pathed signals for kernel-internal things like SIGSTOP
723 if (info == SEND_SIG_FORCED)
726 /* Real-time signals must be queued if sent by sigqueue, or
727 some other real-time mechanism. It is implementation
728 defined whether kill() does so. We attempt to do so, on
729 the principle of least surprise, but since kill is not
730 allowed to fail with EAGAIN when low on memory we just
731 make sure at least one signal gets delivered and don't
732 pass on the info struct. */
734 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
735 (is_si_special(info) ||
736 info->si_code >= 0)));
738 list_add_tail(&q->list, &signals->list);
739 switch ((unsigned long) info) {
740 case (unsigned long) SEND_SIG_NOINFO:
741 q->info.si_signo = sig;
742 q->info.si_errno = 0;
743 q->info.si_code = SI_USER;
744 q->info.si_pid = current->pid;
745 q->info.si_uid = current->uid;
747 case (unsigned long) SEND_SIG_PRIV:
748 q->info.si_signo = sig;
749 q->info.si_errno = 0;
750 q->info.si_code = SI_KERNEL;
755 copy_siginfo(&q->info, info);
758 } else if (!is_si_special(info)) {
759 if (sig >= SIGRTMIN && info->si_code != SI_USER)
761 * Queue overflow, abort. We may abort if the signal was rt
762 * and sent by user using something other than kill().
768 sigaddset(&signals->signal, sig);
772 #define LEGACY_QUEUE(sigptr, sig) \
773 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
775 int print_fatal_signals = 0;
777 static void print_fatal_signal(struct pt_regs *regs, int signr)
779 printk("%s/%d: potentially unexpected fatal signal %d.\n",
780 current->comm, current->pid, signr);
783 printk("code at %08lx: ", regs->eip);
786 for (i = 0; i < 16; i++) {
789 __get_user(insn, (unsigned char *)(regs->eip + i));
790 printk("%02x ", insn);
798 static int __init setup_print_fatal_signals(char *str)
800 get_option (&str, &print_fatal_signals);
805 __setup("print-fatal-signals=", setup_print_fatal_signals);
808 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
812 BUG_ON(!irqs_disabled());
813 assert_spin_locked(&t->sighand->siglock);
815 /* Short-circuit ignored signals. */
816 if (sig_ignored(t, sig))
819 /* Support queueing exactly one non-rt signal, so that we
820 can get more detailed information about the cause of
822 if (LEGACY_QUEUE(&t->pending, sig))
825 ret = send_signal(sig, info, t, &t->pending);
826 if (!ret && !sigismember(&t->blocked, sig))
827 signal_wake_up(t, sig == SIGKILL);
833 * Force a signal that the process can't ignore: if necessary
834 * we unblock the signal and change any SIG_IGN to SIG_DFL.
836 * Note: If we unblock the signal, we always reset it to SIG_DFL,
837 * since we do not want to have a signal handler that was blocked
838 * be invoked when user space had explicitly blocked it.
840 * We don't want to have recursive SIGSEGV's etc, for example.
843 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
845 unsigned long int flags;
846 int ret, blocked, ignored;
847 struct k_sigaction *action;
849 spin_lock_irqsave(&t->sighand->siglock, flags);
850 action = &t->sighand->action[sig-1];
851 ignored = action->sa.sa_handler == SIG_IGN;
852 blocked = sigismember(&t->blocked, sig);
853 if (blocked || ignored) {
854 action->sa.sa_handler = SIG_DFL;
856 sigdelset(&t->blocked, sig);
857 recalc_sigpending_tsk(t);
860 ret = specific_send_sig_info(sig, info, t);
861 spin_unlock_irqrestore(&t->sighand->siglock, flags);
867 force_sig_specific(int sig, struct task_struct *t)
869 force_sig_info(sig, SEND_SIG_FORCED, t);
873 * Test if P wants to take SIG. After we've checked all threads with this,
874 * it's equivalent to finding no threads not blocking SIG. Any threads not
875 * blocking SIG were ruled out because they are not running and already
876 * have pending signals. Such threads will dequeue from the shared queue
877 * as soon as they're available, so putting the signal on the shared queue
878 * will be equivalent to sending it to one such thread.
880 static inline int wants_signal(int sig, struct task_struct *p)
882 if (sigismember(&p->blocked, sig))
884 if (p->flags & PF_EXITING)
888 if (p->state & (TASK_STOPPED | TASK_TRACED))
890 return task_curr(p) || !signal_pending(p);
894 __group_complete_signal(int sig, struct task_struct *p)
896 struct task_struct *t;
899 * Now find a thread we can wake up to take the signal off the queue.
901 * If the main thread wants the signal, it gets first crack.
902 * Probably the least surprising to the average bear.
904 if (wants_signal(sig, p))
906 else if (thread_group_empty(p))
908 * There is just one thread and it does not need to be woken.
909 * It will dequeue unblocked signals before it runs again.
914 * Otherwise try to find a suitable thread.
916 t = p->signal->curr_target;
918 /* restart balancing at this thread */
919 t = p->signal->curr_target = p;
921 while (!wants_signal(sig, t)) {
923 if (t == p->signal->curr_target)
925 * No thread needs to be woken.
926 * Any eligible threads will see
927 * the signal in the queue soon.
931 p->signal->curr_target = t;
935 * Found a killable thread. If the signal will be fatal,
936 * then start taking the whole group down immediately.
938 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
939 !sigismember(&t->real_blocked, sig) &&
940 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
942 * This signal will be fatal to the whole group.
944 if (!sig_kernel_coredump(sig)) {
946 * Start a group exit and wake everybody up.
947 * This way we don't have other threads
948 * running and doing things after a slower
949 * thread has the fatal signal pending.
951 p->signal->flags = SIGNAL_GROUP_EXIT;
952 p->signal->group_exit_code = sig;
953 p->signal->group_stop_count = 0;
956 sigaddset(&t->pending.signal, SIGKILL);
957 signal_wake_up(t, 1);
964 * There will be a core dump. We make all threads other
965 * than the chosen one go into a group stop so that nothing
966 * happens until it gets scheduled, takes the signal off
967 * the shared queue, and does the core dump. This is a
968 * little more complicated than strictly necessary, but it
969 * keeps the signal state that winds up in the core dump
970 * unchanged from the death state, e.g. which thread had
971 * the core-dump signal unblocked.
973 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
974 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
975 p->signal->group_stop_count = 0;
976 p->signal->group_exit_task = t;
979 p->signal->group_stop_count++;
980 signal_wake_up(t, 0);
983 wake_up_process(p->signal->group_exit_task);
988 * The signal is already in the shared-pending queue.
989 * Tell the chosen thread to wake up and dequeue it.
991 signal_wake_up(t, sig == SIGKILL);
996 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1000 assert_spin_locked(&p->sighand->siglock);
1001 handle_stop_signal(sig, p);
1003 /* Short-circuit ignored signals. */
1004 if (sig_ignored(p, sig))
1007 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
1008 /* This is a non-RT signal and we already have one queued. */
1012 * Put this signal on the shared-pending queue, or fail with EAGAIN.
1013 * We always use the shared queue for process-wide signals,
1014 * to avoid several races.
1016 ret = send_signal(sig, info, p, &p->signal->shared_pending);
1020 __group_complete_signal(sig, p);
1025 * Nuke all other threads in the group.
1027 void zap_other_threads(struct task_struct *p)
1029 struct task_struct *t;
1031 p->signal->flags = SIGNAL_GROUP_EXIT;
1032 p->signal->group_stop_count = 0;
1034 if (thread_group_empty(p))
1037 for (t = next_thread(p); t != p; t = next_thread(t)) {
1039 * Don't bother with already dead threads
1045 * We don't want to notify the parent, since we are
1046 * killed as part of a thread group due to another
1047 * thread doing an execve() or similar. So set the
1048 * exit signal to -1 to allow immediate reaping of
1049 * the process. But don't detach the thread group
1052 if (t != p->group_leader)
1053 t->exit_signal = -1;
1055 /* SIGKILL will be handled before any pending SIGSTOP */
1056 sigaddset(&t->pending.signal, SIGKILL);
1057 signal_wake_up(t, 1);
1062 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1064 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1066 struct sighand_struct *sighand;
1069 sighand = rcu_dereference(tsk->sighand);
1070 if (unlikely(sighand == NULL))
1073 spin_lock_irqsave(&sighand->siglock, *flags);
1074 if (likely(sighand == tsk->sighand))
1076 spin_unlock_irqrestore(&sighand->siglock, *flags);
1082 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1084 unsigned long flags;
1087 ret = check_kill_permission(sig, info, p);
1091 if (lock_task_sighand(p, &flags)) {
1092 ret = __group_send_sig_info(sig, info, p);
1093 unlock_task_sighand(p, &flags);
1101 * kill_pg_info() sends a signal to a process group: this is what the tty
1102 * control characters do (^C, ^Z etc)
1105 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1107 struct task_struct *p = NULL;
1108 int retval, success;
1115 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1116 int err = group_send_sig_info(sig, info, p);
1119 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1120 return success ? 0 : retval;
1124 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1128 read_lock(&tasklist_lock);
1129 retval = __kill_pg_info(sig, info, pgrp);
1130 read_unlock(&tasklist_lock);
1136 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1139 int acquired_tasklist_lock = 0;
1140 struct task_struct *p;
1143 if (unlikely(sig_needs_tasklist(sig))) {
1144 read_lock(&tasklist_lock);
1145 acquired_tasklist_lock = 1;
1147 p = find_task_by_pid(pid);
1149 if (p && vx_check(vx_task_xid(p), VX_IDENT))
1150 error = group_send_sig_info(sig, info, p);
1151 if (unlikely(acquired_tasklist_lock))
1152 read_unlock(&tasklist_lock);
1157 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1158 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1159 uid_t uid, uid_t euid, u32 secid)
1162 struct task_struct *p;
1164 if (!valid_signal(sig))
1167 read_lock(&tasklist_lock);
1168 p = find_task_by_pid(pid);
1173 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1174 && (euid != p->suid) && (euid != p->uid)
1175 && (uid != p->suid) && (uid != p->uid)) {
1179 ret = security_task_kill(p, info, sig, secid);
1182 if (sig && p->sighand) {
1183 unsigned long flags;
1184 spin_lock_irqsave(&p->sighand->siglock, flags);
1185 ret = __group_send_sig_info(sig, info, p);
1186 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1189 read_unlock(&tasklist_lock);
1192 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1195 * kill_something_info() interprets pid in interesting ways just like kill(2).
1197 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1198 * is probably wrong. Should make it like BSD or SYSV.
1201 static int kill_something_info(int sig, struct siginfo *info, int pid)
1204 return kill_pg_info(sig, info, process_group(current));
1205 } else if (pid == -1) {
1206 int retval = 0, count = 0;
1207 struct task_struct * p;
1209 read_lock(&tasklist_lock);
1210 for_each_process(p) {
1211 if (vx_check(vx_task_xid(p), VX_ADMIN|VX_IDENT) &&
1212 p->pid > 1 && p->tgid != current->tgid) {
1213 int err = group_send_sig_info(sig, info, p);
1219 read_unlock(&tasklist_lock);
1220 return count ? retval : -ESRCH;
1221 } else if (pid < 0) {
1222 return kill_pg_info(sig, info, -pid);
1224 return kill_proc_info(sig, info, pid);
1229 * These are for backward compatibility with the rest of the kernel source.
1233 * These two are the most common entry points. They send a signal
1234 * just to the specific thread.
1237 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1240 unsigned long flags;
1243 * Make sure legacy kernel users don't send in bad values
1244 * (normal paths check this in check_kill_permission).
1246 if (!valid_signal(sig))
1250 * We need the tasklist lock even for the specific
1251 * thread case (when we don't need to follow the group
1252 * lists) in order to avoid races with "p->sighand"
1253 * going away or changing from under us.
1255 read_lock(&tasklist_lock);
1256 spin_lock_irqsave(&p->sighand->siglock, flags);
1257 ret = specific_send_sig_info(sig, info, p);
1258 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1259 read_unlock(&tasklist_lock);
1263 #define __si_special(priv) \
1264 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1267 send_sig(int sig, struct task_struct *p, int priv)
1269 return send_sig_info(sig, __si_special(priv), p);
1273 * This is the entry point for "process-wide" signals.
1274 * They will go to an appropriate thread in the thread group.
1277 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1280 read_lock(&tasklist_lock);
1281 ret = group_send_sig_info(sig, info, p);
1282 read_unlock(&tasklist_lock);
1287 force_sig(int sig, struct task_struct *p)
1289 force_sig_info(sig, SEND_SIG_PRIV, p);
1293 * When things go south during signal handling, we
1294 * will force a SIGSEGV. And if the signal that caused
1295 * the problem was already a SIGSEGV, we'll want to
1296 * make sure we don't even try to deliver the signal..
1299 force_sigsegv(int sig, struct task_struct *p)
1301 if (sig == SIGSEGV) {
1302 unsigned long flags;
1303 spin_lock_irqsave(&p->sighand->siglock, flags);
1304 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1305 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1307 force_sig(SIGSEGV, p);
1312 kill_pg(pid_t pgrp, int sig, int priv)
1314 return kill_pg_info(sig, __si_special(priv), pgrp);
1318 kill_proc(pid_t pid, int sig, int priv)
1320 return kill_proc_info(sig, __si_special(priv), pid);
1324 * These functions support sending signals using preallocated sigqueue
1325 * structures. This is needed "because realtime applications cannot
1326 * afford to lose notifications of asynchronous events, like timer
1327 * expirations or I/O completions". In the case of Posix Timers
1328 * we allocate the sigqueue structure from the timer_create. If this
1329 * allocation fails we are able to report the failure to the application
1330 * with an EAGAIN error.
1333 struct sigqueue *sigqueue_alloc(void)
1337 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1338 q->flags |= SIGQUEUE_PREALLOC;
1342 void sigqueue_free(struct sigqueue *q)
1344 unsigned long flags;
1345 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1347 * If the signal is still pending remove it from the
1350 if (unlikely(!list_empty(&q->list))) {
1351 spinlock_t *lock = ¤t->sighand->siglock;
1352 read_lock(&tasklist_lock);
1353 spin_lock_irqsave(lock, flags);
1354 if (!list_empty(&q->list))
1355 list_del_init(&q->list);
1356 spin_unlock_irqrestore(lock, flags);
1357 read_unlock(&tasklist_lock);
1359 q->flags &= ~SIGQUEUE_PREALLOC;
1363 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1365 unsigned long flags;
1368 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1371 * The rcu based delayed sighand destroy makes it possible to
1372 * run this without tasklist lock held. The task struct itself
1373 * cannot go away as create_timer did get_task_struct().
1375 * We return -1, when the task is marked exiting, so
1376 * posix_timer_event can redirect it to the group leader
1380 if (!likely(lock_task_sighand(p, &flags))) {
1385 if (unlikely(!list_empty(&q->list))) {
1387 * If an SI_TIMER entry is already queue just increment
1388 * the overrun count.
1390 BUG_ON(q->info.si_code != SI_TIMER);
1391 q->info.si_overrun++;
1394 /* Short-circuit ignored signals. */
1395 if (sig_ignored(p, sig)) {
1400 list_add_tail(&q->list, &p->pending.list);
1401 sigaddset(&p->pending.signal, sig);
1402 if (!sigismember(&p->blocked, sig))
1403 signal_wake_up(p, sig == SIGKILL);
1406 unlock_task_sighand(p, &flags);
1414 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1416 unsigned long flags;
1419 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1421 read_lock(&tasklist_lock);
1422 /* Since it_lock is held, p->sighand cannot be NULL. */
1423 spin_lock_irqsave(&p->sighand->siglock, flags);
1424 handle_stop_signal(sig, p);
1426 /* Short-circuit ignored signals. */
1427 if (sig_ignored(p, sig)) {
1432 if (unlikely(!list_empty(&q->list))) {
1434 * If an SI_TIMER entry is already queue just increment
1435 * the overrun count. Other uses should not try to
1436 * send the signal multiple times.
1438 BUG_ON(q->info.si_code != SI_TIMER);
1439 q->info.si_overrun++;
1444 * Put this signal on the shared-pending queue.
1445 * We always use the shared queue for process-wide signals,
1446 * to avoid several races.
1448 list_add_tail(&q->list, &p->signal->shared_pending.list);
1449 sigaddset(&p->signal->shared_pending.signal, sig);
1451 __group_complete_signal(sig, p);
1453 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1454 read_unlock(&tasklist_lock);
1459 * Wake up any threads in the parent blocked in wait* syscalls.
1461 static inline void __wake_up_parent(struct task_struct *p,
1462 struct task_struct *parent)
1464 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1468 * Let a parent know about the death of a child.
1469 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1472 void do_notify_parent(struct task_struct *tsk, int sig)
1474 struct siginfo info;
1475 unsigned long flags;
1476 struct sighand_struct *psig;
1480 /* do_notify_parent_cldstop should have been called instead. */
1481 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1483 BUG_ON(!tsk->ptrace &&
1484 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1486 info.si_signo = sig;
1488 info.si_pid = tsk->pid;
1489 info.si_uid = tsk->uid;
1491 /* FIXME: find out whether or not this is supposed to be c*time. */
1492 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1493 tsk->signal->utime));
1494 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1495 tsk->signal->stime));
1497 info.si_status = tsk->exit_code & 0x7f;
1498 if (tsk->exit_code & 0x80)
1499 info.si_code = CLD_DUMPED;
1500 else if (tsk->exit_code & 0x7f)
1501 info.si_code = CLD_KILLED;
1503 info.si_code = CLD_EXITED;
1504 info.si_status = tsk->exit_code >> 8;
1507 psig = tsk->parent->sighand;
1508 spin_lock_irqsave(&psig->siglock, flags);
1509 if (!tsk->ptrace && sig == SIGCHLD &&
1510 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1511 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1513 * We are exiting and our parent doesn't care. POSIX.1
1514 * defines special semantics for setting SIGCHLD to SIG_IGN
1515 * or setting the SA_NOCLDWAIT flag: we should be reaped
1516 * automatically and not left for our parent's wait4 call.
1517 * Rather than having the parent do it as a magic kind of
1518 * signal handler, we just set this to tell do_exit that we
1519 * can be cleaned up without becoming a zombie. Note that
1520 * we still call __wake_up_parent in this case, because a
1521 * blocked sys_wait4 might now return -ECHILD.
1523 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1524 * is implementation-defined: we do (if you don't want
1525 * it, just use SIG_IGN instead).
1527 tsk->exit_signal = -1;
1528 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1531 if (valid_signal(sig) && sig > 0)
1532 __group_send_sig_info(sig, &info, tsk->parent);
1533 __wake_up_parent(tsk, tsk->parent);
1534 spin_unlock_irqrestore(&psig->siglock, flags);
1537 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1539 struct siginfo info;
1540 unsigned long flags;
1541 struct task_struct *parent;
1542 struct sighand_struct *sighand;
1544 if (tsk->ptrace & PT_PTRACED)
1545 parent = tsk->parent;
1547 tsk = tsk->group_leader;
1548 parent = tsk->real_parent;
1551 info.si_signo = SIGCHLD;
1553 info.si_pid = tsk->pid;
1554 info.si_uid = tsk->uid;
1556 /* FIXME: find out whether or not this is supposed to be c*time. */
1557 info.si_utime = cputime_to_jiffies(tsk->utime);
1558 info.si_stime = cputime_to_jiffies(tsk->stime);
1563 info.si_status = SIGCONT;
1566 info.si_status = tsk->signal->group_exit_code & 0x7f;
1569 info.si_status = tsk->exit_code & 0x7f;
1575 sighand = parent->sighand;
1576 spin_lock_irqsave(&sighand->siglock, flags);
1577 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1578 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1579 __group_send_sig_info(SIGCHLD, &info, parent);
1581 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1583 __wake_up_parent(tsk, parent);
1584 spin_unlock_irqrestore(&sighand->siglock, flags);
1587 static inline int may_ptrace_stop(void)
1589 if (!likely(current->ptrace & PT_PTRACED))
1592 if (unlikely(current->parent == current->real_parent &&
1593 (current->ptrace & PT_ATTACHED)))
1596 if (unlikely(current->signal == current->parent->signal) &&
1597 unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))
1601 * Are we in the middle of do_coredump?
1602 * If so and our tracer is also part of the coredump stopping
1603 * is a deadlock situation, and pointless because our tracer
1604 * is dead so don't allow us to stop.
1605 * If SIGKILL was already sent before the caller unlocked
1606 * ->siglock we must see ->core_waiters != 0. Otherwise it
1607 * is safe to enter schedule().
1609 if (unlikely(current->mm->core_waiters) &&
1610 unlikely(current->mm == current->parent->mm))
1617 * This must be called with current->sighand->siglock held.
1619 * This should be the path for all ptrace stops.
1620 * We always set current->last_siginfo while stopped here.
1621 * That makes it a way to test a stopped process for
1622 * being ptrace-stopped vs being job-control-stopped.
1624 * If we actually decide not to stop at all because the tracer is gone,
1625 * we leave nostop_code in current->exit_code.
1627 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1630 * If there is a group stop in progress,
1631 * we must participate in the bookkeeping.
1633 if (current->signal->group_stop_count > 0)
1634 --current->signal->group_stop_count;
1636 current->last_siginfo = info;
1637 current->exit_code = exit_code;
1639 /* Let the debugger run. */
1640 set_current_state(TASK_TRACED);
1641 spin_unlock_irq(¤t->sighand->siglock);
1643 read_lock(&tasklist_lock);
1644 if (may_ptrace_stop()) {
1645 do_notify_parent_cldstop(current, CLD_TRAPPED);
1646 read_unlock(&tasklist_lock);
1650 * By the time we got the lock, our tracer went away.
1653 read_unlock(&tasklist_lock);
1654 set_current_state(TASK_RUNNING);
1655 current->exit_code = nostop_code;
1659 * We are back. Now reacquire the siglock before touching
1660 * last_siginfo, so that we are sure to have synchronized with
1661 * any signal-sending on another CPU that wants to examine it.
1663 spin_lock_irq(¤t->sighand->siglock);
1664 current->last_siginfo = NULL;
1667 * Queued signals ignored us while we were stopped for tracing.
1668 * So check for any that we should take before resuming user mode.
1670 recalc_sigpending();
1673 void ptrace_notify(int exit_code)
1677 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1679 memset(&info, 0, sizeof info);
1680 info.si_signo = SIGTRAP;
1681 info.si_code = exit_code;
1682 info.si_pid = current->pid;
1683 info.si_uid = current->uid;
1685 /* Let the debugger run. */
1686 spin_lock_irq(¤t->sighand->siglock);
1687 ptrace_stop(exit_code, 0, &info);
1688 spin_unlock_irq(¤t->sighand->siglock);
1692 finish_stop(int stop_count)
1695 * If there are no other threads in the group, or if there is
1696 * a group stop in progress and we are the last to stop,
1697 * report to the parent. When ptraced, every thread reports itself.
1699 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1700 read_lock(&tasklist_lock);
1701 do_notify_parent_cldstop(current, CLD_STOPPED);
1702 read_unlock(&tasklist_lock);
1707 * Now we don't run again until continued.
1709 current->exit_code = 0;
1713 * This performs the stopping for SIGSTOP and other stop signals.
1714 * We have to stop all threads in the thread group.
1715 * Returns nonzero if we've actually stopped and released the siglock.
1716 * Returns zero if we didn't stop and still hold the siglock.
1718 static int do_signal_stop(int signr)
1720 struct signal_struct *sig = current->signal;
1723 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1726 if (sig->group_stop_count > 0) {
1728 * There is a group stop in progress. We don't need to
1729 * start another one.
1731 stop_count = --sig->group_stop_count;
1734 * There is no group stop already in progress.
1735 * We must initiate one now.
1737 struct task_struct *t;
1739 sig->group_exit_code = signr;
1742 for (t = next_thread(current); t != current; t = next_thread(t))
1744 * Setting state to TASK_STOPPED for a group
1745 * stop is always done with the siglock held,
1746 * so this check has no races.
1748 if (!t->exit_state &&
1749 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1751 signal_wake_up(t, 0);
1753 sig->group_stop_count = stop_count;
1756 if (stop_count == 0)
1757 sig->flags = SIGNAL_STOP_STOPPED;
1758 current->exit_code = sig->group_exit_code;
1759 __set_current_state(TASK_STOPPED);
1761 spin_unlock_irq(¤t->sighand->siglock);
1762 finish_stop(stop_count);
1767 * Do appropriate magic when group_stop_count > 0.
1768 * We return nonzero if we stopped, after releasing the siglock.
1769 * We return zero if we still hold the siglock and should look
1770 * for another signal without checking group_stop_count again.
1772 static int handle_group_stop(void)
1776 if (current->signal->group_exit_task == current) {
1778 * Group stop is so we can do a core dump,
1779 * We are the initiating thread, so get on with it.
1781 current->signal->group_exit_task = NULL;
1785 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1787 * Group stop is so another thread can do a core dump,
1788 * or else we are racing against a death signal.
1789 * Just punt the stop so we can get the next signal.
1794 * There is a group stop in progress. We stop
1795 * without any associated signal being in our queue.
1797 stop_count = --current->signal->group_stop_count;
1798 if (stop_count == 0)
1799 current->signal->flags = SIGNAL_STOP_STOPPED;
1800 current->exit_code = current->signal->group_exit_code;
1801 set_current_state(TASK_STOPPED);
1802 spin_unlock_irq(¤t->sighand->siglock);
1803 finish_stop(stop_count);
1807 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1808 struct pt_regs *regs, void *cookie)
1810 sigset_t *mask = ¤t->blocked;
1816 spin_lock_irq(¤t->sighand->siglock);
1818 struct k_sigaction *ka;
1820 if (unlikely(current->signal->group_stop_count > 0) &&
1821 handle_group_stop())
1824 signr = dequeue_signal(current, mask, info);
1827 break; /* will return 0 */
1829 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1830 ptrace_signal_deliver(regs, cookie);
1832 /* Let the debugger run. */
1833 ptrace_stop(signr, signr, info);
1835 /* We're back. Did the debugger cancel the sig? */
1836 signr = current->exit_code;
1840 current->exit_code = 0;
1842 /* Update the siginfo structure if the signal has
1843 changed. If the debugger wanted something
1844 specific in the siginfo structure then it should
1845 have updated *info via PTRACE_SETSIGINFO. */
1846 if (signr != info->si_signo) {
1847 info->si_signo = signr;
1849 info->si_code = SI_USER;
1850 info->si_pid = current->parent->pid;
1851 info->si_uid = current->parent->uid;
1854 /* If the (new) signal is now blocked, requeue it. */
1855 if (sigismember(¤t->blocked, signr)) {
1856 specific_send_sig_info(signr, info, current);
1861 ka = ¤t->sighand->action[signr-1];
1862 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1864 if (ka->sa.sa_handler != SIG_DFL) {
1865 /* Run the handler. */
1868 if (ka->sa.sa_flags & SA_ONESHOT)
1869 ka->sa.sa_handler = SIG_DFL;
1871 break; /* will return non-zero "signr" value */
1875 * Now we are doing the default action for this signal.
1877 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1880 /* Init gets no signals it doesn't want. */
1881 if (current == child_reaper)
1884 /* virtual init is protected against user signals */
1885 if ((info->si_code == SI_USER) &&
1886 vx_current_initpid(current->pid))
1889 if (sig_kernel_stop(signr)) {
1891 * The default action is to stop all threads in
1892 * the thread group. The job control signals
1893 * do nothing in an orphaned pgrp, but SIGSTOP
1894 * always works. Note that siglock needs to be
1895 * dropped during the call to is_orphaned_pgrp()
1896 * because of lock ordering with tasklist_lock.
1897 * This allows an intervening SIGCONT to be posted.
1898 * We need to check for that and bail out if necessary.
1900 if (signr != SIGSTOP) {
1901 spin_unlock_irq(¤t->sighand->siglock);
1903 /* signals can be posted during this window */
1905 if (is_orphaned_pgrp(process_group(current)))
1908 spin_lock_irq(¤t->sighand->siglock);
1911 if (likely(do_signal_stop(signr))) {
1912 /* It released the siglock. */
1917 * We didn't actually stop, due to a race
1918 * with SIGCONT or something like that.
1923 spin_unlock_irq(¤t->sighand->siglock);
1926 * Anything else is fatal, maybe with a core dump.
1928 current->flags |= PF_SIGNALED;
1929 if (print_fatal_signals)
1930 print_fatal_signal(regs, signr);
1931 if (sig_kernel_coredump(signr)) {
1933 * If it was able to dump core, this kills all
1934 * other threads in the group and synchronizes with
1935 * their demise. If we lost the race with another
1936 * thread getting here, it set group_exit_code
1937 * first and our do_group_exit call below will use
1938 * that value and ignore the one we pass it.
1940 do_coredump((long)signr, signr, regs);
1944 * Death signals, no core dump.
1946 do_group_exit(signr);
1949 spin_unlock_irq(¤t->sighand->siglock);
1953 EXPORT_SYMBOL(recalc_sigpending);
1954 EXPORT_SYMBOL_GPL(dequeue_signal);
1955 EXPORT_SYMBOL(flush_signals);
1956 EXPORT_SYMBOL(force_sig);
1957 EXPORT_SYMBOL(kill_pg);
1958 EXPORT_SYMBOL(kill_proc);
1959 EXPORT_SYMBOL(ptrace_notify);
1960 EXPORT_SYMBOL(send_sig);
1961 EXPORT_SYMBOL(send_sig_info);
1962 EXPORT_SYMBOL(sigprocmask);
1963 EXPORT_SYMBOL(block_all_signals);
1964 EXPORT_SYMBOL(unblock_all_signals);
1968 * System call entry points.
1971 asmlinkage long sys_restart_syscall(void)
1973 struct restart_block *restart = ¤t_thread_info()->restart_block;
1974 return restart->fn(restart);
1977 long do_no_restart_syscall(struct restart_block *param)
1983 * We don't need to get the kernel lock - this is all local to this
1984 * particular thread.. (and that's good, because this is _heavily_
1985 * used by various programs)
1989 * This is also useful for kernel threads that want to temporarily
1990 * (or permanently) block certain signals.
1992 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1993 * interface happily blocks "unblockable" signals like SIGKILL
1996 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2000 spin_lock_irq(¤t->sighand->siglock);
2002 *oldset = current->blocked;
2007 sigorsets(¤t->blocked, ¤t->blocked, set);
2010 signandsets(¤t->blocked, ¤t->blocked, set);
2013 current->blocked = *set;
2018 recalc_sigpending();
2019 spin_unlock_irq(¤t->sighand->siglock);
2025 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2027 int error = -EINVAL;
2028 sigset_t old_set, new_set;
2030 /* XXX: Don't preclude handling different sized sigset_t's. */
2031 if (sigsetsize != sizeof(sigset_t))
2036 if (copy_from_user(&new_set, set, sizeof(*set)))
2038 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2040 error = sigprocmask(how, &new_set, &old_set);
2046 spin_lock_irq(¤t->sighand->siglock);
2047 old_set = current->blocked;
2048 spin_unlock_irq(¤t->sighand->siglock);
2052 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2060 long do_sigpending(void __user *set, unsigned long sigsetsize)
2062 long error = -EINVAL;
2065 if (sigsetsize > sizeof(sigset_t))
2068 spin_lock_irq(¤t->sighand->siglock);
2069 sigorsets(&pending, ¤t->pending.signal,
2070 ¤t->signal->shared_pending.signal);
2071 spin_unlock_irq(¤t->sighand->siglock);
2073 /* Outside the lock because only this thread touches it. */
2074 sigandsets(&pending, ¤t->blocked, &pending);
2077 if (!copy_to_user(set, &pending, sigsetsize))
2085 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2087 return do_sigpending(set, sigsetsize);
2090 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2092 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2096 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2098 if (from->si_code < 0)
2099 return __copy_to_user(to, from, sizeof(siginfo_t))
2102 * If you change siginfo_t structure, please be sure
2103 * this code is fixed accordingly.
2104 * It should never copy any pad contained in the structure
2105 * to avoid security leaks, but must copy the generic
2106 * 3 ints plus the relevant union member.
2108 err = __put_user(from->si_signo, &to->si_signo);
2109 err |= __put_user(from->si_errno, &to->si_errno);
2110 err |= __put_user((short)from->si_code, &to->si_code);
2111 switch (from->si_code & __SI_MASK) {
2113 err |= __put_user(from->si_pid, &to->si_pid);
2114 err |= __put_user(from->si_uid, &to->si_uid);
2117 err |= __put_user(from->si_tid, &to->si_tid);
2118 err |= __put_user(from->si_overrun, &to->si_overrun);
2119 err |= __put_user(from->si_ptr, &to->si_ptr);
2122 err |= __put_user(from->si_band, &to->si_band);
2123 err |= __put_user(from->si_fd, &to->si_fd);
2126 err |= __put_user(from->si_addr, &to->si_addr);
2127 #ifdef __ARCH_SI_TRAPNO
2128 err |= __put_user(from->si_trapno, &to->si_trapno);
2132 err |= __put_user(from->si_pid, &to->si_pid);
2133 err |= __put_user(from->si_uid, &to->si_uid);
2134 err |= __put_user(from->si_status, &to->si_status);
2135 err |= __put_user(from->si_utime, &to->si_utime);
2136 err |= __put_user(from->si_stime, &to->si_stime);
2138 case __SI_RT: /* This is not generated by the kernel as of now. */
2139 case __SI_MESGQ: /* But this is */
2140 err |= __put_user(from->si_pid, &to->si_pid);
2141 err |= __put_user(from->si_uid, &to->si_uid);
2142 err |= __put_user(from->si_ptr, &to->si_ptr);
2144 default: /* this is just in case for now ... */
2145 err |= __put_user(from->si_pid, &to->si_pid);
2146 err |= __put_user(from->si_uid, &to->si_uid);
2155 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2156 siginfo_t __user *uinfo,
2157 const struct timespec __user *uts,
2166 /* XXX: Don't preclude handling different sized sigset_t's. */
2167 if (sigsetsize != sizeof(sigset_t))
2170 if (copy_from_user(&these, uthese, sizeof(these)))
2174 * Invert the set of allowed signals to get those we
2177 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2181 if (copy_from_user(&ts, uts, sizeof(ts)))
2183 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2188 spin_lock_irq(¤t->sighand->siglock);
2189 sig = dequeue_signal(current, &these, &info);
2191 timeout = MAX_SCHEDULE_TIMEOUT;
2193 timeout = (timespec_to_jiffies(&ts)
2194 + (ts.tv_sec || ts.tv_nsec));
2197 /* None ready -- temporarily unblock those we're
2198 * interested while we are sleeping in so that we'll
2199 * be awakened when they arrive. */
2200 current->real_blocked = current->blocked;
2201 sigandsets(¤t->blocked, ¤t->blocked, &these);
2202 recalc_sigpending();
2203 spin_unlock_irq(¤t->sighand->siglock);
2205 timeout = schedule_timeout_interruptible(timeout);
2207 spin_lock_irq(¤t->sighand->siglock);
2208 sig = dequeue_signal(current, &these, &info);
2209 current->blocked = current->real_blocked;
2210 siginitset(¤t->real_blocked, 0);
2211 recalc_sigpending();
2214 spin_unlock_irq(¤t->sighand->siglock);
2219 if (copy_siginfo_to_user(uinfo, &info))
2232 sys_kill(int pid, int sig)
2234 struct siginfo info;
2236 info.si_signo = sig;
2238 info.si_code = SI_USER;
2239 info.si_pid = current->tgid;
2240 info.si_uid = current->uid;
2242 return kill_something_info(sig, &info, pid);
2245 static int do_tkill(int tgid, int pid, int sig)
2248 struct siginfo info;
2249 struct task_struct *p;
2252 info.si_signo = sig;
2254 info.si_code = SI_TKILL;
2255 info.si_pid = current->tgid;
2256 info.si_uid = current->uid;
2258 read_lock(&tasklist_lock);
2259 p = find_task_by_pid(pid);
2260 if (p && (tgid <= 0 || p->tgid == tgid)) {
2261 error = check_kill_permission(sig, &info, p);
2263 * The null signal is a permissions and process existence
2264 * probe. No signal is actually delivered.
2266 if (!error && sig && p->sighand) {
2267 spin_lock_irq(&p->sighand->siglock);
2268 handle_stop_signal(sig, p);
2269 error = specific_send_sig_info(sig, &info, p);
2270 spin_unlock_irq(&p->sighand->siglock);
2273 read_unlock(&tasklist_lock);
2279 * sys_tgkill - send signal to one specific thread
2280 * @tgid: the thread group ID of the thread
2281 * @pid: the PID of the thread
2282 * @sig: signal to be sent
2284 * This syscall also checks the tgid and returns -ESRCH even if the PID
2285 * exists but it's not belonging to the target process anymore. This
2286 * method solves the problem of threads exiting and PIDs getting reused.
2288 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2290 /* This is only valid for single tasks */
2291 if (pid <= 0 || tgid <= 0)
2294 return do_tkill(tgid, pid, sig);
2298 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2301 sys_tkill(int pid, int sig)
2303 /* This is only valid for single tasks */
2307 return do_tkill(0, pid, sig);
2311 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2315 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2318 /* Not even root can pretend to send signals from the kernel.
2319 Nor can they impersonate a kill(), which adds source info. */
2320 if (info.si_code >= 0)
2322 info.si_signo = sig;
2324 /* POSIX.1b doesn't mention process groups. */
2325 return kill_proc_info(sig, &info, pid);
2328 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2330 struct k_sigaction *k;
2333 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2336 k = ¤t->sighand->action[sig-1];
2338 spin_lock_irq(¤t->sighand->siglock);
2339 if (signal_pending(current)) {
2341 * If there might be a fatal signal pending on multiple
2342 * threads, make sure we take it before changing the action.
2344 spin_unlock_irq(¤t->sighand->siglock);
2345 return -ERESTARTNOINTR;
2352 sigdelsetmask(&act->sa.sa_mask,
2353 sigmask(SIGKILL) | sigmask(SIGSTOP));
2357 * "Setting a signal action to SIG_IGN for a signal that is
2358 * pending shall cause the pending signal to be discarded,
2359 * whether or not it is blocked."
2361 * "Setting a signal action to SIG_DFL for a signal that is
2362 * pending and whose default action is to ignore the signal
2363 * (for example, SIGCHLD), shall cause the pending signal to
2364 * be discarded, whether or not it is blocked"
2366 if (act->sa.sa_handler == SIG_IGN ||
2367 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2368 struct task_struct *t = current;
2370 sigaddset(&mask, sig);
2371 rm_from_queue_full(&mask, &t->signal->shared_pending);
2373 rm_from_queue_full(&mask, &t->pending);
2374 recalc_sigpending_tsk(t);
2376 } while (t != current);
2380 spin_unlock_irq(¤t->sighand->siglock);
2385 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2391 oss.ss_sp = (void __user *) current->sas_ss_sp;
2392 oss.ss_size = current->sas_ss_size;
2393 oss.ss_flags = sas_ss_flags(sp);
2402 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2403 || __get_user(ss_sp, &uss->ss_sp)
2404 || __get_user(ss_flags, &uss->ss_flags)
2405 || __get_user(ss_size, &uss->ss_size))
2409 if (on_sig_stack(sp))
2415 * Note - this code used to test ss_flags incorrectly
2416 * old code may have been written using ss_flags==0
2417 * to mean ss_flags==SS_ONSTACK (as this was the only
2418 * way that worked) - this fix preserves that older
2421 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2424 if (ss_flags == SS_DISABLE) {
2429 if (ss_size < MINSIGSTKSZ)
2433 current->sas_ss_sp = (unsigned long) ss_sp;
2434 current->sas_ss_size = ss_size;
2439 if (copy_to_user(uoss, &oss, sizeof(oss)))
2448 #ifdef __ARCH_WANT_SYS_SIGPENDING
2451 sys_sigpending(old_sigset_t __user *set)
2453 return do_sigpending(set, sizeof(*set));
2458 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2459 /* Some platforms have their own version with special arguments others
2460 support only sys_rt_sigprocmask. */
2463 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2466 old_sigset_t old_set, new_set;
2470 if (copy_from_user(&new_set, set, sizeof(*set)))
2472 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2474 spin_lock_irq(¤t->sighand->siglock);
2475 old_set = current->blocked.sig[0];
2483 sigaddsetmask(¤t->blocked, new_set);
2486 sigdelsetmask(¤t->blocked, new_set);
2489 current->blocked.sig[0] = new_set;
2493 recalc_sigpending();
2494 spin_unlock_irq(¤t->sighand->siglock);
2500 old_set = current->blocked.sig[0];
2503 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2510 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2512 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2514 sys_rt_sigaction(int sig,
2515 const struct sigaction __user *act,
2516 struct sigaction __user *oact,
2519 struct k_sigaction new_sa, old_sa;
2522 /* XXX: Don't preclude handling different sized sigset_t's. */
2523 if (sigsetsize != sizeof(sigset_t))
2527 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2531 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2534 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2540 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2542 #ifdef __ARCH_WANT_SYS_SGETMASK
2545 * For backwards compatibility. Functionality superseded by sigprocmask.
2551 return current->blocked.sig[0];
2555 sys_ssetmask(int newmask)
2559 spin_lock_irq(¤t->sighand->siglock);
2560 old = current->blocked.sig[0];
2562 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2564 recalc_sigpending();
2565 spin_unlock_irq(¤t->sighand->siglock);
2569 #endif /* __ARCH_WANT_SGETMASK */
2571 #ifdef __ARCH_WANT_SYS_SIGNAL
2573 * For backwards compatibility. Functionality superseded by sigaction.
2575 asmlinkage unsigned long
2576 sys_signal(int sig, __sighandler_t handler)
2578 struct k_sigaction new_sa, old_sa;
2581 new_sa.sa.sa_handler = handler;
2582 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2583 sigemptyset(&new_sa.sa.sa_mask);
2585 ret = do_sigaction(sig, &new_sa, &old_sa);
2587 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2589 #endif /* __ARCH_WANT_SYS_SIGNAL */
2591 #ifdef __ARCH_WANT_SYS_PAUSE
2596 current->state = TASK_INTERRUPTIBLE;
2598 return -ERESTARTNOHAND;
2603 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2604 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2608 /* XXX: Don't preclude handling different sized sigset_t's. */
2609 if (sigsetsize != sizeof(sigset_t))
2612 if (copy_from_user(&newset, unewset, sizeof(newset)))
2614 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2616 spin_lock_irq(¤t->sighand->siglock);
2617 current->saved_sigmask = current->blocked;
2618 current->blocked = newset;
2619 recalc_sigpending();
2620 spin_unlock_irq(¤t->sighand->siglock);
2622 current->state = TASK_INTERRUPTIBLE;
2624 set_thread_flag(TIF_RESTORE_SIGMASK);
2625 return -ERESTARTNOHAND;
2627 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2629 void __init signals_init(void)
2632 kmem_cache_create("sigqueue",
2633 sizeof(struct sigqueue),
2634 __alignof__(struct sigqueue),
2635 SLAB_PANIC, NULL, NULL);