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 <linux/freezer.h>
27 #include <linux/pid_namespace.h>
28 #include <linux/nsproxy.h>
30 #include <asm/param.h>
31 #include <asm/uaccess.h>
32 #include <asm/unistd.h>
33 #include <asm/siginfo.h>
34 #include "audit.h" /* audit_signal_info() */
37 * SLAB caches for signal bits.
40 static struct kmem_cache *sigqueue_cachep;
43 * In POSIX a signal is sent either to a specific thread (Linux task)
44 * or to the process as a whole (Linux thread group). How the signal
45 * is sent determines whether it's to one thread or the whole group,
46 * which determines which signal mask(s) are involved in blocking it
47 * from being delivered until later. When the signal is delivered,
48 * either it's caught or ignored by a user handler or it has a default
49 * effect that applies to the whole thread group (POSIX process).
51 * The possible effects an unblocked signal set to SIG_DFL can have are:
52 * ignore - Nothing Happens
53 * terminate - kill the process, i.e. all threads in the group,
54 * similar to exit_group. The group leader (only) reports
55 * WIFSIGNALED status to its parent.
56 * coredump - write a core dump file describing all threads using
57 * the same mm and then kill all those threads
58 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
60 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
61 * Other signals when not blocked and set to SIG_DFL behaves as follows.
62 * The job control signals also have other special effects.
64 * +--------------------+------------------+
65 * | POSIX signal | default action |
66 * +--------------------+------------------+
67 * | SIGHUP | terminate |
68 * | SIGINT | terminate |
69 * | SIGQUIT | coredump |
70 * | SIGILL | coredump |
71 * | SIGTRAP | coredump |
72 * | SIGABRT/SIGIOT | coredump |
73 * | SIGBUS | coredump |
74 * | SIGFPE | coredump |
75 * | SIGKILL | terminate(+) |
76 * | SIGUSR1 | terminate |
77 * | SIGSEGV | coredump |
78 * | SIGUSR2 | terminate |
79 * | SIGPIPE | terminate |
80 * | SIGALRM | terminate |
81 * | SIGTERM | terminate |
82 * | SIGCHLD | ignore |
83 * | SIGCONT | ignore(*) |
84 * | SIGSTOP | stop(*)(+) |
85 * | SIGTSTP | stop(*) |
86 * | SIGTTIN | stop(*) |
87 * | SIGTTOU | stop(*) |
89 * | SIGXCPU | coredump |
90 * | SIGXFSZ | coredump |
91 * | SIGVTALRM | terminate |
92 * | SIGPROF | terminate |
93 * | SIGPOLL/SIGIO | terminate |
94 * | SIGSYS/SIGUNUSED | coredump |
95 * | SIGSTKFLT | terminate |
96 * | SIGWINCH | ignore |
97 * | SIGPWR | terminate |
98 * | SIGRTMIN-SIGRTMAX | terminate |
99 * +--------------------+------------------+
100 * | non-POSIX signal | default action |
101 * +--------------------+------------------+
102 * | SIGEMT | coredump |
103 * +--------------------+------------------+
105 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
106 * (*) Special job control effects:
107 * When SIGCONT is sent, it resumes the process (all threads in the group)
108 * from TASK_STOPPED state and also clears any pending/queued stop signals
109 * (any of those marked with "stop(*)"). This happens regardless of blocking,
110 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
111 * any pending/queued SIGCONT signals; this happens regardless of blocking,
112 * catching, or ignored the stop signal, though (except for SIGSTOP) the
113 * default action of stopping the process may happen later or never.
117 #define M_SIGEMT M(SIGEMT)
122 #if SIGRTMIN > BITS_PER_LONG
123 #define M(sig) (1ULL << ((sig)-1))
125 #define M(sig) (1UL << ((sig)-1))
127 #define T(sig, mask) (M(sig) & (mask))
129 #define SIG_KERNEL_ONLY_MASK (\
130 M(SIGKILL) | M(SIGSTOP) )
132 #define SIG_KERNEL_STOP_MASK (\
133 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
135 #define SIG_KERNEL_COREDUMP_MASK (\
136 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
137 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
138 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
140 #define SIG_KERNEL_IGNORE_MASK (\
141 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
143 #define sig_kernel_only(sig) \
144 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
145 #define sig_kernel_coredump(sig) \
146 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
147 #define sig_kernel_ignore(sig) \
148 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
149 #define sig_kernel_stop(sig) \
150 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
152 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
154 #define sig_user_defined(t, signr) \
155 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
156 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
158 #define sig_fatal(t, signr) \
159 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
160 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
162 static int sig_ignored(struct task_struct *t, int sig)
164 void __user * handler;
167 * Tracers always want to know about signals..
169 if (t->ptrace & PT_PTRACED)
173 * Blocked signals are never ignored, since the
174 * signal handler may change by the time it is
177 if (sigismember(&t->blocked, sig))
180 /* Is it explicitly or implicitly ignored? */
181 handler = t->sighand->action[sig-1].sa.sa_handler;
182 return handler == SIG_IGN ||
183 (handler == SIG_DFL && sig_kernel_ignore(sig));
187 * Re-calculate pending state from the set of locally pending
188 * signals, globally pending signals, and blocked signals.
190 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
195 switch (_NSIG_WORDS) {
197 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
198 ready |= signal->sig[i] &~ blocked->sig[i];
201 case 4: ready = signal->sig[3] &~ blocked->sig[3];
202 ready |= signal->sig[2] &~ blocked->sig[2];
203 ready |= signal->sig[1] &~ blocked->sig[1];
204 ready |= signal->sig[0] &~ blocked->sig[0];
207 case 2: ready = signal->sig[1] &~ blocked->sig[1];
208 ready |= signal->sig[0] &~ blocked->sig[0];
211 case 1: ready = signal->sig[0] &~ blocked->sig[0];
216 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
218 fastcall void recalc_sigpending_tsk(struct task_struct *t)
220 if (t->signal->group_stop_count > 0 ||
222 PENDING(&t->pending, &t->blocked) ||
223 PENDING(&t->signal->shared_pending, &t->blocked))
224 set_tsk_thread_flag(t, TIF_SIGPENDING);
226 clear_tsk_thread_flag(t, TIF_SIGPENDING);
229 void recalc_sigpending(void)
231 recalc_sigpending_tsk(current);
234 /* Given the mask, find the first available signal that should be serviced. */
237 next_signal(struct sigpending *pending, sigset_t *mask)
239 unsigned long i, *s, *m, x;
242 s = pending->signal.sig;
244 switch (_NSIG_WORDS) {
246 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
247 if ((x = *s &~ *m) != 0) {
248 sig = ffz(~x) + i*_NSIG_BPW + 1;
253 case 2: if ((x = s[0] &~ m[0]) != 0)
255 else if ((x = s[1] &~ m[1]) != 0)
262 case 1: if ((x = *s &~ *m) != 0)
270 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
273 struct sigqueue *q = NULL;
274 struct user_struct *user;
277 * In order to avoid problems with "switch_user()", we want to make
278 * sure that the compiler doesn't re-load "t->user"
282 atomic_inc(&user->sigpending);
283 if (override_rlimit ||
284 atomic_read(&user->sigpending) <=
285 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
286 q = kmem_cache_alloc(sigqueue_cachep, flags);
287 if (unlikely(q == NULL)) {
288 atomic_dec(&user->sigpending);
290 INIT_LIST_HEAD(&q->list);
292 q->user = get_uid(user);
297 static void __sigqueue_free(struct sigqueue *q)
299 if (q->flags & SIGQUEUE_PREALLOC)
301 atomic_dec(&q->user->sigpending);
303 kmem_cache_free(sigqueue_cachep, q);
306 void flush_sigqueue(struct sigpending *queue)
310 sigemptyset(&queue->signal);
311 while (!list_empty(&queue->list)) {
312 q = list_entry(queue->list.next, struct sigqueue , list);
313 list_del_init(&q->list);
319 * Flush all pending signals for a task.
321 void flush_signals(struct task_struct *t)
325 spin_lock_irqsave(&t->sighand->siglock, flags);
326 clear_tsk_thread_flag(t,TIF_SIGPENDING);
327 flush_sigqueue(&t->pending);
328 flush_sigqueue(&t->signal->shared_pending);
329 spin_unlock_irqrestore(&t->sighand->siglock, flags);
333 * Flush all handlers for a task.
337 flush_signal_handlers(struct task_struct *t, int force_default)
340 struct k_sigaction *ka = &t->sighand->action[0];
341 for (i = _NSIG ; i != 0 ; i--) {
342 if (force_default || ka->sa.sa_handler != SIG_IGN)
343 ka->sa.sa_handler = SIG_DFL;
345 sigemptyset(&ka->sa.sa_mask);
351 /* Notify the system that a driver wants to block all signals for this
352 * process, and wants to be notified if any signals at all were to be
353 * sent/acted upon. If the notifier routine returns non-zero, then the
354 * signal will be acted upon after all. If the notifier routine returns 0,
355 * then then signal will be blocked. Only one block per process is
356 * allowed. priv is a pointer to private data that the notifier routine
357 * can use to determine if the signal should be blocked or not. */
360 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
364 spin_lock_irqsave(¤t->sighand->siglock, flags);
365 current->notifier_mask = mask;
366 current->notifier_data = priv;
367 current->notifier = notifier;
368 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
371 /* Notify the system that blocking has ended. */
374 unblock_all_signals(void)
378 spin_lock_irqsave(¤t->sighand->siglock, flags);
379 current->notifier = NULL;
380 current->notifier_data = NULL;
382 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
385 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
387 struct sigqueue *q, *first = NULL;
388 int still_pending = 0;
390 if (unlikely(!sigismember(&list->signal, sig)))
394 * Collect the siginfo appropriate to this signal. Check if
395 * there is another siginfo for the same signal.
397 list_for_each_entry(q, &list->list, list) {
398 if (q->info.si_signo == sig) {
407 list_del_init(&first->list);
408 copy_siginfo(info, &first->info);
409 __sigqueue_free(first);
411 sigdelset(&list->signal, sig);
414 /* Ok, it wasn't in the queue. This must be
415 a fast-pathed signal or we must have been
416 out of queue space. So zero out the info.
418 sigdelset(&list->signal, sig);
419 info->si_signo = sig;
428 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
431 int sig = next_signal(pending, mask);
434 if (current->notifier) {
435 if (sigismember(current->notifier_mask, sig)) {
436 if (!(current->notifier)(current->notifier_data)) {
437 clear_thread_flag(TIF_SIGPENDING);
443 if (!collect_signal(sig, pending, info))
451 * Dequeue a signal and return the element to the caller, which is
452 * expected to free it.
454 * All callers have to hold the siglock.
456 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
458 int signr = __dequeue_signal(&tsk->pending, mask, info);
460 signr = __dequeue_signal(&tsk->signal->shared_pending,
462 recalc_sigpending_tsk(tsk);
463 if (signr && unlikely(sig_kernel_stop(signr))) {
465 * Set a marker that we have dequeued a stop signal. Our
466 * caller might release the siglock and then the pending
467 * stop signal it is about to process is no longer in the
468 * pending bitmasks, but must still be cleared by a SIGCONT
469 * (and overruled by a SIGKILL). So those cases clear this
470 * shared flag after we've set it. Note that this flag may
471 * remain set after the signal we return is ignored or
472 * handled. That doesn't matter because its only purpose
473 * is to alert stop-signal processing code when another
474 * processor has come along and cleared the flag.
476 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
477 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
480 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
481 info->si_sys_private){
483 * Release the siglock to ensure proper locking order
484 * of timer locks outside of siglocks. Note, we leave
485 * irqs disabled here, since the posix-timers code is
486 * about to disable them again anyway.
488 spin_unlock(&tsk->sighand->siglock);
489 do_schedule_next_timer(info);
490 spin_lock(&tsk->sighand->siglock);
496 * Tell a process that it has a new active signal..
498 * NOTE! we rely on the previous spin_lock to
499 * lock interrupts for us! We can only be called with
500 * "siglock" held, and the local interrupt must
501 * have been disabled when that got acquired!
503 * No need to set need_resched since signal event passing
504 * goes through ->blocked
506 void signal_wake_up(struct task_struct *t, int resume)
510 set_tsk_thread_flag(t, TIF_SIGPENDING);
513 * For SIGKILL, we want to wake it up in the stopped/traced case.
514 * We don't check t->state here because there is a race with it
515 * executing another processor and just now entering stopped state.
516 * By using wake_up_state, we ensure the process will wake up and
517 * handle its death signal.
519 mask = TASK_INTERRUPTIBLE;
521 mask |= TASK_STOPPED | TASK_TRACED;
522 if (!wake_up_state(t, mask))
527 * Remove signals in mask from the pending set and queue.
528 * Returns 1 if any signals were found.
530 * All callers must be holding the siglock.
532 * This version takes a sigset mask and looks at all signals,
533 * not just those in the first mask word.
535 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
537 struct sigqueue *q, *n;
540 sigandsets(&m, mask, &s->signal);
541 if (sigisemptyset(&m))
544 signandsets(&s->signal, &s->signal, mask);
545 list_for_each_entry_safe(q, n, &s->list, list) {
546 if (sigismember(mask, q->info.si_signo)) {
547 list_del_init(&q->list);
554 * Remove signals in mask from the pending set and queue.
555 * Returns 1 if any signals were found.
557 * All callers must be holding the siglock.
559 static int rm_from_queue(unsigned long mask, struct sigpending *s)
561 struct sigqueue *q, *n;
563 if (!sigtestsetmask(&s->signal, mask))
566 sigdelsetmask(&s->signal, mask);
567 list_for_each_entry_safe(q, n, &s->list, list) {
568 if (q->info.si_signo < SIGRTMIN &&
569 (mask & sigmask(q->info.si_signo))) {
570 list_del_init(&q->list);
578 * Bad permissions for sending the signal
580 static int check_kill_permission(int sig, struct siginfo *info,
581 struct task_struct *t)
584 if (!valid_signal(sig))
587 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
588 && ((sig != SIGCONT) ||
589 (process_session(current) != process_session(t)))
590 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
591 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
592 && !capable(CAP_KILL))
595 error = security_task_kill(t, info, sig, 0);
597 audit_signal_info(sig, t); /* Let audit system see the signal */
602 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
605 * Handle magic process-wide effects of stop/continue signals.
606 * Unlike the signal actions, these happen immediately at signal-generation
607 * time regardless of blocking, ignoring, or handling. This does the
608 * actual continuing for SIGCONT, but not the actual stopping for stop
609 * signals. The process stop is done as a signal action for SIG_DFL.
611 static void handle_stop_signal(int sig, struct task_struct *p)
613 struct task_struct *t;
615 if (p->signal->flags & SIGNAL_GROUP_EXIT)
617 * The process is in the middle of dying already.
621 if (sig_kernel_stop(sig)) {
623 * This is a stop signal. Remove SIGCONT from all queues.
625 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
628 rm_from_queue(sigmask(SIGCONT), &t->pending);
631 } else if (sig == SIGCONT) {
633 * Remove all stop signals from all queues,
634 * and wake all threads.
636 if (unlikely(p->signal->group_stop_count > 0)) {
638 * There was a group stop in progress. We'll
639 * pretend it finished before we got here. We are
640 * obliged to report it to the parent: if the
641 * SIGSTOP happened "after" this SIGCONT, then it
642 * would have cleared this pending SIGCONT. If it
643 * happened "before" this SIGCONT, then the parent
644 * got the SIGCHLD about the stop finishing before
645 * the continue happened. We do the notification
646 * now, and it's as if the stop had finished and
647 * the SIGCHLD was pending on entry to this kill.
649 p->signal->group_stop_count = 0;
650 p->signal->flags = SIGNAL_STOP_CONTINUED;
651 spin_unlock(&p->sighand->siglock);
652 do_notify_parent_cldstop(p, CLD_STOPPED);
653 spin_lock(&p->sighand->siglock);
655 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
659 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
662 * If there is a handler for SIGCONT, we must make
663 * sure that no thread returns to user mode before
664 * we post the signal, in case it was the only
665 * thread eligible to run the signal handler--then
666 * it must not do anything between resuming and
667 * running the handler. With the TIF_SIGPENDING
668 * flag set, the thread will pause and acquire the
669 * siglock that we hold now and until we've queued
670 * the pending signal.
672 * Wake up the stopped thread _after_ setting
675 state = TASK_STOPPED;
676 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
677 set_tsk_thread_flag(t, TIF_SIGPENDING);
678 state |= TASK_INTERRUPTIBLE;
680 wake_up_state(t, state);
685 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
687 * We were in fact stopped, and are now continued.
688 * Notify the parent with CLD_CONTINUED.
690 p->signal->flags = SIGNAL_STOP_CONTINUED;
691 p->signal->group_exit_code = 0;
692 spin_unlock(&p->sighand->siglock);
693 do_notify_parent_cldstop(p, CLD_CONTINUED);
694 spin_lock(&p->sighand->siglock);
697 * We are not stopped, but there could be a stop
698 * signal in the middle of being processed after
699 * being removed from the queue. Clear that too.
701 p->signal->flags = 0;
703 } else if (sig == SIGKILL) {
705 * Make sure that any pending stop signal already dequeued
706 * is undone by the wakeup for SIGKILL.
708 p->signal->flags = 0;
712 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
713 struct sigpending *signals)
715 struct sigqueue * q = NULL;
719 * fast-pathed signals for kernel-internal things like SIGSTOP
722 if (info == SEND_SIG_FORCED)
725 /* Real-time signals must be queued if sent by sigqueue, or
726 some other real-time mechanism. It is implementation
727 defined whether kill() does so. We attempt to do so, on
728 the principle of least surprise, but since kill is not
729 allowed to fail with EAGAIN when low on memory we just
730 make sure at least one signal gets delivered and don't
731 pass on the info struct. */
733 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
734 (is_si_special(info) ||
735 info->si_code >= 0)));
737 list_add_tail(&q->list, &signals->list);
738 switch ((unsigned long) info) {
739 case (unsigned long) SEND_SIG_NOINFO:
740 q->info.si_signo = sig;
741 q->info.si_errno = 0;
742 q->info.si_code = SI_USER;
743 q->info.si_pid = current->pid;
744 q->info.si_uid = current->uid;
746 case (unsigned long) SEND_SIG_PRIV:
747 q->info.si_signo = sig;
748 q->info.si_errno = 0;
749 q->info.si_code = SI_KERNEL;
754 copy_siginfo(&q->info, info);
757 } else if (!is_si_special(info)) {
758 if (sig >= SIGRTMIN && info->si_code != SI_USER)
760 * Queue overflow, abort. We may abort if the signal was rt
761 * and sent by user using something other than kill().
767 sigaddset(&signals->signal, sig);
771 #define LEGACY_QUEUE(sigptr, sig) \
772 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
776 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
780 BUG_ON(!irqs_disabled());
781 assert_spin_locked(&t->sighand->siglock);
783 /* Short-circuit ignored signals. */
784 if (sig_ignored(t, sig))
787 /* Support queueing exactly one non-rt signal, so that we
788 can get more detailed information about the cause of
790 if (LEGACY_QUEUE(&t->pending, sig))
793 ret = send_signal(sig, info, t, &t->pending);
794 if (!ret && !sigismember(&t->blocked, sig))
795 signal_wake_up(t, sig == SIGKILL);
801 * Force a signal that the process can't ignore: if necessary
802 * we unblock the signal and change any SIG_IGN to SIG_DFL.
804 * Note: If we unblock the signal, we always reset it to SIG_DFL,
805 * since we do not want to have a signal handler that was blocked
806 * be invoked when user space had explicitly blocked it.
808 * We don't want to have recursive SIGSEGV's etc, for example.
811 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
813 unsigned long int flags;
814 int ret, blocked, ignored;
815 struct k_sigaction *action;
817 spin_lock_irqsave(&t->sighand->siglock, flags);
818 action = &t->sighand->action[sig-1];
819 ignored = action->sa.sa_handler == SIG_IGN;
820 blocked = sigismember(&t->blocked, sig);
821 if (blocked || ignored) {
822 action->sa.sa_handler = SIG_DFL;
824 sigdelset(&t->blocked, sig);
825 recalc_sigpending_tsk(t);
828 ret = specific_send_sig_info(sig, info, t);
829 spin_unlock_irqrestore(&t->sighand->siglock, flags);
835 force_sig_specific(int sig, struct task_struct *t)
837 force_sig_info(sig, SEND_SIG_FORCED, t);
841 * Test if P wants to take SIG. After we've checked all threads with this,
842 * it's equivalent to finding no threads not blocking SIG. Any threads not
843 * blocking SIG were ruled out because they are not running and already
844 * have pending signals. Such threads will dequeue from the shared queue
845 * as soon as they're available, so putting the signal on the shared queue
846 * will be equivalent to sending it to one such thread.
848 static inline int wants_signal(int sig, struct task_struct *p)
850 if (sigismember(&p->blocked, sig))
852 if (p->flags & PF_EXITING)
856 if (p->state & (TASK_STOPPED | TASK_TRACED))
858 return task_curr(p) || !signal_pending(p);
862 __group_complete_signal(int sig, struct task_struct *p)
864 struct task_struct *t;
867 * Now find a thread we can wake up to take the signal off the queue.
869 * If the main thread wants the signal, it gets first crack.
870 * Probably the least surprising to the average bear.
872 if (wants_signal(sig, p))
874 else if (thread_group_empty(p))
876 * There is just one thread and it does not need to be woken.
877 * It will dequeue unblocked signals before it runs again.
882 * Otherwise try to find a suitable thread.
884 t = p->signal->curr_target;
886 /* restart balancing at this thread */
887 t = p->signal->curr_target = p;
889 while (!wants_signal(sig, t)) {
891 if (t == p->signal->curr_target)
893 * No thread needs to be woken.
894 * Any eligible threads will see
895 * the signal in the queue soon.
899 p->signal->curr_target = t;
903 * Found a killable thread. If the signal will be fatal,
904 * then start taking the whole group down immediately.
906 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
907 !sigismember(&t->real_blocked, sig) &&
908 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
910 * This signal will be fatal to the whole group.
912 if (!sig_kernel_coredump(sig)) {
914 * Start a group exit and wake everybody up.
915 * This way we don't have other threads
916 * running and doing things after a slower
917 * thread has the fatal signal pending.
919 p->signal->flags = SIGNAL_GROUP_EXIT;
920 p->signal->group_exit_code = sig;
921 p->signal->group_stop_count = 0;
924 sigaddset(&t->pending.signal, SIGKILL);
925 signal_wake_up(t, 1);
932 * There will be a core dump. We make all threads other
933 * than the chosen one go into a group stop so that nothing
934 * happens until it gets scheduled, takes the signal off
935 * the shared queue, and does the core dump. This is a
936 * little more complicated than strictly necessary, but it
937 * keeps the signal state that winds up in the core dump
938 * unchanged from the death state, e.g. which thread had
939 * the core-dump signal unblocked.
941 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
942 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
943 p->signal->group_stop_count = 0;
944 p->signal->group_exit_task = t;
947 p->signal->group_stop_count++;
948 signal_wake_up(t, 0);
951 wake_up_process(p->signal->group_exit_task);
956 * The signal is already in the shared-pending queue.
957 * Tell the chosen thread to wake up and dequeue it.
959 signal_wake_up(t, sig == SIGKILL);
964 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
968 assert_spin_locked(&p->sighand->siglock);
969 handle_stop_signal(sig, p);
971 /* Short-circuit ignored signals. */
972 if (sig_ignored(p, sig))
975 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
976 /* This is a non-RT signal and we already have one queued. */
980 * Put this signal on the shared-pending queue, or fail with EAGAIN.
981 * We always use the shared queue for process-wide signals,
982 * to avoid several races.
984 ret = send_signal(sig, info, p, &p->signal->shared_pending);
988 __group_complete_signal(sig, p);
993 * Nuke all other threads in the group.
995 void zap_other_threads(struct task_struct *p)
997 struct task_struct *t;
999 p->signal->flags = SIGNAL_GROUP_EXIT;
1000 p->signal->group_stop_count = 0;
1002 if (thread_group_empty(p))
1005 for (t = next_thread(p); t != p; t = next_thread(t)) {
1007 * Don't bother with already dead threads
1013 * We don't want to notify the parent, since we are
1014 * killed as part of a thread group due to another
1015 * thread doing an execve() or similar. So set the
1016 * exit signal to -1 to allow immediate reaping of
1017 * the process. But don't detach the thread group
1020 if (t != p->group_leader)
1021 t->exit_signal = -1;
1023 /* SIGKILL will be handled before any pending SIGSTOP */
1024 sigaddset(&t->pending.signal, SIGKILL);
1025 signal_wake_up(t, 1);
1030 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1032 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1034 struct sighand_struct *sighand;
1037 sighand = rcu_dereference(tsk->sighand);
1038 if (unlikely(sighand == NULL))
1041 spin_lock_irqsave(&sighand->siglock, *flags);
1042 if (likely(sighand == tsk->sighand))
1044 spin_unlock_irqrestore(&sighand->siglock, *flags);
1050 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1052 unsigned long flags;
1055 ret = check_kill_permission(sig, info, p);
1059 if (lock_task_sighand(p, &flags)) {
1060 ret = __group_send_sig_info(sig, info, p);
1061 unlock_task_sighand(p, &flags);
1069 * kill_pgrp_info() sends a signal to a process group: this is what the tty
1070 * control characters do (^C, ^Z etc)
1073 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1075 struct task_struct *p = NULL;
1076 int retval, success;
1080 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1081 int err = group_send_sig_info(sig, info, p);
1084 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1085 return success ? 0 : retval;
1088 int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1092 read_lock(&tasklist_lock);
1093 retval = __kill_pgrp_info(sig, info, pgrp);
1094 read_unlock(&tasklist_lock);
1099 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1104 return __kill_pgrp_info(sig, info, find_pid(pgrp));
1108 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1112 read_lock(&tasklist_lock);
1113 retval = __kill_pg_info(sig, info, pgrp);
1114 read_unlock(&tasklist_lock);
1119 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1122 int acquired_tasklist_lock = 0;
1123 struct task_struct *p;
1126 if (unlikely(sig_needs_tasklist(sig))) {
1127 read_lock(&tasklist_lock);
1128 acquired_tasklist_lock = 1;
1130 p = pid_task(pid, PIDTYPE_PID);
1133 error = group_send_sig_info(sig, info, p);
1134 if (unlikely(acquired_tasklist_lock))
1135 read_unlock(&tasklist_lock);
1141 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1145 error = kill_pid_info(sig, info, find_pid(pid));
1150 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1151 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1152 uid_t uid, uid_t euid, u32 secid)
1155 struct task_struct *p;
1157 if (!valid_signal(sig))
1160 read_lock(&tasklist_lock);
1161 p = pid_task(pid, PIDTYPE_PID);
1166 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1167 && (euid != p->suid) && (euid != p->uid)
1168 && (uid != p->suid) && (uid != p->uid)) {
1172 ret = security_task_kill(p, info, sig, secid);
1175 if (sig && p->sighand) {
1176 unsigned long flags;
1177 spin_lock_irqsave(&p->sighand->siglock, flags);
1178 ret = __group_send_sig_info(sig, info, p);
1179 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1182 read_unlock(&tasklist_lock);
1185 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1188 * kill_something_info() interprets pid in interesting ways just like kill(2).
1190 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1191 * is probably wrong. Should make it like BSD or SYSV.
1194 static int kill_something_info(int sig, struct siginfo *info, int pid)
1197 return kill_pg_info(sig, info, process_group(current));
1198 } else if (pid == -1) {
1199 int retval = 0, count = 0;
1200 struct task_struct * p;
1202 read_lock(&tasklist_lock);
1203 for_each_process(p) {
1204 if (p->pid > 1 && p->tgid != current->tgid) {
1205 int err = group_send_sig_info(sig, info, p);
1211 read_unlock(&tasklist_lock);
1212 return count ? retval : -ESRCH;
1213 } else if (pid < 0) {
1214 return kill_pg_info(sig, info, -pid);
1216 return kill_proc_info(sig, info, pid);
1221 * These are for backward compatibility with the rest of the kernel source.
1225 * These two are the most common entry points. They send a signal
1226 * just to the specific thread.
1229 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1232 unsigned long flags;
1235 * Make sure legacy kernel users don't send in bad values
1236 * (normal paths check this in check_kill_permission).
1238 if (!valid_signal(sig))
1242 * We need the tasklist lock even for the specific
1243 * thread case (when we don't need to follow the group
1244 * lists) in order to avoid races with "p->sighand"
1245 * going away or changing from under us.
1247 read_lock(&tasklist_lock);
1248 spin_lock_irqsave(&p->sighand->siglock, flags);
1249 ret = specific_send_sig_info(sig, info, p);
1250 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1251 read_unlock(&tasklist_lock);
1255 #define __si_special(priv) \
1256 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1259 send_sig(int sig, struct task_struct *p, int priv)
1261 return send_sig_info(sig, __si_special(priv), p);
1265 * This is the entry point for "process-wide" signals.
1266 * They will go to an appropriate thread in the thread group.
1269 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1272 read_lock(&tasklist_lock);
1273 ret = group_send_sig_info(sig, info, p);
1274 read_unlock(&tasklist_lock);
1279 force_sig(int sig, struct task_struct *p)
1281 force_sig_info(sig, SEND_SIG_PRIV, p);
1285 * When things go south during signal handling, we
1286 * will force a SIGSEGV. And if the signal that caused
1287 * the problem was already a SIGSEGV, we'll want to
1288 * make sure we don't even try to deliver the signal..
1291 force_sigsegv(int sig, struct task_struct *p)
1293 if (sig == SIGSEGV) {
1294 unsigned long flags;
1295 spin_lock_irqsave(&p->sighand->siglock, flags);
1296 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1297 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1299 force_sig(SIGSEGV, p);
1303 int kill_pgrp(struct pid *pid, int sig, int priv)
1305 return kill_pgrp_info(sig, __si_special(priv), pid);
1307 EXPORT_SYMBOL(kill_pgrp);
1309 int kill_pid(struct pid *pid, int sig, int priv)
1311 return kill_pid_info(sig, __si_special(priv), pid);
1313 EXPORT_SYMBOL(kill_pid);
1316 kill_pg(pid_t pgrp, int sig, int priv)
1318 return kill_pg_info(sig, __si_special(priv), pgrp);
1322 kill_proc(pid_t pid, int sig, int priv)
1324 return kill_proc_info(sig, __si_special(priv), pid);
1328 * These functions support sending signals using preallocated sigqueue
1329 * structures. This is needed "because realtime applications cannot
1330 * afford to lose notifications of asynchronous events, like timer
1331 * expirations or I/O completions". In the case of Posix Timers
1332 * we allocate the sigqueue structure from the timer_create. If this
1333 * allocation fails we are able to report the failure to the application
1334 * with an EAGAIN error.
1337 struct sigqueue *sigqueue_alloc(void)
1341 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1342 q->flags |= SIGQUEUE_PREALLOC;
1346 void sigqueue_free(struct sigqueue *q)
1348 unsigned long flags;
1349 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1351 * If the signal is still pending remove it from the
1354 if (unlikely(!list_empty(&q->list))) {
1355 spinlock_t *lock = ¤t->sighand->siglock;
1356 read_lock(&tasklist_lock);
1357 spin_lock_irqsave(lock, flags);
1358 if (!list_empty(&q->list))
1359 list_del_init(&q->list);
1360 spin_unlock_irqrestore(lock, flags);
1361 read_unlock(&tasklist_lock);
1363 q->flags &= ~SIGQUEUE_PREALLOC;
1367 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1369 unsigned long flags;
1372 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1375 * The rcu based delayed sighand destroy makes it possible to
1376 * run this without tasklist lock held. The task struct itself
1377 * cannot go away as create_timer did get_task_struct().
1379 * We return -1, when the task is marked exiting, so
1380 * posix_timer_event can redirect it to the group leader
1384 if (!likely(lock_task_sighand(p, &flags))) {
1389 if (unlikely(!list_empty(&q->list))) {
1391 * If an SI_TIMER entry is already queue just increment
1392 * the overrun count.
1394 BUG_ON(q->info.si_code != SI_TIMER);
1395 q->info.si_overrun++;
1398 /* Short-circuit ignored signals. */
1399 if (sig_ignored(p, sig)) {
1404 list_add_tail(&q->list, &p->pending.list);
1405 sigaddset(&p->pending.signal, sig);
1406 if (!sigismember(&p->blocked, sig))
1407 signal_wake_up(p, sig == SIGKILL);
1410 unlock_task_sighand(p, &flags);
1418 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1420 unsigned long flags;
1423 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1425 read_lock(&tasklist_lock);
1426 /* Since it_lock is held, p->sighand cannot be NULL. */
1427 spin_lock_irqsave(&p->sighand->siglock, flags);
1428 handle_stop_signal(sig, p);
1430 /* Short-circuit ignored signals. */
1431 if (sig_ignored(p, sig)) {
1436 if (unlikely(!list_empty(&q->list))) {
1438 * If an SI_TIMER entry is already queue just increment
1439 * the overrun count. Other uses should not try to
1440 * send the signal multiple times.
1442 BUG_ON(q->info.si_code != SI_TIMER);
1443 q->info.si_overrun++;
1448 * Put this signal on the shared-pending queue.
1449 * We always use the shared queue for process-wide signals,
1450 * to avoid several races.
1452 list_add_tail(&q->list, &p->signal->shared_pending.list);
1453 sigaddset(&p->signal->shared_pending.signal, sig);
1455 __group_complete_signal(sig, p);
1457 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1458 read_unlock(&tasklist_lock);
1463 * Wake up any threads in the parent blocked in wait* syscalls.
1465 static inline void __wake_up_parent(struct task_struct *p,
1466 struct task_struct *parent)
1468 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1472 * Let a parent know about the death of a child.
1473 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1476 void do_notify_parent(struct task_struct *tsk, int sig)
1478 struct siginfo info;
1479 unsigned long flags;
1480 struct sighand_struct *psig;
1484 /* do_notify_parent_cldstop should have been called instead. */
1485 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1487 BUG_ON(!tsk->ptrace &&
1488 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1490 info.si_signo = sig;
1492 info.si_pid = tsk->pid;
1493 info.si_uid = tsk->uid;
1495 /* FIXME: find out whether or not this is supposed to be c*time. */
1496 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1497 tsk->signal->utime));
1498 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1499 tsk->signal->stime));
1501 info.si_status = tsk->exit_code & 0x7f;
1502 if (tsk->exit_code & 0x80)
1503 info.si_code = CLD_DUMPED;
1504 else if (tsk->exit_code & 0x7f)
1505 info.si_code = CLD_KILLED;
1507 info.si_code = CLD_EXITED;
1508 info.si_status = tsk->exit_code >> 8;
1511 psig = tsk->parent->sighand;
1512 spin_lock_irqsave(&psig->siglock, flags);
1513 if (!tsk->ptrace && sig == SIGCHLD &&
1514 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1515 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1517 * We are exiting and our parent doesn't care. POSIX.1
1518 * defines special semantics for setting SIGCHLD to SIG_IGN
1519 * or setting the SA_NOCLDWAIT flag: we should be reaped
1520 * automatically and not left for our parent's wait4 call.
1521 * Rather than having the parent do it as a magic kind of
1522 * signal handler, we just set this to tell do_exit that we
1523 * can be cleaned up without becoming a zombie. Note that
1524 * we still call __wake_up_parent in this case, because a
1525 * blocked sys_wait4 might now return -ECHILD.
1527 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1528 * is implementation-defined: we do (if you don't want
1529 * it, just use SIG_IGN instead).
1531 tsk->exit_signal = -1;
1532 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1535 if (valid_signal(sig) && sig > 0)
1536 __group_send_sig_info(sig, &info, tsk->parent);
1537 __wake_up_parent(tsk, tsk->parent);
1538 spin_unlock_irqrestore(&psig->siglock, flags);
1541 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1543 struct siginfo info;
1544 unsigned long flags;
1545 struct task_struct *parent;
1546 struct sighand_struct *sighand;
1548 if (tsk->ptrace & PT_PTRACED)
1549 parent = tsk->parent;
1551 tsk = tsk->group_leader;
1552 parent = tsk->real_parent;
1555 info.si_signo = SIGCHLD;
1557 info.si_pid = tsk->pid;
1558 info.si_uid = tsk->uid;
1560 /* FIXME: find out whether or not this is supposed to be c*time. */
1561 info.si_utime = cputime_to_jiffies(tsk->utime);
1562 info.si_stime = cputime_to_jiffies(tsk->stime);
1567 info.si_status = SIGCONT;
1570 info.si_status = tsk->signal->group_exit_code & 0x7f;
1573 info.si_status = tsk->exit_code & 0x7f;
1579 sighand = parent->sighand;
1580 spin_lock_irqsave(&sighand->siglock, flags);
1581 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1582 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1583 __group_send_sig_info(SIGCHLD, &info, parent);
1585 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1587 __wake_up_parent(tsk, parent);
1588 spin_unlock_irqrestore(&sighand->siglock, flags);
1591 static inline int may_ptrace_stop(void)
1593 if (!likely(current->ptrace & PT_PTRACED))
1596 if (unlikely(current->parent == current->real_parent &&
1597 (current->ptrace & PT_ATTACHED)))
1600 if (unlikely(current->signal == current->parent->signal) &&
1601 unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))
1605 * Are we in the middle of do_coredump?
1606 * If so and our tracer is also part of the coredump stopping
1607 * is a deadlock situation, and pointless because our tracer
1608 * is dead so don't allow us to stop.
1609 * If SIGKILL was already sent before the caller unlocked
1610 * ->siglock we must see ->core_waiters != 0. Otherwise it
1611 * is safe to enter schedule().
1613 if (unlikely(current->mm->core_waiters) &&
1614 unlikely(current->mm == current->parent->mm))
1621 * This must be called with current->sighand->siglock held.
1623 * This should be the path for all ptrace stops.
1624 * We always set current->last_siginfo while stopped here.
1625 * That makes it a way to test a stopped process for
1626 * being ptrace-stopped vs being job-control-stopped.
1628 * If we actually decide not to stop at all because the tracer is gone,
1629 * we leave nostop_code in current->exit_code.
1631 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1634 * If there is a group stop in progress,
1635 * we must participate in the bookkeeping.
1637 if (current->signal->group_stop_count > 0)
1638 --current->signal->group_stop_count;
1640 current->last_siginfo = info;
1641 current->exit_code = exit_code;
1643 /* Let the debugger run. */
1644 set_current_state(TASK_TRACED);
1645 spin_unlock_irq(¤t->sighand->siglock);
1647 read_lock(&tasklist_lock);
1648 if (may_ptrace_stop()) {
1649 do_notify_parent_cldstop(current, CLD_TRAPPED);
1650 read_unlock(&tasklist_lock);
1654 * By the time we got the lock, our tracer went away.
1657 read_unlock(&tasklist_lock);
1658 set_current_state(TASK_RUNNING);
1659 current->exit_code = nostop_code;
1663 * We are back. Now reacquire the siglock before touching
1664 * last_siginfo, so that we are sure to have synchronized with
1665 * any signal-sending on another CPU that wants to examine it.
1667 spin_lock_irq(¤t->sighand->siglock);
1668 current->last_siginfo = NULL;
1671 * Queued signals ignored us while we were stopped for tracing.
1672 * So check for any that we should take before resuming user mode.
1674 recalc_sigpending();
1677 void ptrace_notify(int exit_code)
1681 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1683 memset(&info, 0, sizeof info);
1684 info.si_signo = SIGTRAP;
1685 info.si_code = exit_code;
1686 info.si_pid = current->pid;
1687 info.si_uid = current->uid;
1689 /* Let the debugger run. */
1690 spin_lock_irq(¤t->sighand->siglock);
1691 ptrace_stop(exit_code, 0, &info);
1692 spin_unlock_irq(¤t->sighand->siglock);
1696 finish_stop(int stop_count)
1699 * If there are no other threads in the group, or if there is
1700 * a group stop in progress and we are the last to stop,
1701 * report to the parent. When ptraced, every thread reports itself.
1703 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1704 read_lock(&tasklist_lock);
1705 do_notify_parent_cldstop(current, CLD_STOPPED);
1706 read_unlock(&tasklist_lock);
1711 } while (try_to_freeze());
1713 * Now we don't run again until continued.
1715 current->exit_code = 0;
1719 * This performs the stopping for SIGSTOP and other stop signals.
1720 * We have to stop all threads in the thread group.
1721 * Returns nonzero if we've actually stopped and released the siglock.
1722 * Returns zero if we didn't stop and still hold the siglock.
1724 static int do_signal_stop(int signr)
1726 struct signal_struct *sig = current->signal;
1729 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1732 if (sig->group_stop_count > 0) {
1734 * There is a group stop in progress. We don't need to
1735 * start another one.
1737 stop_count = --sig->group_stop_count;
1740 * There is no group stop already in progress.
1741 * We must initiate one now.
1743 struct task_struct *t;
1745 sig->group_exit_code = signr;
1748 for (t = next_thread(current); t != current; t = next_thread(t))
1750 * Setting state to TASK_STOPPED for a group
1751 * stop is always done with the siglock held,
1752 * so this check has no races.
1754 if (!t->exit_state &&
1755 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1757 signal_wake_up(t, 0);
1759 sig->group_stop_count = stop_count;
1762 if (stop_count == 0)
1763 sig->flags = SIGNAL_STOP_STOPPED;
1764 current->exit_code = sig->group_exit_code;
1765 __set_current_state(TASK_STOPPED);
1767 spin_unlock_irq(¤t->sighand->siglock);
1768 finish_stop(stop_count);
1773 * Do appropriate magic when group_stop_count > 0.
1774 * We return nonzero if we stopped, after releasing the siglock.
1775 * We return zero if we still hold the siglock and should look
1776 * for another signal without checking group_stop_count again.
1778 static int handle_group_stop(void)
1782 if (current->signal->group_exit_task == current) {
1784 * Group stop is so we can do a core dump,
1785 * We are the initiating thread, so get on with it.
1787 current->signal->group_exit_task = NULL;
1791 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1793 * Group stop is so another thread can do a core dump,
1794 * or else we are racing against a death signal.
1795 * Just punt the stop so we can get the next signal.
1800 * There is a group stop in progress. We stop
1801 * without any associated signal being in our queue.
1803 stop_count = --current->signal->group_stop_count;
1804 if (stop_count == 0)
1805 current->signal->flags = SIGNAL_STOP_STOPPED;
1806 current->exit_code = current->signal->group_exit_code;
1807 set_current_state(TASK_STOPPED);
1808 spin_unlock_irq(¤t->sighand->siglock);
1809 finish_stop(stop_count);
1813 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1814 struct pt_regs *regs, void *cookie)
1816 sigset_t *mask = ¤t->blocked;
1822 spin_lock_irq(¤t->sighand->siglock);
1824 struct k_sigaction *ka;
1826 if (unlikely(current->signal->group_stop_count > 0) &&
1827 handle_group_stop())
1830 signr = dequeue_signal(current, mask, info);
1833 break; /* will return 0 */
1835 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1836 ptrace_signal_deliver(regs, cookie);
1838 /* Let the debugger run. */
1839 ptrace_stop(signr, signr, info);
1841 /* We're back. Did the debugger cancel the sig? */
1842 signr = current->exit_code;
1846 current->exit_code = 0;
1848 /* Update the siginfo structure if the signal has
1849 changed. If the debugger wanted something
1850 specific in the siginfo structure then it should
1851 have updated *info via PTRACE_SETSIGINFO. */
1852 if (signr != info->si_signo) {
1853 info->si_signo = signr;
1855 info->si_code = SI_USER;
1856 info->si_pid = current->parent->pid;
1857 info->si_uid = current->parent->uid;
1860 /* If the (new) signal is now blocked, requeue it. */
1861 if (sigismember(¤t->blocked, signr)) {
1862 specific_send_sig_info(signr, info, current);
1867 ka = ¤t->sighand->action[signr-1];
1868 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1870 if (ka->sa.sa_handler != SIG_DFL) {
1871 /* Run the handler. */
1874 if (ka->sa.sa_flags & SA_ONESHOT)
1875 ka->sa.sa_handler = SIG_DFL;
1877 break; /* will return non-zero "signr" value */
1881 * Now we are doing the default action for this signal.
1883 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1887 * Init of a pid space gets no signals it doesn't want from
1888 * within that pid space. It can of course get signals from
1889 * its parent pid space.
1891 if (current == child_reaper(current))
1894 if (sig_kernel_stop(signr)) {
1896 * The default action is to stop all threads in
1897 * the thread group. The job control signals
1898 * do nothing in an orphaned pgrp, but SIGSTOP
1899 * always works. Note that siglock needs to be
1900 * dropped during the call to is_orphaned_pgrp()
1901 * because of lock ordering with tasklist_lock.
1902 * This allows an intervening SIGCONT to be posted.
1903 * We need to check for that and bail out if necessary.
1905 if (signr != SIGSTOP) {
1906 spin_unlock_irq(¤t->sighand->siglock);
1908 /* signals can be posted during this window */
1910 if (is_orphaned_pgrp(process_group(current)))
1913 spin_lock_irq(¤t->sighand->siglock);
1916 if (likely(do_signal_stop(signr))) {
1917 /* It released the siglock. */
1922 * We didn't actually stop, due to a race
1923 * with SIGCONT or something like that.
1928 spin_unlock_irq(¤t->sighand->siglock);
1931 * Anything else is fatal, maybe with a core dump.
1933 current->flags |= PF_SIGNALED;
1934 if (sig_kernel_coredump(signr)) {
1936 * If it was able to dump core, this kills all
1937 * other threads in the group and synchronizes with
1938 * their demise. If we lost the race with another
1939 * thread getting here, it set group_exit_code
1940 * first and our do_group_exit call below will use
1941 * that value and ignore the one we pass it.
1943 do_coredump((long)signr, signr, regs);
1947 * Death signals, no core dump.
1949 do_group_exit(signr);
1952 spin_unlock_irq(¤t->sighand->siglock);
1956 EXPORT_SYMBOL(recalc_sigpending);
1957 EXPORT_SYMBOL_GPL(dequeue_signal);
1958 EXPORT_SYMBOL(flush_signals);
1959 EXPORT_SYMBOL(force_sig);
1960 EXPORT_SYMBOL(kill_pg);
1961 EXPORT_SYMBOL(kill_proc);
1962 EXPORT_SYMBOL(ptrace_notify);
1963 EXPORT_SYMBOL(send_sig);
1964 EXPORT_SYMBOL(send_sig_info);
1965 EXPORT_SYMBOL(sigprocmask);
1966 EXPORT_SYMBOL(block_all_signals);
1967 EXPORT_SYMBOL(unblock_all_signals);
1971 * System call entry points.
1974 asmlinkage long sys_restart_syscall(void)
1976 struct restart_block *restart = ¤t_thread_info()->restart_block;
1977 return restart->fn(restart);
1980 long do_no_restart_syscall(struct restart_block *param)
1986 * We don't need to get the kernel lock - this is all local to this
1987 * particular thread.. (and that's good, because this is _heavily_
1988 * used by various programs)
1992 * This is also useful for kernel threads that want to temporarily
1993 * (or permanently) block certain signals.
1995 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1996 * interface happily blocks "unblockable" signals like SIGKILL
1999 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2003 spin_lock_irq(¤t->sighand->siglock);
2005 *oldset = current->blocked;
2010 sigorsets(¤t->blocked, ¤t->blocked, set);
2013 signandsets(¤t->blocked, ¤t->blocked, set);
2016 current->blocked = *set;
2021 recalc_sigpending();
2022 spin_unlock_irq(¤t->sighand->siglock);
2028 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2030 int error = -EINVAL;
2031 sigset_t old_set, new_set;
2033 /* XXX: Don't preclude handling different sized sigset_t's. */
2034 if (sigsetsize != sizeof(sigset_t))
2039 if (copy_from_user(&new_set, set, sizeof(*set)))
2041 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2043 error = sigprocmask(how, &new_set, &old_set);
2049 spin_lock_irq(¤t->sighand->siglock);
2050 old_set = current->blocked;
2051 spin_unlock_irq(¤t->sighand->siglock);
2055 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2063 long do_sigpending(void __user *set, unsigned long sigsetsize)
2065 long error = -EINVAL;
2068 if (sigsetsize > sizeof(sigset_t))
2071 spin_lock_irq(¤t->sighand->siglock);
2072 sigorsets(&pending, ¤t->pending.signal,
2073 ¤t->signal->shared_pending.signal);
2074 spin_unlock_irq(¤t->sighand->siglock);
2076 /* Outside the lock because only this thread touches it. */
2077 sigandsets(&pending, ¤t->blocked, &pending);
2080 if (!copy_to_user(set, &pending, sigsetsize))
2088 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2090 return do_sigpending(set, sigsetsize);
2093 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2095 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2099 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2101 if (from->si_code < 0)
2102 return __copy_to_user(to, from, sizeof(siginfo_t))
2105 * If you change siginfo_t structure, please be sure
2106 * this code is fixed accordingly.
2107 * It should never copy any pad contained in the structure
2108 * to avoid security leaks, but must copy the generic
2109 * 3 ints plus the relevant union member.
2111 err = __put_user(from->si_signo, &to->si_signo);
2112 err |= __put_user(from->si_errno, &to->si_errno);
2113 err |= __put_user((short)from->si_code, &to->si_code);
2114 switch (from->si_code & __SI_MASK) {
2116 err |= __put_user(from->si_pid, &to->si_pid);
2117 err |= __put_user(from->si_uid, &to->si_uid);
2120 err |= __put_user(from->si_tid, &to->si_tid);
2121 err |= __put_user(from->si_overrun, &to->si_overrun);
2122 err |= __put_user(from->si_ptr, &to->si_ptr);
2125 err |= __put_user(from->si_band, &to->si_band);
2126 err |= __put_user(from->si_fd, &to->si_fd);
2129 err |= __put_user(from->si_addr, &to->si_addr);
2130 #ifdef __ARCH_SI_TRAPNO
2131 err |= __put_user(from->si_trapno, &to->si_trapno);
2135 err |= __put_user(from->si_pid, &to->si_pid);
2136 err |= __put_user(from->si_uid, &to->si_uid);
2137 err |= __put_user(from->si_status, &to->si_status);
2138 err |= __put_user(from->si_utime, &to->si_utime);
2139 err |= __put_user(from->si_stime, &to->si_stime);
2141 case __SI_RT: /* This is not generated by the kernel as of now. */
2142 case __SI_MESGQ: /* But this is */
2143 err |= __put_user(from->si_pid, &to->si_pid);
2144 err |= __put_user(from->si_uid, &to->si_uid);
2145 err |= __put_user(from->si_ptr, &to->si_ptr);
2147 default: /* this is just in case for now ... */
2148 err |= __put_user(from->si_pid, &to->si_pid);
2149 err |= __put_user(from->si_uid, &to->si_uid);
2158 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2159 siginfo_t __user *uinfo,
2160 const struct timespec __user *uts,
2169 /* XXX: Don't preclude handling different sized sigset_t's. */
2170 if (sigsetsize != sizeof(sigset_t))
2173 if (copy_from_user(&these, uthese, sizeof(these)))
2177 * Invert the set of allowed signals to get those we
2180 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2184 if (copy_from_user(&ts, uts, sizeof(ts)))
2186 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2191 spin_lock_irq(¤t->sighand->siglock);
2192 sig = dequeue_signal(current, &these, &info);
2194 timeout = MAX_SCHEDULE_TIMEOUT;
2196 timeout = (timespec_to_jiffies(&ts)
2197 + (ts.tv_sec || ts.tv_nsec));
2200 /* None ready -- temporarily unblock those we're
2201 * interested while we are sleeping in so that we'll
2202 * be awakened when they arrive. */
2203 current->real_blocked = current->blocked;
2204 sigandsets(¤t->blocked, ¤t->blocked, &these);
2205 recalc_sigpending();
2206 spin_unlock_irq(¤t->sighand->siglock);
2208 timeout = schedule_timeout_interruptible(timeout);
2210 spin_lock_irq(¤t->sighand->siglock);
2211 sig = dequeue_signal(current, &these, &info);
2212 current->blocked = current->real_blocked;
2213 siginitset(¤t->real_blocked, 0);
2214 recalc_sigpending();
2217 spin_unlock_irq(¤t->sighand->siglock);
2222 if (copy_siginfo_to_user(uinfo, &info))
2235 sys_kill(int pid, int sig)
2237 struct siginfo info;
2239 info.si_signo = sig;
2241 info.si_code = SI_USER;
2242 info.si_pid = current->tgid;
2243 info.si_uid = current->uid;
2245 return kill_something_info(sig, &info, pid);
2248 static int do_tkill(int tgid, int pid, int sig)
2251 struct siginfo info;
2252 struct task_struct *p;
2255 info.si_signo = sig;
2257 info.si_code = SI_TKILL;
2258 info.si_pid = current->tgid;
2259 info.si_uid = current->uid;
2261 read_lock(&tasklist_lock);
2262 p = find_task_by_pid(pid);
2263 if (p && (tgid <= 0 || p->tgid == tgid)) {
2264 error = check_kill_permission(sig, &info, p);
2266 * The null signal is a permissions and process existence
2267 * probe. No signal is actually delivered.
2269 if (!error && sig && p->sighand) {
2270 spin_lock_irq(&p->sighand->siglock);
2271 handle_stop_signal(sig, p);
2272 error = specific_send_sig_info(sig, &info, p);
2273 spin_unlock_irq(&p->sighand->siglock);
2276 read_unlock(&tasklist_lock);
2282 * sys_tgkill - send signal to one specific thread
2283 * @tgid: the thread group ID of the thread
2284 * @pid: the PID of the thread
2285 * @sig: signal to be sent
2287 * This syscall also checks the tgid and returns -ESRCH even if the PID
2288 * exists but it's not belonging to the target process anymore. This
2289 * method solves the problem of threads exiting and PIDs getting reused.
2291 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2293 /* This is only valid for single tasks */
2294 if (pid <= 0 || tgid <= 0)
2297 return do_tkill(tgid, pid, sig);
2301 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2304 sys_tkill(int pid, int sig)
2306 /* This is only valid for single tasks */
2310 return do_tkill(0, pid, sig);
2314 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2318 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2321 /* Not even root can pretend to send signals from the kernel.
2322 Nor can they impersonate a kill(), which adds source info. */
2323 if (info.si_code >= 0)
2325 info.si_signo = sig;
2327 /* POSIX.1b doesn't mention process groups. */
2328 return kill_proc_info(sig, &info, pid);
2331 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2333 struct k_sigaction *k;
2336 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2339 k = ¤t->sighand->action[sig-1];
2341 spin_lock_irq(¤t->sighand->siglock);
2342 if (signal_pending(current)) {
2344 * If there might be a fatal signal pending on multiple
2345 * threads, make sure we take it before changing the action.
2347 spin_unlock_irq(¤t->sighand->siglock);
2348 return -ERESTARTNOINTR;
2355 sigdelsetmask(&act->sa.sa_mask,
2356 sigmask(SIGKILL) | sigmask(SIGSTOP));
2360 * "Setting a signal action to SIG_IGN for a signal that is
2361 * pending shall cause the pending signal to be discarded,
2362 * whether or not it is blocked."
2364 * "Setting a signal action to SIG_DFL for a signal that is
2365 * pending and whose default action is to ignore the signal
2366 * (for example, SIGCHLD), shall cause the pending signal to
2367 * be discarded, whether or not it is blocked"
2369 if (act->sa.sa_handler == SIG_IGN ||
2370 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2371 struct task_struct *t = current;
2373 sigaddset(&mask, sig);
2374 rm_from_queue_full(&mask, &t->signal->shared_pending);
2376 rm_from_queue_full(&mask, &t->pending);
2377 recalc_sigpending_tsk(t);
2379 } while (t != current);
2383 spin_unlock_irq(¤t->sighand->siglock);
2388 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2394 oss.ss_sp = (void __user *) current->sas_ss_sp;
2395 oss.ss_size = current->sas_ss_size;
2396 oss.ss_flags = sas_ss_flags(sp);
2405 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2406 || __get_user(ss_sp, &uss->ss_sp)
2407 || __get_user(ss_flags, &uss->ss_flags)
2408 || __get_user(ss_size, &uss->ss_size))
2412 if (on_sig_stack(sp))
2418 * Note - this code used to test ss_flags incorrectly
2419 * old code may have been written using ss_flags==0
2420 * to mean ss_flags==SS_ONSTACK (as this was the only
2421 * way that worked) - this fix preserves that older
2424 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2427 if (ss_flags == SS_DISABLE) {
2432 if (ss_size < MINSIGSTKSZ)
2436 current->sas_ss_sp = (unsigned long) ss_sp;
2437 current->sas_ss_size = ss_size;
2442 if (copy_to_user(uoss, &oss, sizeof(oss)))
2451 #ifdef __ARCH_WANT_SYS_SIGPENDING
2454 sys_sigpending(old_sigset_t __user *set)
2456 return do_sigpending(set, sizeof(*set));
2461 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2462 /* Some platforms have their own version with special arguments others
2463 support only sys_rt_sigprocmask. */
2466 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2469 old_sigset_t old_set, new_set;
2473 if (copy_from_user(&new_set, set, sizeof(*set)))
2475 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2477 spin_lock_irq(¤t->sighand->siglock);
2478 old_set = current->blocked.sig[0];
2486 sigaddsetmask(¤t->blocked, new_set);
2489 sigdelsetmask(¤t->blocked, new_set);
2492 current->blocked.sig[0] = new_set;
2496 recalc_sigpending();
2497 spin_unlock_irq(¤t->sighand->siglock);
2503 old_set = current->blocked.sig[0];
2506 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2513 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2515 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2517 sys_rt_sigaction(int sig,
2518 const struct sigaction __user *act,
2519 struct sigaction __user *oact,
2522 struct k_sigaction new_sa, old_sa;
2525 /* XXX: Don't preclude handling different sized sigset_t's. */
2526 if (sigsetsize != sizeof(sigset_t))
2530 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2534 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2537 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2543 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2545 #ifdef __ARCH_WANT_SYS_SGETMASK
2548 * For backwards compatibility. Functionality superseded by sigprocmask.
2554 return current->blocked.sig[0];
2558 sys_ssetmask(int newmask)
2562 spin_lock_irq(¤t->sighand->siglock);
2563 old = current->blocked.sig[0];
2565 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2567 recalc_sigpending();
2568 spin_unlock_irq(¤t->sighand->siglock);
2572 #endif /* __ARCH_WANT_SGETMASK */
2574 #ifdef __ARCH_WANT_SYS_SIGNAL
2576 * For backwards compatibility. Functionality superseded by sigaction.
2578 asmlinkage unsigned long
2579 sys_signal(int sig, __sighandler_t handler)
2581 struct k_sigaction new_sa, old_sa;
2584 new_sa.sa.sa_handler = handler;
2585 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2586 sigemptyset(&new_sa.sa.sa_mask);
2588 ret = do_sigaction(sig, &new_sa, &old_sa);
2590 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2592 #endif /* __ARCH_WANT_SYS_SIGNAL */
2594 #ifdef __ARCH_WANT_SYS_PAUSE
2599 current->state = TASK_INTERRUPTIBLE;
2601 return -ERESTARTNOHAND;
2606 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2607 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2611 /* XXX: Don't preclude handling different sized sigset_t's. */
2612 if (sigsetsize != sizeof(sigset_t))
2615 if (copy_from_user(&newset, unewset, sizeof(newset)))
2617 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2619 spin_lock_irq(¤t->sighand->siglock);
2620 current->saved_sigmask = current->blocked;
2621 current->blocked = newset;
2622 recalc_sigpending();
2623 spin_unlock_irq(¤t->sighand->siglock);
2625 current->state = TASK_INTERRUPTIBLE;
2627 set_thread_flag(TIF_RESTORE_SIGMASK);
2628 return -ERESTARTNOHAND;
2630 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2632 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2637 void __init signals_init(void)
2640 kmem_cache_create("sigqueue",
2641 sizeof(struct sigqueue),
2642 __alignof__(struct sigqueue),
2643 SLAB_PANIC, NULL, NULL);