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() */
31 #include <linux/vs_base.h>
34 * SLAB caches for signal bits.
37 static kmem_cache_t *sigqueue_cachep;
40 * In POSIX a signal is sent either to a specific thread (Linux task)
41 * or to the process as a whole (Linux thread group). How the signal
42 * is sent determines whether it's to one thread or the whole group,
43 * which determines which signal mask(s) are involved in blocking it
44 * from being delivered until later. When the signal is delivered,
45 * either it's caught or ignored by a user handler or it has a default
46 * effect that applies to the whole thread group (POSIX process).
48 * The possible effects an unblocked signal set to SIG_DFL can have are:
49 * ignore - Nothing Happens
50 * terminate - kill the process, i.e. all threads in the group,
51 * similar to exit_group. The group leader (only) reports
52 * WIFSIGNALED status to its parent.
53 * coredump - write a core dump file describing all threads using
54 * the same mm and then kill all those threads
55 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
57 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
58 * Other signals when not blocked and set to SIG_DFL behaves as follows.
59 * The job control signals also have other special effects.
61 * +--------------------+------------------+
62 * | POSIX signal | default action |
63 * +--------------------+------------------+
64 * | SIGHUP | terminate |
65 * | SIGINT | terminate |
66 * | SIGQUIT | coredump |
67 * | SIGILL | coredump |
68 * | SIGTRAP | coredump |
69 * | SIGABRT/SIGIOT | coredump |
70 * | SIGBUS | coredump |
71 * | SIGFPE | coredump |
72 * | SIGKILL | terminate(+) |
73 * | SIGUSR1 | terminate |
74 * | SIGSEGV | coredump |
75 * | SIGUSR2 | terminate |
76 * | SIGPIPE | terminate |
77 * | SIGALRM | terminate |
78 * | SIGTERM | terminate |
79 * | SIGCHLD | ignore |
80 * | SIGCONT | ignore(*) |
81 * | SIGSTOP | stop(*)(+) |
82 * | SIGTSTP | stop(*) |
83 * | SIGTTIN | stop(*) |
84 * | SIGTTOU | stop(*) |
86 * | SIGXCPU | coredump |
87 * | SIGXFSZ | coredump |
88 * | SIGVTALRM | terminate |
89 * | SIGPROF | terminate |
90 * | SIGPOLL/SIGIO | terminate |
91 * | SIGSYS/SIGUNUSED | coredump |
92 * | SIGSTKFLT | terminate |
93 * | SIGWINCH | ignore |
94 * | SIGPWR | terminate |
95 * | SIGRTMIN-SIGRTMAX | terminate |
96 * +--------------------+------------------+
97 * | non-POSIX signal | default action |
98 * +--------------------+------------------+
99 * | SIGEMT | coredump |
100 * +--------------------+------------------+
102 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
103 * (*) Special job control effects:
104 * When SIGCONT is sent, it resumes the process (all threads in the group)
105 * from TASK_STOPPED state and also clears any pending/queued stop signals
106 * (any of those marked with "stop(*)"). This happens regardless of blocking,
107 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
108 * any pending/queued SIGCONT signals; this happens regardless of blocking,
109 * catching, or ignored the stop signal, though (except for SIGSTOP) the
110 * default action of stopping the process may happen later or never.
114 #define M_SIGEMT M(SIGEMT)
119 #if SIGRTMIN > BITS_PER_LONG
120 #define M(sig) (1ULL << ((sig)-1))
122 #define M(sig) (1UL << ((sig)-1))
124 #define T(sig, mask) (M(sig) & (mask))
126 #define SIG_KERNEL_ONLY_MASK (\
127 M(SIGKILL) | M(SIGSTOP) )
129 #define SIG_KERNEL_STOP_MASK (\
130 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
132 #define SIG_KERNEL_COREDUMP_MASK (\
133 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
134 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
135 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
137 #define SIG_KERNEL_IGNORE_MASK (\
138 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
140 #define sig_kernel_only(sig) \
141 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
142 #define sig_kernel_coredump(sig) \
143 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
144 #define sig_kernel_ignore(sig) \
145 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
146 #define sig_kernel_stop(sig) \
147 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
149 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
151 #define sig_user_defined(t, signr) \
152 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
153 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
155 #define sig_fatal(t, signr) \
156 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
157 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
159 static int sig_ignored(struct task_struct *t, int sig)
161 void __user * handler;
164 * Tracers always want to know about signals..
166 if (t->ptrace & PT_PTRACED)
170 * Blocked signals are never ignored, since the
171 * signal handler may change by the time it is
174 if (sigismember(&t->blocked, sig))
177 /* Is it explicitly or implicitly ignored? */
178 handler = t->sighand->action[sig-1].sa.sa_handler;
179 return handler == SIG_IGN ||
180 (handler == SIG_DFL && sig_kernel_ignore(sig));
184 * Re-calculate pending state from the set of locally pending
185 * signals, globally pending signals, and blocked signals.
187 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
192 switch (_NSIG_WORDS) {
194 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
195 ready |= signal->sig[i] &~ blocked->sig[i];
198 case 4: ready = signal->sig[3] &~ blocked->sig[3];
199 ready |= signal->sig[2] &~ blocked->sig[2];
200 ready |= signal->sig[1] &~ blocked->sig[1];
201 ready |= signal->sig[0] &~ blocked->sig[0];
204 case 2: ready = signal->sig[1] &~ blocked->sig[1];
205 ready |= signal->sig[0] &~ blocked->sig[0];
208 case 1: ready = signal->sig[0] &~ blocked->sig[0];
213 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
215 fastcall void recalc_sigpending_tsk(struct task_struct *t)
217 if (t->signal->group_stop_count > 0 ||
219 PENDING(&t->pending, &t->blocked) ||
220 PENDING(&t->signal->shared_pending, &t->blocked))
221 set_tsk_thread_flag(t, TIF_SIGPENDING);
223 clear_tsk_thread_flag(t, TIF_SIGPENDING);
226 void recalc_sigpending(void)
228 recalc_sigpending_tsk(current);
231 /* Given the mask, find the first available signal that should be serviced. */
234 next_signal(struct sigpending *pending, sigset_t *mask)
236 unsigned long i, *s, *m, x;
239 s = pending->signal.sig;
241 switch (_NSIG_WORDS) {
243 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
244 if ((x = *s &~ *m) != 0) {
245 sig = ffz(~x) + i*_NSIG_BPW + 1;
250 case 2: if ((x = s[0] &~ m[0]) != 0)
252 else if ((x = s[1] &~ m[1]) != 0)
259 case 1: if ((x = *s &~ *m) != 0)
267 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
270 struct sigqueue *q = NULL;
272 atomic_inc(&t->user->sigpending);
273 if (override_rlimit ||
274 atomic_read(&t->user->sigpending) <=
275 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
276 q = kmem_cache_alloc(sigqueue_cachep, flags);
277 if (unlikely(q == NULL)) {
278 atomic_dec(&t->user->sigpending);
280 INIT_LIST_HEAD(&q->list);
282 q->user = get_uid(t->user);
287 static void __sigqueue_free(struct sigqueue *q)
289 if (q->flags & SIGQUEUE_PREALLOC)
291 atomic_dec(&q->user->sigpending);
293 kmem_cache_free(sigqueue_cachep, q);
296 void flush_sigqueue(struct sigpending *queue)
300 sigemptyset(&queue->signal);
301 while (!list_empty(&queue->list)) {
302 q = list_entry(queue->list.next, struct sigqueue , list);
303 list_del_init(&q->list);
309 * Flush all pending signals for a task.
311 void flush_signals(struct task_struct *t)
315 spin_lock_irqsave(&t->sighand->siglock, flags);
316 clear_tsk_thread_flag(t,TIF_SIGPENDING);
317 flush_sigqueue(&t->pending);
318 flush_sigqueue(&t->signal->shared_pending);
319 spin_unlock_irqrestore(&t->sighand->siglock, flags);
323 * Flush all handlers for a task.
327 flush_signal_handlers(struct task_struct *t, int force_default)
330 struct k_sigaction *ka = &t->sighand->action[0];
331 for (i = _NSIG ; i != 0 ; i--) {
332 if (force_default || ka->sa.sa_handler != SIG_IGN)
333 ka->sa.sa_handler = SIG_DFL;
335 sigemptyset(&ka->sa.sa_mask);
340 EXPORT_SYMBOL_GPL(flush_signal_handlers);
342 /* Notify the system that a driver wants to block all signals for this
343 * process, and wants to be notified if any signals at all were to be
344 * sent/acted upon. If the notifier routine returns non-zero, then the
345 * signal will be acted upon after all. If the notifier routine returns 0,
346 * then then signal will be blocked. Only one block per process is
347 * allowed. priv is a pointer to private data that the notifier routine
348 * can use to determine if the signal should be blocked or not. */
351 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
355 spin_lock_irqsave(¤t->sighand->siglock, flags);
356 current->notifier_mask = mask;
357 current->notifier_data = priv;
358 current->notifier = notifier;
359 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
362 /* Notify the system that blocking has ended. */
365 unblock_all_signals(void)
369 spin_lock_irqsave(¤t->sighand->siglock, flags);
370 current->notifier = NULL;
371 current->notifier_data = NULL;
373 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
376 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
378 struct sigqueue *q, *first = NULL;
379 int still_pending = 0;
381 if (unlikely(!sigismember(&list->signal, sig)))
385 * Collect the siginfo appropriate to this signal. Check if
386 * there is another siginfo for the same signal.
388 list_for_each_entry(q, &list->list, list) {
389 if (q->info.si_signo == sig) {
398 list_del_init(&first->list);
399 copy_siginfo(info, &first->info);
400 __sigqueue_free(first);
402 sigdelset(&list->signal, sig);
405 /* Ok, it wasn't in the queue. This must be
406 a fast-pathed signal or we must have been
407 out of queue space. So zero out the info.
409 sigdelset(&list->signal, sig);
410 info->si_signo = sig;
419 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
424 sig = next_signal(pending, mask);
426 if (current->notifier) {
427 if (sigismember(current->notifier_mask, sig)) {
428 if (!(current->notifier)(current->notifier_data)) {
429 clear_thread_flag(TIF_SIGPENDING);
435 if (!collect_signal(sig, pending, info))
445 * Dequeue a signal and return the element to the caller, which is
446 * expected to free it.
448 * All callers have to hold the siglock.
450 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
452 int signr = __dequeue_signal(&tsk->pending, mask, info);
454 signr = __dequeue_signal(&tsk->signal->shared_pending,
456 if (signr && unlikely(sig_kernel_stop(signr))) {
458 * Set a marker that we have dequeued a stop signal. Our
459 * caller might release the siglock and then the pending
460 * stop signal it is about to process is no longer in the
461 * pending bitmasks, but must still be cleared by a SIGCONT
462 * (and overruled by a SIGKILL). So those cases clear this
463 * shared flag after we've set it. Note that this flag may
464 * remain set after the signal we return is ignored or
465 * handled. That doesn't matter because its only purpose
466 * is to alert stop-signal processing code when another
467 * processor has come along and cleared the flag.
469 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
470 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
473 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
474 info->si_sys_private){
476 * Release the siglock to ensure proper locking order
477 * of timer locks outside of siglocks. Note, we leave
478 * irqs disabled here, since the posix-timers code is
479 * about to disable them again anyway.
481 spin_unlock(&tsk->sighand->siglock);
482 do_schedule_next_timer(info);
483 spin_lock(&tsk->sighand->siglock);
489 * Tell a process that it has a new active signal..
491 * NOTE! we rely on the previous spin_lock to
492 * lock interrupts for us! We can only be called with
493 * "siglock" held, and the local interrupt must
494 * have been disabled when that got acquired!
496 * No need to set need_resched since signal event passing
497 * goes through ->blocked
499 void signal_wake_up(struct task_struct *t, int resume)
503 set_tsk_thread_flag(t, TIF_SIGPENDING);
506 * For SIGKILL, we want to wake it up in the stopped/traced case.
507 * We don't check t->state here because there is a race with it
508 * executing another processor and just now entering stopped state.
509 * By using wake_up_state, we ensure the process will wake up and
510 * handle its death signal.
512 mask = TASK_INTERRUPTIBLE;
514 mask |= TASK_STOPPED | TASK_TRACED;
515 if (!wake_up_state(t, mask))
520 * Remove signals in mask from the pending set and queue.
521 * Returns 1 if any signals were found.
523 * All callers must be holding the siglock.
525 * This version takes a sigset mask and looks at all signals,
526 * not just those in the first mask word.
528 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
530 struct sigqueue *q, *n;
533 sigandsets(&m, mask, &s->signal);
534 if (sigisemptyset(&m))
537 signandsets(&s->signal, &s->signal, mask);
538 list_for_each_entry_safe(q, n, &s->list, list) {
539 if (sigismember(mask, q->info.si_signo)) {
540 list_del_init(&q->list);
547 * Remove signals in mask from the pending set and queue.
548 * Returns 1 if any signals were found.
550 * All callers must be holding the siglock.
552 static int rm_from_queue(unsigned long mask, struct sigpending *s)
554 struct sigqueue *q, *n;
556 if (!sigtestsetmask(&s->signal, mask))
559 sigdelsetmask(&s->signal, mask);
560 list_for_each_entry_safe(q, n, &s->list, list) {
561 if (q->info.si_signo < SIGRTMIN &&
562 (mask & sigmask(q->info.si_signo))) {
563 list_del_init(&q->list);
571 * Bad permissions for sending the signal
573 static int check_kill_permission(int sig, struct siginfo *info,
574 struct task_struct *t)
579 if (!valid_signal(sig))
582 user = ((info == SEND_SIG_NOINFO) ||
583 (!is_si_special(info) && SI_FROMUSER(info)));
586 if (user && ((sig != SIGCONT) ||
587 (current->signal->session != t->signal->session))
588 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
589 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
590 && !capable(CAP_KILL))
594 if (user && !vx_check(vx_task_xid(t), VX_ADMIN|VX_IDENT))
597 error = security_task_kill(t, info, sig, 0);
599 audit_signal_info(sig, t); /* Let audit system see the signal */
604 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
607 * Handle magic process-wide effects of stop/continue signals.
608 * Unlike the signal actions, these happen immediately at signal-generation
609 * time regardless of blocking, ignoring, or handling. This does the
610 * actual continuing for SIGCONT, but not the actual stopping for stop
611 * signals. The process stop is done as a signal action for SIG_DFL.
613 static void handle_stop_signal(int sig, struct task_struct *p)
615 struct task_struct *t;
617 if (p->signal->flags & SIGNAL_GROUP_EXIT)
619 * The process is in the middle of dying already.
623 if (sig_kernel_stop(sig)) {
625 * This is a stop signal. Remove SIGCONT from all queues.
627 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
630 rm_from_queue(sigmask(SIGCONT), &t->pending);
633 } else if (sig == SIGCONT) {
635 * Remove all stop signals from all queues,
636 * and wake all threads.
638 if (unlikely(p->signal->group_stop_count > 0)) {
640 * There was a group stop in progress. We'll
641 * pretend it finished before we got here. We are
642 * obliged to report it to the parent: if the
643 * SIGSTOP happened "after" this SIGCONT, then it
644 * would have cleared this pending SIGCONT. If it
645 * happened "before" this SIGCONT, then the parent
646 * got the SIGCHLD about the stop finishing before
647 * the continue happened. We do the notification
648 * now, and it's as if the stop had finished and
649 * the SIGCHLD was pending on entry to this kill.
651 p->signal->group_stop_count = 0;
652 p->signal->flags = SIGNAL_STOP_CONTINUED;
653 spin_unlock(&p->sighand->siglock);
654 do_notify_parent_cldstop(p, CLD_STOPPED);
655 spin_lock(&p->sighand->siglock);
657 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
661 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
664 * If there is a handler for SIGCONT, we must make
665 * sure that no thread returns to user mode before
666 * we post the signal, in case it was the only
667 * thread eligible to run the signal handler--then
668 * it must not do anything between resuming and
669 * running the handler. With the TIF_SIGPENDING
670 * flag set, the thread will pause and acquire the
671 * siglock that we hold now and until we've queued
672 * the pending signal.
674 * Wake up the stopped thread _after_ setting
677 state = TASK_STOPPED;
678 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
679 set_tsk_thread_flag(t, TIF_SIGPENDING);
680 state |= TASK_INTERRUPTIBLE;
682 wake_up_state(t, state);
687 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
689 * We were in fact stopped, and are now continued.
690 * Notify the parent with CLD_CONTINUED.
692 p->signal->flags = SIGNAL_STOP_CONTINUED;
693 p->signal->group_exit_code = 0;
694 spin_unlock(&p->sighand->siglock);
695 do_notify_parent_cldstop(p, CLD_CONTINUED);
696 spin_lock(&p->sighand->siglock);
699 * We are not stopped, but there could be a stop
700 * signal in the middle of being processed after
701 * being removed from the queue. Clear that too.
703 p->signal->flags = 0;
705 } else if (sig == SIGKILL) {
707 * Make sure that any pending stop signal already dequeued
708 * is undone by the wakeup for SIGKILL.
710 p->signal->flags = 0;
714 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
715 struct sigpending *signals)
717 struct sigqueue * q = NULL;
721 * fast-pathed signals for kernel-internal things like SIGSTOP
724 if (info == SEND_SIG_FORCED)
727 /* Real-time signals must be queued if sent by sigqueue, or
728 some other real-time mechanism. It is implementation
729 defined whether kill() does so. We attempt to do so, on
730 the principle of least surprise, but since kill is not
731 allowed to fail with EAGAIN when low on memory we just
732 make sure at least one signal gets delivered and don't
733 pass on the info struct. */
735 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
736 (is_si_special(info) ||
737 info->si_code >= 0)));
739 list_add_tail(&q->list, &signals->list);
740 switch ((unsigned long) info) {
741 case (unsigned long) SEND_SIG_NOINFO:
742 q->info.si_signo = sig;
743 q->info.si_errno = 0;
744 q->info.si_code = SI_USER;
745 q->info.si_pid = current->pid;
746 q->info.si_uid = current->uid;
748 case (unsigned long) SEND_SIG_PRIV:
749 q->info.si_signo = sig;
750 q->info.si_errno = 0;
751 q->info.si_code = SI_KERNEL;
756 copy_siginfo(&q->info, info);
759 } else if (!is_si_special(info)) {
760 if (sig >= SIGRTMIN && info->si_code != SI_USER)
762 * Queue overflow, abort. We may abort if the signal was rt
763 * and sent by user using something other than kill().
769 sigaddset(&signals->signal, sig);
773 #define LEGACY_QUEUE(sigptr, sig) \
774 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
776 int print_fatal_signals = 0;
778 static void print_fatal_signal(struct pt_regs *regs, int signr)
780 printk("%s/%d: potentially unexpected fatal signal %d.\n",
781 current->comm, current->pid, signr);
784 printk("code at %08lx: ", regs->eip);
787 for (i = 0; i < 16; i++) {
790 __get_user(insn, (unsigned char *)(regs->eip + i));
791 printk("%02x ", insn);
799 static int __init setup_print_fatal_signals(char *str)
801 get_option (&str, &print_fatal_signals);
806 __setup("print-fatal-signals=", setup_print_fatal_signals);
809 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
813 BUG_ON(!irqs_disabled());
814 assert_spin_locked(&t->sighand->siglock);
816 /* Short-circuit ignored signals. */
817 if (sig_ignored(t, sig))
820 /* Support queueing exactly one non-rt signal, so that we
821 can get more detailed information about the cause of
823 if (LEGACY_QUEUE(&t->pending, sig))
826 ret = send_signal(sig, info, t, &t->pending);
827 if (!ret && !sigismember(&t->blocked, sig))
828 signal_wake_up(t, sig == SIGKILL);
834 * Force a signal that the process can't ignore: if necessary
835 * we unblock the signal and change any SIG_IGN to SIG_DFL.
837 * Note: If we unblock the signal, we always reset it to SIG_DFL,
838 * since we do not want to have a signal handler that was blocked
839 * be invoked when user space had explicitly blocked it.
841 * We don't want to have recursive SIGSEGV's etc, for example.
844 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
846 unsigned long int flags;
847 int ret, blocked, ignored;
848 struct k_sigaction *action;
850 spin_lock_irqsave(&t->sighand->siglock, flags);
851 action = &t->sighand->action[sig-1];
852 ignored = action->sa.sa_handler == SIG_IGN;
853 blocked = sigismember(&t->blocked, sig);
854 if (blocked || ignored) {
855 action->sa.sa_handler = SIG_DFL;
857 sigdelset(&t->blocked, sig);
858 recalc_sigpending_tsk(t);
861 ret = specific_send_sig_info(sig, info, t);
862 spin_unlock_irqrestore(&t->sighand->siglock, flags);
868 force_sig_specific(int sig, struct task_struct *t)
870 force_sig_info(sig, SEND_SIG_FORCED, t);
874 * Test if P wants to take SIG. After we've checked all threads with this,
875 * it's equivalent to finding no threads not blocking SIG. Any threads not
876 * blocking SIG were ruled out because they are not running and already
877 * have pending signals. Such threads will dequeue from the shared queue
878 * as soon as they're available, so putting the signal on the shared queue
879 * will be equivalent to sending it to one such thread.
881 static inline int wants_signal(int sig, struct task_struct *p)
883 if (sigismember(&p->blocked, sig))
885 if (p->flags & PF_EXITING)
889 if (p->state & (TASK_STOPPED | TASK_TRACED))
891 return task_curr(p) || !signal_pending(p);
895 __group_complete_signal(int sig, struct task_struct *p)
897 struct task_struct *t;
900 * Now find a thread we can wake up to take the signal off the queue.
902 * If the main thread wants the signal, it gets first crack.
903 * Probably the least surprising to the average bear.
905 if (wants_signal(sig, p))
907 else if (thread_group_empty(p))
909 * There is just one thread and it does not need to be woken.
910 * It will dequeue unblocked signals before it runs again.
915 * Otherwise try to find a suitable thread.
917 t = p->signal->curr_target;
919 /* restart balancing at this thread */
920 t = p->signal->curr_target = p;
922 while (!wants_signal(sig, t)) {
924 if (t == p->signal->curr_target)
926 * No thread needs to be woken.
927 * Any eligible threads will see
928 * the signal in the queue soon.
932 p->signal->curr_target = t;
936 * Found a killable thread. If the signal will be fatal,
937 * then start taking the whole group down immediately.
939 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
940 !sigismember(&t->real_blocked, sig) &&
941 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
943 * This signal will be fatal to the whole group.
945 if (!sig_kernel_coredump(sig)) {
947 * Start a group exit and wake everybody up.
948 * This way we don't have other threads
949 * running and doing things after a slower
950 * thread has the fatal signal pending.
952 p->signal->flags = SIGNAL_GROUP_EXIT;
953 p->signal->group_exit_code = sig;
954 p->signal->group_stop_count = 0;
957 sigaddset(&t->pending.signal, SIGKILL);
958 signal_wake_up(t, 1);
965 * There will be a core dump. We make all threads other
966 * than the chosen one go into a group stop so that nothing
967 * happens until it gets scheduled, takes the signal off
968 * the shared queue, and does the core dump. This is a
969 * little more complicated than strictly necessary, but it
970 * keeps the signal state that winds up in the core dump
971 * unchanged from the death state, e.g. which thread had
972 * the core-dump signal unblocked.
974 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
975 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
976 p->signal->group_stop_count = 0;
977 p->signal->group_exit_task = t;
980 p->signal->group_stop_count++;
981 signal_wake_up(t, 0);
984 wake_up_process(p->signal->group_exit_task);
989 * The signal is already in the shared-pending queue.
990 * Tell the chosen thread to wake up and dequeue it.
992 signal_wake_up(t, sig == SIGKILL);
997 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1001 assert_spin_locked(&p->sighand->siglock);
1002 handle_stop_signal(sig, p);
1004 /* Short-circuit ignored signals. */
1005 if (sig_ignored(p, sig))
1008 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
1009 /* This is a non-RT signal and we already have one queued. */
1013 * Put this signal on the shared-pending queue, or fail with EAGAIN.
1014 * We always use the shared queue for process-wide signals,
1015 * to avoid several races.
1017 ret = send_signal(sig, info, p, &p->signal->shared_pending);
1021 __group_complete_signal(sig, p);
1026 * Nuke all other threads in the group.
1028 void zap_other_threads(struct task_struct *p)
1030 struct task_struct *t;
1032 p->signal->flags = SIGNAL_GROUP_EXIT;
1033 p->signal->group_stop_count = 0;
1035 if (thread_group_empty(p))
1038 for (t = next_thread(p); t != p; t = next_thread(t)) {
1040 * Don't bother with already dead threads
1046 * We don't want to notify the parent, since we are
1047 * killed as part of a thread group due to another
1048 * thread doing an execve() or similar. So set the
1049 * exit signal to -1 to allow immediate reaping of
1050 * the process. But don't detach the thread group
1053 if (t != p->group_leader)
1054 t->exit_signal = -1;
1056 /* SIGKILL will be handled before any pending SIGSTOP */
1057 sigaddset(&t->pending.signal, SIGKILL);
1058 signal_wake_up(t, 1);
1063 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1065 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1067 struct sighand_struct *sighand;
1070 sighand = rcu_dereference(tsk->sighand);
1071 if (unlikely(sighand == NULL))
1074 spin_lock_irqsave(&sighand->siglock, *flags);
1075 if (likely(sighand == tsk->sighand))
1077 spin_unlock_irqrestore(&sighand->siglock, *flags);
1083 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1085 unsigned long flags;
1088 ret = check_kill_permission(sig, info, p);
1092 if (lock_task_sighand(p, &flags)) {
1093 ret = __group_send_sig_info(sig, info, p);
1094 unlock_task_sighand(p, &flags);
1102 * kill_pg_info() sends a signal to a process group: this is what the tty
1103 * control characters do (^C, ^Z etc)
1106 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1108 struct task_struct *p = NULL;
1109 int retval, success;
1116 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1117 int err = group_send_sig_info(sig, info, p);
1120 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1121 return success ? 0 : retval;
1125 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1129 read_lock(&tasklist_lock);
1130 retval = __kill_pg_info(sig, info, pgrp);
1131 read_unlock(&tasklist_lock);
1137 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1140 int acquired_tasklist_lock = 0;
1141 struct task_struct *p;
1144 if (unlikely(sig_needs_tasklist(sig))) {
1145 read_lock(&tasklist_lock);
1146 acquired_tasklist_lock = 1;
1148 p = find_task_by_pid(pid);
1150 if (p && vx_check(vx_task_xid(p), VX_IDENT))
1151 error = group_send_sig_info(sig, info, p);
1152 if (unlikely(acquired_tasklist_lock))
1153 read_unlock(&tasklist_lock);
1158 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1159 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1160 uid_t uid, uid_t euid, u32 secid)
1163 struct task_struct *p;
1165 if (!valid_signal(sig))
1168 read_lock(&tasklist_lock);
1169 p = find_task_by_pid(pid);
1174 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1175 && (euid != p->suid) && (euid != p->uid)
1176 && (uid != p->suid) && (uid != p->uid)) {
1180 ret = security_task_kill(p, info, sig, secid);
1183 if (sig && p->sighand) {
1184 unsigned long flags;
1185 spin_lock_irqsave(&p->sighand->siglock, flags);
1186 ret = __group_send_sig_info(sig, info, p);
1187 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1190 read_unlock(&tasklist_lock);
1193 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1196 * kill_something_info() interprets pid in interesting ways just like kill(2).
1198 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1199 * is probably wrong. Should make it like BSD or SYSV.
1202 static int kill_something_info(int sig, struct siginfo *info, int pid)
1205 return kill_pg_info(sig, info, process_group(current));
1206 } else if (pid == -1) {
1207 int retval = 0, count = 0;
1208 struct task_struct * p;
1210 read_lock(&tasklist_lock);
1211 for_each_process(p) {
1212 if (vx_check(vx_task_xid(p), VX_ADMIN|VX_IDENT) &&
1213 p->pid > 1 && p->tgid != current->tgid) {
1214 int err = group_send_sig_info(sig, info, p);
1220 read_unlock(&tasklist_lock);
1221 return count ? retval : -ESRCH;
1222 } else if (pid < 0) {
1223 return kill_pg_info(sig, info, -pid);
1225 return kill_proc_info(sig, info, pid);
1230 * These are for backward compatibility with the rest of the kernel source.
1234 * These two are the most common entry points. They send a signal
1235 * just to the specific thread.
1238 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1241 unsigned long flags;
1244 * Make sure legacy kernel users don't send in bad values
1245 * (normal paths check this in check_kill_permission).
1247 if (!valid_signal(sig))
1251 * We need the tasklist lock even for the specific
1252 * thread case (when we don't need to follow the group
1253 * lists) in order to avoid races with "p->sighand"
1254 * going away or changing from under us.
1256 read_lock(&tasklist_lock);
1257 spin_lock_irqsave(&p->sighand->siglock, flags);
1258 ret = specific_send_sig_info(sig, info, p);
1259 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1260 read_unlock(&tasklist_lock);
1264 #define __si_special(priv) \
1265 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1268 send_sig(int sig, struct task_struct *p, int priv)
1270 return send_sig_info(sig, __si_special(priv), p);
1274 * This is the entry point for "process-wide" signals.
1275 * They will go to an appropriate thread in the thread group.
1278 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1281 read_lock(&tasklist_lock);
1282 ret = group_send_sig_info(sig, info, p);
1283 read_unlock(&tasklist_lock);
1288 force_sig(int sig, struct task_struct *p)
1290 force_sig_info(sig, SEND_SIG_PRIV, p);
1294 * When things go south during signal handling, we
1295 * will force a SIGSEGV. And if the signal that caused
1296 * the problem was already a SIGSEGV, we'll want to
1297 * make sure we don't even try to deliver the signal..
1300 force_sigsegv(int sig, struct task_struct *p)
1302 if (sig == SIGSEGV) {
1303 unsigned long flags;
1304 spin_lock_irqsave(&p->sighand->siglock, flags);
1305 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1306 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1308 force_sig(SIGSEGV, p);
1313 kill_pg(pid_t pgrp, int sig, int priv)
1315 return kill_pg_info(sig, __si_special(priv), pgrp);
1319 kill_proc(pid_t pid, int sig, int priv)
1321 return kill_proc_info(sig, __si_special(priv), pid);
1325 * These functions support sending signals using preallocated sigqueue
1326 * structures. This is needed "because realtime applications cannot
1327 * afford to lose notifications of asynchronous events, like timer
1328 * expirations or I/O completions". In the case of Posix Timers
1329 * we allocate the sigqueue structure from the timer_create. If this
1330 * allocation fails we are able to report the failure to the application
1331 * with an EAGAIN error.
1334 struct sigqueue *sigqueue_alloc(void)
1338 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1339 q->flags |= SIGQUEUE_PREALLOC;
1343 void sigqueue_free(struct sigqueue *q)
1345 unsigned long flags;
1346 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1348 * If the signal is still pending remove it from the
1351 if (unlikely(!list_empty(&q->list))) {
1352 spinlock_t *lock = ¤t->sighand->siglock;
1353 read_lock(&tasklist_lock);
1354 spin_lock_irqsave(lock, flags);
1355 if (!list_empty(&q->list))
1356 list_del_init(&q->list);
1357 spin_unlock_irqrestore(lock, flags);
1358 read_unlock(&tasklist_lock);
1360 q->flags &= ~SIGQUEUE_PREALLOC;
1364 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1366 unsigned long flags;
1369 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1372 * The rcu based delayed sighand destroy makes it possible to
1373 * run this without tasklist lock held. The task struct itself
1374 * cannot go away as create_timer did get_task_struct().
1376 * We return -1, when the task is marked exiting, so
1377 * posix_timer_event can redirect it to the group leader
1381 if (!likely(lock_task_sighand(p, &flags))) {
1386 if (unlikely(!list_empty(&q->list))) {
1388 * If an SI_TIMER entry is already queue just increment
1389 * the overrun count.
1391 BUG_ON(q->info.si_code != SI_TIMER);
1392 q->info.si_overrun++;
1395 /* Short-circuit ignored signals. */
1396 if (sig_ignored(p, sig)) {
1401 list_add_tail(&q->list, &p->pending.list);
1402 sigaddset(&p->pending.signal, sig);
1403 if (!sigismember(&p->blocked, sig))
1404 signal_wake_up(p, sig == SIGKILL);
1407 unlock_task_sighand(p, &flags);
1415 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1417 unsigned long flags;
1420 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1422 read_lock(&tasklist_lock);
1423 /* Since it_lock is held, p->sighand cannot be NULL. */
1424 spin_lock_irqsave(&p->sighand->siglock, flags);
1425 handle_stop_signal(sig, p);
1427 /* Short-circuit ignored signals. */
1428 if (sig_ignored(p, sig)) {
1433 if (unlikely(!list_empty(&q->list))) {
1435 * If an SI_TIMER entry is already queue just increment
1436 * the overrun count. Other uses should not try to
1437 * send the signal multiple times.
1439 BUG_ON(q->info.si_code != SI_TIMER);
1440 q->info.si_overrun++;
1445 * Put this signal on the shared-pending queue.
1446 * We always use the shared queue for process-wide signals,
1447 * to avoid several races.
1449 list_add_tail(&q->list, &p->signal->shared_pending.list);
1450 sigaddset(&p->signal->shared_pending.signal, sig);
1452 __group_complete_signal(sig, p);
1454 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1455 read_unlock(&tasklist_lock);
1460 * Wake up any threads in the parent blocked in wait* syscalls.
1462 static inline void __wake_up_parent(struct task_struct *p,
1463 struct task_struct *parent)
1465 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1469 * Let a parent know about the death of a child.
1470 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1473 void do_notify_parent(struct task_struct *tsk, int sig)
1475 struct siginfo info;
1476 unsigned long flags;
1477 struct sighand_struct *psig;
1481 /* do_notify_parent_cldstop should have been called instead. */
1482 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1484 BUG_ON(!tsk->ptrace &&
1485 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1487 info.si_signo = sig;
1489 info.si_pid = tsk->pid;
1490 info.si_uid = tsk->uid;
1492 /* FIXME: find out whether or not this is supposed to be c*time. */
1493 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1494 tsk->signal->utime));
1495 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1496 tsk->signal->stime));
1498 info.si_status = tsk->exit_code & 0x7f;
1499 if (tsk->exit_code & 0x80)
1500 info.si_code = CLD_DUMPED;
1501 else if (tsk->exit_code & 0x7f)
1502 info.si_code = CLD_KILLED;
1504 info.si_code = CLD_EXITED;
1505 info.si_status = tsk->exit_code >> 8;
1508 psig = tsk->parent->sighand;
1509 spin_lock_irqsave(&psig->siglock, flags);
1510 if (!tsk->ptrace && sig == SIGCHLD &&
1511 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1512 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1514 * We are exiting and our parent doesn't care. POSIX.1
1515 * defines special semantics for setting SIGCHLD to SIG_IGN
1516 * or setting the SA_NOCLDWAIT flag: we should be reaped
1517 * automatically and not left for our parent's wait4 call.
1518 * Rather than having the parent do it as a magic kind of
1519 * signal handler, we just set this to tell do_exit that we
1520 * can be cleaned up without becoming a zombie. Note that
1521 * we still call __wake_up_parent in this case, because a
1522 * blocked sys_wait4 might now return -ECHILD.
1524 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1525 * is implementation-defined: we do (if you don't want
1526 * it, just use SIG_IGN instead).
1528 tsk->exit_signal = -1;
1529 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1532 if (valid_signal(sig) && sig > 0)
1533 __group_send_sig_info(sig, &info, tsk->parent);
1534 __wake_up_parent(tsk, tsk->parent);
1535 spin_unlock_irqrestore(&psig->siglock, flags);
1538 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1540 struct siginfo info;
1541 unsigned long flags;
1542 struct task_struct *parent;
1543 struct sighand_struct *sighand;
1545 if (tsk->ptrace & PT_PTRACED)
1546 parent = tsk->parent;
1548 tsk = tsk->group_leader;
1549 parent = tsk->real_parent;
1552 info.si_signo = SIGCHLD;
1554 info.si_pid = tsk->pid;
1555 info.si_uid = tsk->uid;
1557 /* FIXME: find out whether or not this is supposed to be c*time. */
1558 info.si_utime = cputime_to_jiffies(tsk->utime);
1559 info.si_stime = cputime_to_jiffies(tsk->stime);
1564 info.si_status = SIGCONT;
1567 info.si_status = tsk->signal->group_exit_code & 0x7f;
1570 info.si_status = tsk->exit_code & 0x7f;
1576 sighand = parent->sighand;
1577 spin_lock_irqsave(&sighand->siglock, flags);
1578 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1579 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1580 __group_send_sig_info(SIGCHLD, &info, parent);
1582 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1584 __wake_up_parent(tsk, parent);
1585 spin_unlock_irqrestore(&sighand->siglock, flags);
1588 static inline int may_ptrace_stop(void)
1590 if (!likely(current->ptrace & PT_PTRACED))
1593 if (unlikely(current->parent == current->real_parent &&
1594 (current->ptrace & PT_ATTACHED)))
1597 if (unlikely(current->signal == current->parent->signal) &&
1598 unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))
1602 * Are we in the middle of do_coredump?
1603 * If so and our tracer is also part of the coredump stopping
1604 * is a deadlock situation, and pointless because our tracer
1605 * is dead so don't allow us to stop.
1606 * If SIGKILL was already sent before the caller unlocked
1607 * ->siglock we must see ->core_waiters != 0. Otherwise it
1608 * is safe to enter schedule().
1610 if (unlikely(current->mm->core_waiters) &&
1611 unlikely(current->mm == current->parent->mm))
1618 * This must be called with current->sighand->siglock held.
1620 * This should be the path for all ptrace stops.
1621 * We always set current->last_siginfo while stopped here.
1622 * That makes it a way to test a stopped process for
1623 * being ptrace-stopped vs being job-control-stopped.
1625 * If we actually decide not to stop at all because the tracer is gone,
1626 * we leave nostop_code in current->exit_code.
1628 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1631 * If there is a group stop in progress,
1632 * we must participate in the bookkeeping.
1634 if (current->signal->group_stop_count > 0)
1635 --current->signal->group_stop_count;
1637 current->last_siginfo = info;
1638 current->exit_code = exit_code;
1640 /* Let the debugger run. */
1641 set_current_state(TASK_TRACED);
1642 spin_unlock_irq(¤t->sighand->siglock);
1644 read_lock(&tasklist_lock);
1645 if (may_ptrace_stop()) {
1646 do_notify_parent_cldstop(current, CLD_TRAPPED);
1647 read_unlock(&tasklist_lock);
1651 * By the time we got the lock, our tracer went away.
1654 read_unlock(&tasklist_lock);
1655 set_current_state(TASK_RUNNING);
1656 current->exit_code = nostop_code;
1660 * We are back. Now reacquire the siglock before touching
1661 * last_siginfo, so that we are sure to have synchronized with
1662 * any signal-sending on another CPU that wants to examine it.
1664 spin_lock_irq(¤t->sighand->siglock);
1665 current->last_siginfo = NULL;
1668 * Queued signals ignored us while we were stopped for tracing.
1669 * So check for any that we should take before resuming user mode.
1671 recalc_sigpending();
1674 void ptrace_notify(int exit_code)
1678 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1680 memset(&info, 0, sizeof info);
1681 info.si_signo = SIGTRAP;
1682 info.si_code = exit_code;
1683 info.si_pid = current->pid;
1684 info.si_uid = current->uid;
1686 /* Let the debugger run. */
1687 spin_lock_irq(¤t->sighand->siglock);
1688 ptrace_stop(exit_code, 0, &info);
1689 spin_unlock_irq(¤t->sighand->siglock);
1693 finish_stop(int stop_count)
1696 * If there are no other threads in the group, or if there is
1697 * a group stop in progress and we are the last to stop,
1698 * report to the parent. When ptraced, every thread reports itself.
1700 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1701 read_lock(&tasklist_lock);
1702 do_notify_parent_cldstop(current, CLD_STOPPED);
1703 read_unlock(&tasklist_lock);
1708 * Now we don't run again until continued.
1710 current->exit_code = 0;
1714 * This performs the stopping for SIGSTOP and other stop signals.
1715 * We have to stop all threads in the thread group.
1716 * Returns nonzero if we've actually stopped and released the siglock.
1717 * Returns zero if we didn't stop and still hold the siglock.
1719 static int do_signal_stop(int signr)
1721 struct signal_struct *sig = current->signal;
1724 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1727 if (sig->group_stop_count > 0) {
1729 * There is a group stop in progress. We don't need to
1730 * start another one.
1732 stop_count = --sig->group_stop_count;
1735 * There is no group stop already in progress.
1736 * We must initiate one now.
1738 struct task_struct *t;
1740 sig->group_exit_code = signr;
1743 for (t = next_thread(current); t != current; t = next_thread(t))
1745 * Setting state to TASK_STOPPED for a group
1746 * stop is always done with the siglock held,
1747 * so this check has no races.
1749 if (!t->exit_state &&
1750 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1752 signal_wake_up(t, 0);
1754 sig->group_stop_count = stop_count;
1757 if (stop_count == 0)
1758 sig->flags = SIGNAL_STOP_STOPPED;
1759 current->exit_code = sig->group_exit_code;
1760 __set_current_state(TASK_STOPPED);
1762 spin_unlock_irq(¤t->sighand->siglock);
1763 finish_stop(stop_count);
1768 * Do appropriate magic when group_stop_count > 0.
1769 * We return nonzero if we stopped, after releasing the siglock.
1770 * We return zero if we still hold the siglock and should look
1771 * for another signal without checking group_stop_count again.
1773 static int handle_group_stop(void)
1777 if (current->signal->group_exit_task == current) {
1779 * Group stop is so we can do a core dump,
1780 * We are the initiating thread, so get on with it.
1782 current->signal->group_exit_task = NULL;
1786 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1788 * Group stop is so another thread can do a core dump,
1789 * or else we are racing against a death signal.
1790 * Just punt the stop so we can get the next signal.
1795 * There is a group stop in progress. We stop
1796 * without any associated signal being in our queue.
1798 stop_count = --current->signal->group_stop_count;
1799 if (stop_count == 0)
1800 current->signal->flags = SIGNAL_STOP_STOPPED;
1801 current->exit_code = current->signal->group_exit_code;
1802 set_current_state(TASK_STOPPED);
1803 spin_unlock_irq(¤t->sighand->siglock);
1804 finish_stop(stop_count);
1808 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1809 struct pt_regs *regs, void *cookie)
1811 sigset_t *mask = ¤t->blocked;
1817 spin_lock_irq(¤t->sighand->siglock);
1819 struct k_sigaction *ka;
1821 if (unlikely(current->signal->group_stop_count > 0) &&
1822 handle_group_stop())
1825 signr = dequeue_signal(current, mask, info);
1828 break; /* will return 0 */
1830 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1831 ptrace_signal_deliver(regs, cookie);
1833 /* Let the debugger run. */
1834 ptrace_stop(signr, signr, info);
1836 /* We're back. Did the debugger cancel the sig? */
1837 signr = current->exit_code;
1841 current->exit_code = 0;
1843 /* Update the siginfo structure if the signal has
1844 changed. If the debugger wanted something
1845 specific in the siginfo structure then it should
1846 have updated *info via PTRACE_SETSIGINFO. */
1847 if (signr != info->si_signo) {
1848 info->si_signo = signr;
1850 info->si_code = SI_USER;
1851 info->si_pid = current->parent->pid;
1852 info->si_uid = current->parent->uid;
1855 /* If the (new) signal is now blocked, requeue it. */
1856 if (sigismember(¤t->blocked, signr)) {
1857 specific_send_sig_info(signr, info, current);
1862 ka = ¤t->sighand->action[signr-1];
1863 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1865 if (ka->sa.sa_handler != SIG_DFL) {
1866 /* Run the handler. */
1869 if (ka->sa.sa_flags & SA_ONESHOT)
1870 ka->sa.sa_handler = SIG_DFL;
1872 break; /* will return non-zero "signr" value */
1876 * Now we are doing the default action for this signal.
1878 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1881 /* Init gets no signals it doesn't want. */
1882 if (current == child_reaper)
1885 /* virtual init is protected against user signals */
1886 if ((info->si_code == SI_USER) &&
1887 vx_current_initpid(current->pid))
1890 if (sig_kernel_stop(signr)) {
1892 * The default action is to stop all threads in
1893 * the thread group. The job control signals
1894 * do nothing in an orphaned pgrp, but SIGSTOP
1895 * always works. Note that siglock needs to be
1896 * dropped during the call to is_orphaned_pgrp()
1897 * because of lock ordering with tasklist_lock.
1898 * This allows an intervening SIGCONT to be posted.
1899 * We need to check for that and bail out if necessary.
1901 if (signr != SIGSTOP) {
1902 spin_unlock_irq(¤t->sighand->siglock);
1904 /* signals can be posted during this window */
1906 if (is_orphaned_pgrp(process_group(current)))
1909 spin_lock_irq(¤t->sighand->siglock);
1912 if (likely(do_signal_stop(signr))) {
1913 /* It released the siglock. */
1918 * We didn't actually stop, due to a race
1919 * with SIGCONT or something like that.
1924 spin_unlock_irq(¤t->sighand->siglock);
1927 * Anything else is fatal, maybe with a core dump.
1929 current->flags |= PF_SIGNALED;
1930 if (print_fatal_signals)
1931 print_fatal_signal(regs, signr);
1932 if (sig_kernel_coredump(signr)) {
1934 * If it was able to dump core, this kills all
1935 * other threads in the group and synchronizes with
1936 * their demise. If we lost the race with another
1937 * thread getting here, it set group_exit_code
1938 * first and our do_group_exit call below will use
1939 * that value and ignore the one we pass it.
1941 do_coredump((long)signr, signr, regs);
1945 * Death signals, no core dump.
1947 do_group_exit(signr);
1950 spin_unlock_irq(¤t->sighand->siglock);
1954 EXPORT_SYMBOL(recalc_sigpending);
1955 EXPORT_SYMBOL_GPL(dequeue_signal);
1956 EXPORT_SYMBOL(flush_signals);
1957 EXPORT_SYMBOL(force_sig);
1958 EXPORT_SYMBOL(kill_pg);
1959 EXPORT_SYMBOL(kill_proc);
1960 EXPORT_SYMBOL(ptrace_notify);
1961 EXPORT_SYMBOL(send_sig);
1962 EXPORT_SYMBOL(send_sig_info);
1963 EXPORT_SYMBOL(sigprocmask);
1964 EXPORT_SYMBOL(block_all_signals);
1965 EXPORT_SYMBOL(unblock_all_signals);
1969 * System call entry points.
1972 asmlinkage long sys_restart_syscall(void)
1974 struct restart_block *restart = ¤t_thread_info()->restart_block;
1975 return restart->fn(restart);
1978 long do_no_restart_syscall(struct restart_block *param)
1984 * We don't need to get the kernel lock - this is all local to this
1985 * particular thread.. (and that's good, because this is _heavily_
1986 * used by various programs)
1990 * This is also useful for kernel threads that want to temporarily
1991 * (or permanently) block certain signals.
1993 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1994 * interface happily blocks "unblockable" signals like SIGKILL
1997 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2001 spin_lock_irq(¤t->sighand->siglock);
2003 *oldset = current->blocked;
2008 sigorsets(¤t->blocked, ¤t->blocked, set);
2011 signandsets(¤t->blocked, ¤t->blocked, set);
2014 current->blocked = *set;
2019 recalc_sigpending();
2020 spin_unlock_irq(¤t->sighand->siglock);
2026 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2028 int error = -EINVAL;
2029 sigset_t old_set, new_set;
2031 /* XXX: Don't preclude handling different sized sigset_t's. */
2032 if (sigsetsize != sizeof(sigset_t))
2037 if (copy_from_user(&new_set, set, sizeof(*set)))
2039 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2041 error = sigprocmask(how, &new_set, &old_set);
2047 spin_lock_irq(¤t->sighand->siglock);
2048 old_set = current->blocked;
2049 spin_unlock_irq(¤t->sighand->siglock);
2053 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2061 long do_sigpending(void __user *set, unsigned long sigsetsize)
2063 long error = -EINVAL;
2066 if (sigsetsize > sizeof(sigset_t))
2069 spin_lock_irq(¤t->sighand->siglock);
2070 sigorsets(&pending, ¤t->pending.signal,
2071 ¤t->signal->shared_pending.signal);
2072 spin_unlock_irq(¤t->sighand->siglock);
2074 /* Outside the lock because only this thread touches it. */
2075 sigandsets(&pending, ¤t->blocked, &pending);
2078 if (!copy_to_user(set, &pending, sigsetsize))
2086 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2088 return do_sigpending(set, sigsetsize);
2091 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2093 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2097 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2099 if (from->si_code < 0)
2100 return __copy_to_user(to, from, sizeof(siginfo_t))
2103 * If you change siginfo_t structure, please be sure
2104 * this code is fixed accordingly.
2105 * It should never copy any pad contained in the structure
2106 * to avoid security leaks, but must copy the generic
2107 * 3 ints plus the relevant union member.
2109 err = __put_user(from->si_signo, &to->si_signo);
2110 err |= __put_user(from->si_errno, &to->si_errno);
2111 err |= __put_user((short)from->si_code, &to->si_code);
2112 switch (from->si_code & __SI_MASK) {
2114 err |= __put_user(from->si_pid, &to->si_pid);
2115 err |= __put_user(from->si_uid, &to->si_uid);
2118 err |= __put_user(from->si_tid, &to->si_tid);
2119 err |= __put_user(from->si_overrun, &to->si_overrun);
2120 err |= __put_user(from->si_ptr, &to->si_ptr);
2123 err |= __put_user(from->si_band, &to->si_band);
2124 err |= __put_user(from->si_fd, &to->si_fd);
2127 err |= __put_user(from->si_addr, &to->si_addr);
2128 #ifdef __ARCH_SI_TRAPNO
2129 err |= __put_user(from->si_trapno, &to->si_trapno);
2133 err |= __put_user(from->si_pid, &to->si_pid);
2134 err |= __put_user(from->si_uid, &to->si_uid);
2135 err |= __put_user(from->si_status, &to->si_status);
2136 err |= __put_user(from->si_utime, &to->si_utime);
2137 err |= __put_user(from->si_stime, &to->si_stime);
2139 case __SI_RT: /* This is not generated by the kernel as of now. */
2140 case __SI_MESGQ: /* But this is */
2141 err |= __put_user(from->si_pid, &to->si_pid);
2142 err |= __put_user(from->si_uid, &to->si_uid);
2143 err |= __put_user(from->si_ptr, &to->si_ptr);
2145 default: /* this is just in case for now ... */
2146 err |= __put_user(from->si_pid, &to->si_pid);
2147 err |= __put_user(from->si_uid, &to->si_uid);
2156 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2157 siginfo_t __user *uinfo,
2158 const struct timespec __user *uts,
2167 /* XXX: Don't preclude handling different sized sigset_t's. */
2168 if (sigsetsize != sizeof(sigset_t))
2171 if (copy_from_user(&these, uthese, sizeof(these)))
2175 * Invert the set of allowed signals to get those we
2178 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2182 if (copy_from_user(&ts, uts, sizeof(ts)))
2184 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2189 spin_lock_irq(¤t->sighand->siglock);
2190 sig = dequeue_signal(current, &these, &info);
2192 timeout = MAX_SCHEDULE_TIMEOUT;
2194 timeout = (timespec_to_jiffies(&ts)
2195 + (ts.tv_sec || ts.tv_nsec));
2198 /* None ready -- temporarily unblock those we're
2199 * interested while we are sleeping in so that we'll
2200 * be awakened when they arrive. */
2201 current->real_blocked = current->blocked;
2202 sigandsets(¤t->blocked, ¤t->blocked, &these);
2203 recalc_sigpending();
2204 spin_unlock_irq(¤t->sighand->siglock);
2206 timeout = schedule_timeout_interruptible(timeout);
2208 spin_lock_irq(¤t->sighand->siglock);
2209 sig = dequeue_signal(current, &these, &info);
2210 current->blocked = current->real_blocked;
2211 siginitset(¤t->real_blocked, 0);
2212 recalc_sigpending();
2215 spin_unlock_irq(¤t->sighand->siglock);
2220 if (copy_siginfo_to_user(uinfo, &info))
2233 sys_kill(int pid, int sig)
2235 struct siginfo info;
2237 info.si_signo = sig;
2239 info.si_code = SI_USER;
2240 info.si_pid = current->tgid;
2241 info.si_uid = current->uid;
2243 return kill_something_info(sig, &info, pid);
2246 static int do_tkill(int tgid, int pid, int sig)
2249 struct siginfo info;
2250 struct task_struct *p;
2253 info.si_signo = sig;
2255 info.si_code = SI_TKILL;
2256 info.si_pid = current->tgid;
2257 info.si_uid = current->uid;
2259 read_lock(&tasklist_lock);
2260 p = find_task_by_pid(pid);
2261 if (p && (tgid <= 0 || p->tgid == tgid)) {
2262 error = check_kill_permission(sig, &info, p);
2264 * The null signal is a permissions and process existence
2265 * probe. No signal is actually delivered.
2267 if (!error && sig && p->sighand) {
2268 spin_lock_irq(&p->sighand->siglock);
2269 handle_stop_signal(sig, p);
2270 error = specific_send_sig_info(sig, &info, p);
2271 spin_unlock_irq(&p->sighand->siglock);
2274 read_unlock(&tasklist_lock);
2280 * sys_tgkill - send signal to one specific thread
2281 * @tgid: the thread group ID of the thread
2282 * @pid: the PID of the thread
2283 * @sig: signal to be sent
2285 * This syscall also checks the tgid and returns -ESRCH even if the PID
2286 * exists but it's not belonging to the target process anymore. This
2287 * method solves the problem of threads exiting and PIDs getting reused.
2289 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2291 /* This is only valid for single tasks */
2292 if (pid <= 0 || tgid <= 0)
2295 return do_tkill(tgid, pid, sig);
2299 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2302 sys_tkill(int pid, int sig)
2304 /* This is only valid for single tasks */
2308 return do_tkill(0, pid, sig);
2312 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2316 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2319 /* Not even root can pretend to send signals from the kernel.
2320 Nor can they impersonate a kill(), which adds source info. */
2321 if (info.si_code >= 0)
2323 info.si_signo = sig;
2325 /* POSIX.1b doesn't mention process groups. */
2326 return kill_proc_info(sig, &info, pid);
2329 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2331 struct k_sigaction *k;
2334 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2337 k = ¤t->sighand->action[sig-1];
2339 spin_lock_irq(¤t->sighand->siglock);
2340 if (signal_pending(current)) {
2342 * If there might be a fatal signal pending on multiple
2343 * threads, make sure we take it before changing the action.
2345 spin_unlock_irq(¤t->sighand->siglock);
2346 return -ERESTARTNOINTR;
2353 sigdelsetmask(&act->sa.sa_mask,
2354 sigmask(SIGKILL) | sigmask(SIGSTOP));
2358 * "Setting a signal action to SIG_IGN for a signal that is
2359 * pending shall cause the pending signal to be discarded,
2360 * whether or not it is blocked."
2362 * "Setting a signal action to SIG_DFL for a signal that is
2363 * pending and whose default action is to ignore the signal
2364 * (for example, SIGCHLD), shall cause the pending signal to
2365 * be discarded, whether or not it is blocked"
2367 if (act->sa.sa_handler == SIG_IGN ||
2368 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2369 struct task_struct *t = current;
2371 sigaddset(&mask, sig);
2372 rm_from_queue_full(&mask, &t->signal->shared_pending);
2374 rm_from_queue_full(&mask, &t->pending);
2375 recalc_sigpending_tsk(t);
2377 } while (t != current);
2381 spin_unlock_irq(¤t->sighand->siglock);
2386 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2392 oss.ss_sp = (void __user *) current->sas_ss_sp;
2393 oss.ss_size = current->sas_ss_size;
2394 oss.ss_flags = sas_ss_flags(sp);
2403 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2404 || __get_user(ss_sp, &uss->ss_sp)
2405 || __get_user(ss_flags, &uss->ss_flags)
2406 || __get_user(ss_size, &uss->ss_size))
2410 if (on_sig_stack(sp))
2416 * Note - this code used to test ss_flags incorrectly
2417 * old code may have been written using ss_flags==0
2418 * to mean ss_flags==SS_ONSTACK (as this was the only
2419 * way that worked) - this fix preserves that older
2422 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2425 if (ss_flags == SS_DISABLE) {
2430 if (ss_size < MINSIGSTKSZ)
2434 current->sas_ss_sp = (unsigned long) ss_sp;
2435 current->sas_ss_size = ss_size;
2440 if (copy_to_user(uoss, &oss, sizeof(oss)))
2449 #ifdef __ARCH_WANT_SYS_SIGPENDING
2452 sys_sigpending(old_sigset_t __user *set)
2454 return do_sigpending(set, sizeof(*set));
2459 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2460 /* Some platforms have their own version with special arguments others
2461 support only sys_rt_sigprocmask. */
2464 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2467 old_sigset_t old_set, new_set;
2471 if (copy_from_user(&new_set, set, sizeof(*set)))
2473 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2475 spin_lock_irq(¤t->sighand->siglock);
2476 old_set = current->blocked.sig[0];
2484 sigaddsetmask(¤t->blocked, new_set);
2487 sigdelsetmask(¤t->blocked, new_set);
2490 current->blocked.sig[0] = new_set;
2494 recalc_sigpending();
2495 spin_unlock_irq(¤t->sighand->siglock);
2501 old_set = current->blocked.sig[0];
2504 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2511 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2513 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2515 sys_rt_sigaction(int sig,
2516 const struct sigaction __user *act,
2517 struct sigaction __user *oact,
2520 struct k_sigaction new_sa, old_sa;
2523 /* XXX: Don't preclude handling different sized sigset_t's. */
2524 if (sigsetsize != sizeof(sigset_t))
2528 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2532 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2535 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2541 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2543 #ifdef __ARCH_WANT_SYS_SGETMASK
2546 * For backwards compatibility. Functionality superseded by sigprocmask.
2552 return current->blocked.sig[0];
2556 sys_ssetmask(int newmask)
2560 spin_lock_irq(¤t->sighand->siglock);
2561 old = current->blocked.sig[0];
2563 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2565 recalc_sigpending();
2566 spin_unlock_irq(¤t->sighand->siglock);
2570 #endif /* __ARCH_WANT_SGETMASK */
2572 #ifdef __ARCH_WANT_SYS_SIGNAL
2574 * For backwards compatibility. Functionality superseded by sigaction.
2576 asmlinkage unsigned long
2577 sys_signal(int sig, __sighandler_t handler)
2579 struct k_sigaction new_sa, old_sa;
2582 new_sa.sa.sa_handler = handler;
2583 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2584 sigemptyset(&new_sa.sa.sa_mask);
2586 ret = do_sigaction(sig, &new_sa, &old_sa);
2588 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2590 #endif /* __ARCH_WANT_SYS_SIGNAL */
2592 #ifdef __ARCH_WANT_SYS_PAUSE
2597 current->state = TASK_INTERRUPTIBLE;
2599 return -ERESTARTNOHAND;
2604 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2605 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2609 /* XXX: Don't preclude handling different sized sigset_t's. */
2610 if (sigsetsize != sizeof(sigset_t))
2613 if (copy_from_user(&newset, unewset, sizeof(newset)))
2615 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2617 spin_lock_irq(¤t->sighand->siglock);
2618 current->saved_sigmask = current->blocked;
2619 current->blocked = newset;
2620 recalc_sigpending();
2621 spin_unlock_irq(¤t->sighand->siglock);
2623 current->state = TASK_INTERRUPTIBLE;
2625 set_thread_flag(TIF_RESTORE_SIGMASK);
2626 return -ERESTARTNOHAND;
2628 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2630 void __init signals_init(void)
2633 kmem_cache_create("sigqueue",
2634 sizeof(struct sigqueue),
2635 __alignof__(struct sigqueue),
2636 SLAB_PANIC, NULL, NULL);