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/config.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/smp_lock.h>
17 #include <linux/init.h>
18 #include <linux/sched.h>
20 #include <linux/tty.h>
21 #include <linux/binfmts.h>
22 #include <linux/security.h>
23 #include <linux/syscalls.h>
24 #include <linux/ptrace.h>
25 #include <linux/signal.h>
26 #include <linux/audit.h>
27 #include <linux/capability.h>
28 #include <asm/param.h>
29 #include <asm/uaccess.h>
30 #include <asm/unistd.h>
31 #include <asm/siginfo.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);
341 /* Notify the system that a driver wants to block all signals for this
342 * process, and wants to be notified if any signals at all were to be
343 * sent/acted upon. If the notifier routine returns non-zero, then the
344 * signal will be acted upon after all. If the notifier routine returns 0,
345 * then then signal will be blocked. Only one block per process is
346 * allowed. priv is a pointer to private data that the notifier routine
347 * can use to determine if the signal should be blocked or not. */
350 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
354 spin_lock_irqsave(¤t->sighand->siglock, flags);
355 current->notifier_mask = mask;
356 current->notifier_data = priv;
357 current->notifier = notifier;
358 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
361 /* Notify the system that blocking has ended. */
364 unblock_all_signals(void)
368 spin_lock_irqsave(¤t->sighand->siglock, flags);
369 current->notifier = NULL;
370 current->notifier_data = NULL;
372 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
375 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
377 struct sigqueue *q, *first = NULL;
378 int still_pending = 0;
380 if (unlikely(!sigismember(&list->signal, sig)))
384 * Collect the siginfo appropriate to this signal. Check if
385 * there is another siginfo for the same signal.
387 list_for_each_entry(q, &list->list, list) {
388 if (q->info.si_signo == sig) {
397 list_del_init(&first->list);
398 copy_siginfo(info, &first->info);
399 __sigqueue_free(first);
401 sigdelset(&list->signal, sig);
404 /* Ok, it wasn't in the queue. This must be
405 a fast-pathed signal or we must have been
406 out of queue space. So zero out the info.
408 sigdelset(&list->signal, sig);
409 info->si_signo = sig;
418 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
423 sig = next_signal(pending, mask);
425 if (current->notifier) {
426 if (sigismember(current->notifier_mask, sig)) {
427 if (!(current->notifier)(current->notifier_data)) {
428 clear_thread_flag(TIF_SIGPENDING);
434 if (!collect_signal(sig, pending, info))
444 * Dequeue a signal and return the element to the caller, which is
445 * expected to free it.
447 * All callers have to hold the siglock.
449 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
451 int signr = __dequeue_signal(&tsk->pending, mask, info);
453 signr = __dequeue_signal(&tsk->signal->shared_pending,
455 if (signr && unlikely(sig_kernel_stop(signr))) {
457 * Set a marker that we have dequeued a stop signal. Our
458 * caller might release the siglock and then the pending
459 * stop signal it is about to process is no longer in the
460 * pending bitmasks, but must still be cleared by a SIGCONT
461 * (and overruled by a SIGKILL). So those cases clear this
462 * shared flag after we've set it. Note that this flag may
463 * remain set after the signal we return is ignored or
464 * handled. That doesn't matter because its only purpose
465 * is to alert stop-signal processing code when another
466 * processor has come along and cleared the flag.
468 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
469 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
472 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
473 info->si_sys_private){
475 * Release the siglock to ensure proper locking order
476 * of timer locks outside of siglocks. Note, we leave
477 * irqs disabled here, since the posix-timers code is
478 * about to disable them again anyway.
480 spin_unlock(&tsk->sighand->siglock);
481 do_schedule_next_timer(info);
482 spin_lock(&tsk->sighand->siglock);
488 * Tell a process that it has a new active signal..
490 * NOTE! we rely on the previous spin_lock to
491 * lock interrupts for us! We can only be called with
492 * "siglock" held, and the local interrupt must
493 * have been disabled when that got acquired!
495 * No need to set need_resched since signal event passing
496 * goes through ->blocked
498 void signal_wake_up(struct task_struct *t, int resume)
502 set_tsk_thread_flag(t, TIF_SIGPENDING);
505 * For SIGKILL, we want to wake it up in the stopped/traced case.
506 * We don't check t->state here because there is a race with it
507 * executing another processor and just now entering stopped state.
508 * By using wake_up_state, we ensure the process will wake up and
509 * handle its death signal.
511 mask = TASK_INTERRUPTIBLE;
513 mask |= TASK_STOPPED | TASK_TRACED;
514 if (!wake_up_state(t, mask))
519 * Remove signals in mask from the pending set and queue.
520 * Returns 1 if any signals were found.
522 * All callers must be holding the siglock.
524 * This version takes a sigset mask and looks at all signals,
525 * not just those in the first mask word.
527 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
529 struct sigqueue *q, *n;
532 sigandsets(&m, mask, &s->signal);
533 if (sigisemptyset(&m))
536 signandsets(&s->signal, &s->signal, mask);
537 list_for_each_entry_safe(q, n, &s->list, list) {
538 if (sigismember(mask, q->info.si_signo)) {
539 list_del_init(&q->list);
546 * Remove signals in mask from the pending set and queue.
547 * Returns 1 if any signals were found.
549 * All callers must be holding the siglock.
551 static int rm_from_queue(unsigned long mask, struct sigpending *s)
553 struct sigqueue *q, *n;
555 if (!sigtestsetmask(&s->signal, mask))
558 sigdelsetmask(&s->signal, mask);
559 list_for_each_entry_safe(q, n, &s->list, list) {
560 if (q->info.si_signo < SIGRTMIN &&
561 (mask & sigmask(q->info.si_signo))) {
562 list_del_init(&q->list);
570 * Bad permissions for sending the signal
572 static int check_kill_permission(int sig, struct siginfo *info,
573 struct task_struct *t)
576 if (!valid_signal(sig))
579 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
580 && ((sig != SIGCONT) ||
581 (current->signal->session != t->signal->session))
582 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
583 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
584 && !capable(CAP_KILL))
587 error = security_task_kill(t, info, sig);
589 audit_signal_info(sig, t); /* Let audit system see the signal */
594 static void do_notify_parent_cldstop(struct task_struct *tsk,
599 * Handle magic process-wide effects of stop/continue signals.
600 * Unlike the signal actions, these happen immediately at signal-generation
601 * time regardless of blocking, ignoring, or handling. This does the
602 * actual continuing for SIGCONT, but not the actual stopping for stop
603 * signals. The process stop is done as a signal action for SIG_DFL.
605 static void handle_stop_signal(int sig, struct task_struct *p)
607 struct task_struct *t;
609 if (p->signal->flags & SIGNAL_GROUP_EXIT)
611 * The process is in the middle of dying already.
615 if (sig_kernel_stop(sig)) {
617 * This is a stop signal. Remove SIGCONT from all queues.
619 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
622 rm_from_queue(sigmask(SIGCONT), &t->pending);
625 } else if (sig == SIGCONT) {
627 * Remove all stop signals from all queues,
628 * and wake all threads.
630 if (unlikely(p->signal->group_stop_count > 0)) {
632 * There was a group stop in progress. We'll
633 * pretend it finished before we got here. We are
634 * obliged to report it to the parent: if the
635 * SIGSTOP happened "after" this SIGCONT, then it
636 * would have cleared this pending SIGCONT. If it
637 * happened "before" this SIGCONT, then the parent
638 * got the SIGCHLD about the stop finishing before
639 * the continue happened. We do the notification
640 * now, and it's as if the stop had finished and
641 * the SIGCHLD was pending on entry to this kill.
643 p->signal->group_stop_count = 0;
644 p->signal->flags = SIGNAL_STOP_CONTINUED;
645 spin_unlock(&p->sighand->siglock);
646 do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_STOPPED);
647 spin_lock(&p->sighand->siglock);
649 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
653 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
656 * If there is a handler for SIGCONT, we must make
657 * sure that no thread returns to user mode before
658 * we post the signal, in case it was the only
659 * thread eligible to run the signal handler--then
660 * it must not do anything between resuming and
661 * running the handler. With the TIF_SIGPENDING
662 * flag set, the thread will pause and acquire the
663 * siglock that we hold now and until we've queued
664 * the pending signal.
666 * Wake up the stopped thread _after_ setting
669 state = TASK_STOPPED;
670 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
671 set_tsk_thread_flag(t, TIF_SIGPENDING);
672 state |= TASK_INTERRUPTIBLE;
674 wake_up_state(t, state);
679 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
681 * We were in fact stopped, and are now continued.
682 * Notify the parent with CLD_CONTINUED.
684 p->signal->flags = SIGNAL_STOP_CONTINUED;
685 p->signal->group_exit_code = 0;
686 spin_unlock(&p->sighand->siglock);
687 do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_CONTINUED);
688 spin_lock(&p->sighand->siglock);
691 * We are not stopped, but there could be a stop
692 * signal in the middle of being processed after
693 * being removed from the queue. Clear that too.
695 p->signal->flags = 0;
697 } else if (sig == SIGKILL) {
699 * Make sure that any pending stop signal already dequeued
700 * is undone by the wakeup for SIGKILL.
702 p->signal->flags = 0;
706 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
707 struct sigpending *signals)
709 struct sigqueue * q = NULL;
713 * fast-pathed signals for kernel-internal things like SIGSTOP
716 if (info == SEND_SIG_FORCED)
719 /* Real-time signals must be queued if sent by sigqueue, or
720 some other real-time mechanism. It is implementation
721 defined whether kill() does so. We attempt to do so, on
722 the principle of least surprise, but since kill is not
723 allowed to fail with EAGAIN when low on memory we just
724 make sure at least one signal gets delivered and don't
725 pass on the info struct. */
727 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
728 (is_si_special(info) ||
729 info->si_code >= 0)));
731 list_add_tail(&q->list, &signals->list);
732 switch ((unsigned long) info) {
733 case (unsigned long) SEND_SIG_NOINFO:
734 q->info.si_signo = sig;
735 q->info.si_errno = 0;
736 q->info.si_code = SI_USER;
737 q->info.si_pid = current->pid;
738 q->info.si_uid = current->uid;
740 case (unsigned long) SEND_SIG_PRIV:
741 q->info.si_signo = sig;
742 q->info.si_errno = 0;
743 q->info.si_code = SI_KERNEL;
748 copy_siginfo(&q->info, info);
751 } else if (!is_si_special(info)) {
752 if (sig >= SIGRTMIN && info->si_code != SI_USER)
754 * Queue overflow, abort. We may abort if the signal was rt
755 * and sent by user using something other than kill().
761 sigaddset(&signals->signal, sig);
765 #define LEGACY_QUEUE(sigptr, sig) \
766 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
770 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
774 if (!irqs_disabled())
776 assert_spin_locked(&t->sighand->siglock);
778 /* Short-circuit ignored signals. */
779 if (sig_ignored(t, sig))
782 /* Support queueing exactly one non-rt signal, so that we
783 can get more detailed information about the cause of
785 if (LEGACY_QUEUE(&t->pending, sig))
788 ret = send_signal(sig, info, t, &t->pending);
789 if (!ret && !sigismember(&t->blocked, sig))
790 signal_wake_up(t, sig == SIGKILL);
796 * Force a signal that the process can't ignore: if necessary
797 * we unblock the signal and change any SIG_IGN to SIG_DFL.
801 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
803 unsigned long int flags;
806 spin_lock_irqsave(&t->sighand->siglock, flags);
807 if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
808 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
810 if (sigismember(&t->blocked, sig)) {
811 sigdelset(&t->blocked, sig);
813 recalc_sigpending_tsk(t);
814 ret = specific_send_sig_info(sig, info, t);
815 spin_unlock_irqrestore(&t->sighand->siglock, flags);
821 force_sig_specific(int sig, struct task_struct *t)
823 force_sig_info(sig, SEND_SIG_FORCED, t);
827 * Test if P wants to take SIG. After we've checked all threads with this,
828 * it's equivalent to finding no threads not blocking SIG. Any threads not
829 * blocking SIG were ruled out because they are not running and already
830 * have pending signals. Such threads will dequeue from the shared queue
831 * as soon as they're available, so putting the signal on the shared queue
832 * will be equivalent to sending it to one such thread.
834 static inline int wants_signal(int sig, struct task_struct *p)
836 if (sigismember(&p->blocked, sig))
838 if (p->flags & PF_EXITING)
842 if (p->state & (TASK_STOPPED | TASK_TRACED))
844 return task_curr(p) || !signal_pending(p);
848 __group_complete_signal(int sig, struct task_struct *p)
850 struct task_struct *t;
853 * Now find a thread we can wake up to take the signal off the queue.
855 * If the main thread wants the signal, it gets first crack.
856 * Probably the least surprising to the average bear.
858 if (wants_signal(sig, p))
860 else if (thread_group_empty(p))
862 * There is just one thread and it does not need to be woken.
863 * It will dequeue unblocked signals before it runs again.
868 * Otherwise try to find a suitable thread.
870 t = p->signal->curr_target;
872 /* restart balancing at this thread */
873 t = p->signal->curr_target = p;
874 BUG_ON(t->tgid != p->tgid);
876 while (!wants_signal(sig, t)) {
878 if (t == p->signal->curr_target)
880 * No thread needs to be woken.
881 * Any eligible threads will see
882 * the signal in the queue soon.
886 p->signal->curr_target = t;
890 * Found a killable thread. If the signal will be fatal,
891 * then start taking the whole group down immediately.
893 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
894 !sigismember(&t->real_blocked, sig) &&
895 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
897 * This signal will be fatal to the whole group.
899 if (!sig_kernel_coredump(sig)) {
901 * Start a group exit and wake everybody up.
902 * This way we don't have other threads
903 * running and doing things after a slower
904 * thread has the fatal signal pending.
906 p->signal->flags = SIGNAL_GROUP_EXIT;
907 p->signal->group_exit_code = sig;
908 p->signal->group_stop_count = 0;
911 sigaddset(&t->pending.signal, SIGKILL);
912 signal_wake_up(t, 1);
919 * There will be a core dump. We make all threads other
920 * than the chosen one go into a group stop so that nothing
921 * happens until it gets scheduled, takes the signal off
922 * the shared queue, and does the core dump. This is a
923 * little more complicated than strictly necessary, but it
924 * keeps the signal state that winds up in the core dump
925 * unchanged from the death state, e.g. which thread had
926 * the core-dump signal unblocked.
928 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
929 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
930 p->signal->group_stop_count = 0;
931 p->signal->group_exit_task = t;
934 p->signal->group_stop_count++;
935 signal_wake_up(t, 0);
938 wake_up_process(p->signal->group_exit_task);
943 * The signal is already in the shared-pending queue.
944 * Tell the chosen thread to wake up and dequeue it.
946 signal_wake_up(t, sig == SIGKILL);
951 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
955 assert_spin_locked(&p->sighand->siglock);
956 handle_stop_signal(sig, p);
958 /* Short-circuit ignored signals. */
959 if (sig_ignored(p, sig))
962 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
963 /* This is a non-RT signal and we already have one queued. */
967 * Put this signal on the shared-pending queue, or fail with EAGAIN.
968 * We always use the shared queue for process-wide signals,
969 * to avoid several races.
971 ret = send_signal(sig, info, p, &p->signal->shared_pending);
975 __group_complete_signal(sig, p);
980 * Nuke all other threads in the group.
982 void zap_other_threads(struct task_struct *p)
984 struct task_struct *t;
986 p->signal->flags = SIGNAL_GROUP_EXIT;
987 p->signal->group_stop_count = 0;
989 if (thread_group_empty(p))
992 for (t = next_thread(p); t != p; t = next_thread(t)) {
994 * Don't bother with already dead threads
1000 * We don't want to notify the parent, since we are
1001 * killed as part of a thread group due to another
1002 * thread doing an execve() or similar. So set the
1003 * exit signal to -1 to allow immediate reaping of
1004 * the process. But don't detach the thread group
1007 if (t != p->group_leader)
1008 t->exit_signal = -1;
1010 /* SIGKILL will be handled before any pending SIGSTOP */
1011 sigaddset(&t->pending.signal, SIGKILL);
1012 signal_wake_up(t, 1);
1017 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1019 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1021 struct sighand_struct *sighand;
1024 sighand = rcu_dereference(tsk->sighand);
1025 if (unlikely(sighand == NULL))
1028 spin_lock_irqsave(&sighand->siglock, *flags);
1029 if (likely(sighand == tsk->sighand))
1031 spin_unlock_irqrestore(&sighand->siglock, *flags);
1037 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1039 unsigned long flags;
1042 ret = check_kill_permission(sig, info, p);
1046 if (lock_task_sighand(p, &flags)) {
1047 ret = __group_send_sig_info(sig, info, p);
1048 unlock_task_sighand(p, &flags);
1056 * kill_pg_info() sends a signal to a process group: this is what the tty
1057 * control characters do (^C, ^Z etc)
1060 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1062 struct task_struct *p = NULL;
1063 int retval, success;
1070 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1071 int err = group_send_sig_info(sig, info, p);
1074 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1075 return success ? 0 : retval;
1079 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1083 read_lock(&tasklist_lock);
1084 retval = __kill_pg_info(sig, info, pgrp);
1085 read_unlock(&tasklist_lock);
1091 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1094 int acquired_tasklist_lock = 0;
1095 struct task_struct *p;
1098 if (unlikely(sig_needs_tasklist(sig))) {
1099 read_lock(&tasklist_lock);
1100 acquired_tasklist_lock = 1;
1102 p = find_task_by_pid(pid);
1105 error = group_send_sig_info(sig, info, p);
1106 if (unlikely(acquired_tasklist_lock))
1107 read_unlock(&tasklist_lock);
1112 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1113 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1114 uid_t uid, uid_t euid)
1117 struct task_struct *p;
1119 if (!valid_signal(sig))
1122 read_lock(&tasklist_lock);
1123 p = find_task_by_pid(pid);
1128 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1129 && (euid != p->suid) && (euid != p->uid)
1130 && (uid != p->suid) && (uid != p->uid)) {
1134 if (sig && p->sighand) {
1135 unsigned long flags;
1136 spin_lock_irqsave(&p->sighand->siglock, flags);
1137 ret = __group_send_sig_info(sig, info, p);
1138 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1141 read_unlock(&tasklist_lock);
1144 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1147 * kill_something_info() interprets pid in interesting ways just like kill(2).
1149 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1150 * is probably wrong. Should make it like BSD or SYSV.
1153 static int kill_something_info(int sig, struct siginfo *info, int pid)
1156 return kill_pg_info(sig, info, process_group(current));
1157 } else if (pid == -1) {
1158 int retval = 0, count = 0;
1159 struct task_struct * p;
1161 read_lock(&tasklist_lock);
1162 for_each_process(p) {
1163 if (p->pid > 1 && p->tgid != current->tgid) {
1164 int err = group_send_sig_info(sig, info, p);
1170 read_unlock(&tasklist_lock);
1171 return count ? retval : -ESRCH;
1172 } else if (pid < 0) {
1173 return kill_pg_info(sig, info, -pid);
1175 return kill_proc_info(sig, info, pid);
1180 * These are for backward compatibility with the rest of the kernel source.
1184 * These two are the most common entry points. They send a signal
1185 * just to the specific thread.
1188 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1191 unsigned long flags;
1194 * Make sure legacy kernel users don't send in bad values
1195 * (normal paths check this in check_kill_permission).
1197 if (!valid_signal(sig))
1201 * We need the tasklist lock even for the specific
1202 * thread case (when we don't need to follow the group
1203 * lists) in order to avoid races with "p->sighand"
1204 * going away or changing from under us.
1206 read_lock(&tasklist_lock);
1207 spin_lock_irqsave(&p->sighand->siglock, flags);
1208 ret = specific_send_sig_info(sig, info, p);
1209 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1210 read_unlock(&tasklist_lock);
1214 #define __si_special(priv) \
1215 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1218 send_sig(int sig, struct task_struct *p, int priv)
1220 return send_sig_info(sig, __si_special(priv), p);
1224 * This is the entry point for "process-wide" signals.
1225 * They will go to an appropriate thread in the thread group.
1228 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1231 read_lock(&tasklist_lock);
1232 ret = group_send_sig_info(sig, info, p);
1233 read_unlock(&tasklist_lock);
1238 force_sig(int sig, struct task_struct *p)
1240 force_sig_info(sig, SEND_SIG_PRIV, p);
1244 * When things go south during signal handling, we
1245 * will force a SIGSEGV. And if the signal that caused
1246 * the problem was already a SIGSEGV, we'll want to
1247 * make sure we don't even try to deliver the signal..
1250 force_sigsegv(int sig, struct task_struct *p)
1252 if (sig == SIGSEGV) {
1253 unsigned long flags;
1254 spin_lock_irqsave(&p->sighand->siglock, flags);
1255 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1256 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1258 force_sig(SIGSEGV, p);
1263 kill_pg(pid_t pgrp, int sig, int priv)
1265 return kill_pg_info(sig, __si_special(priv), pgrp);
1269 kill_proc(pid_t pid, int sig, int priv)
1271 return kill_proc_info(sig, __si_special(priv), pid);
1275 * These functions support sending signals using preallocated sigqueue
1276 * structures. This is needed "because realtime applications cannot
1277 * afford to lose notifications of asynchronous events, like timer
1278 * expirations or I/O completions". In the case of Posix Timers
1279 * we allocate the sigqueue structure from the timer_create. If this
1280 * allocation fails we are able to report the failure to the application
1281 * with an EAGAIN error.
1284 struct sigqueue *sigqueue_alloc(void)
1288 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1289 q->flags |= SIGQUEUE_PREALLOC;
1293 void sigqueue_free(struct sigqueue *q)
1295 unsigned long flags;
1296 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1298 * If the signal is still pending remove it from the
1301 if (unlikely(!list_empty(&q->list))) {
1302 spinlock_t *lock = ¤t->sighand->siglock;
1303 read_lock(&tasklist_lock);
1304 spin_lock_irqsave(lock, flags);
1305 if (!list_empty(&q->list))
1306 list_del_init(&q->list);
1307 spin_unlock_irqrestore(lock, flags);
1308 read_unlock(&tasklist_lock);
1310 q->flags &= ~SIGQUEUE_PREALLOC;
1315 send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1317 unsigned long flags;
1319 struct sighand_struct *sh;
1321 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1324 * The rcu based delayed sighand destroy makes it possible to
1325 * run this without tasklist lock held. The task struct itself
1326 * cannot go away as create_timer did get_task_struct().
1328 * We return -1, when the task is marked exiting, so
1329 * posix_timer_event can redirect it to the group leader
1333 if (unlikely(p->flags & PF_EXITING)) {
1339 sh = rcu_dereference(p->sighand);
1341 spin_lock_irqsave(&sh->siglock, flags);
1342 if (p->sighand != sh) {
1343 /* We raced with exec() in a multithreaded process... */
1344 spin_unlock_irqrestore(&sh->siglock, flags);
1349 * We do the check here again to handle the following scenario:
1354 * interrupt exit code running
1356 * lock sighand->siglock
1357 * unlock sighand->siglock
1359 * add(tsk->pending) flush_sigqueue(tsk->pending)
1363 if (unlikely(p->flags & PF_EXITING)) {
1368 if (unlikely(!list_empty(&q->list))) {
1370 * If an SI_TIMER entry is already queue just increment
1371 * the overrun count.
1373 if (q->info.si_code != SI_TIMER)
1375 q->info.si_overrun++;
1378 /* Short-circuit ignored signals. */
1379 if (sig_ignored(p, sig)) {
1384 list_add_tail(&q->list, &p->pending.list);
1385 sigaddset(&p->pending.signal, sig);
1386 if (!sigismember(&p->blocked, sig))
1387 signal_wake_up(p, sig == SIGKILL);
1390 spin_unlock_irqrestore(&sh->siglock, flags);
1398 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1400 unsigned long flags;
1403 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1405 read_lock(&tasklist_lock);
1406 /* Since it_lock is held, p->sighand cannot be NULL. */
1407 spin_lock_irqsave(&p->sighand->siglock, flags);
1408 handle_stop_signal(sig, p);
1410 /* Short-circuit ignored signals. */
1411 if (sig_ignored(p, sig)) {
1416 if (unlikely(!list_empty(&q->list))) {
1418 * If an SI_TIMER entry is already queue just increment
1419 * the overrun count. Other uses should not try to
1420 * send the signal multiple times.
1422 if (q->info.si_code != SI_TIMER)
1424 q->info.si_overrun++;
1429 * Put this signal on the shared-pending queue.
1430 * We always use the shared queue for process-wide signals,
1431 * to avoid several races.
1433 list_add_tail(&q->list, &p->signal->shared_pending.list);
1434 sigaddset(&p->signal->shared_pending.signal, sig);
1436 __group_complete_signal(sig, p);
1438 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1439 read_unlock(&tasklist_lock);
1444 * Wake up any threads in the parent blocked in wait* syscalls.
1446 static inline void __wake_up_parent(struct task_struct *p,
1447 struct task_struct *parent)
1449 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1453 * Let a parent know about the death of a child.
1454 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1457 void do_notify_parent(struct task_struct *tsk, int sig)
1459 struct siginfo info;
1460 unsigned long flags;
1461 struct sighand_struct *psig;
1465 /* do_notify_parent_cldstop should have been called instead. */
1466 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1468 BUG_ON(!tsk->ptrace &&
1469 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1471 info.si_signo = sig;
1473 info.si_pid = tsk->pid;
1474 info.si_uid = tsk->uid;
1476 /* FIXME: find out whether or not this is supposed to be c*time. */
1477 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1478 tsk->signal->utime));
1479 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1480 tsk->signal->stime));
1482 info.si_status = tsk->exit_code & 0x7f;
1483 if (tsk->exit_code & 0x80)
1484 info.si_code = CLD_DUMPED;
1485 else if (tsk->exit_code & 0x7f)
1486 info.si_code = CLD_KILLED;
1488 info.si_code = CLD_EXITED;
1489 info.si_status = tsk->exit_code >> 8;
1492 psig = tsk->parent->sighand;
1493 spin_lock_irqsave(&psig->siglock, flags);
1494 if (!tsk->ptrace && sig == SIGCHLD &&
1495 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1496 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1498 * We are exiting and our parent doesn't care. POSIX.1
1499 * defines special semantics for setting SIGCHLD to SIG_IGN
1500 * or setting the SA_NOCLDWAIT flag: we should be reaped
1501 * automatically and not left for our parent's wait4 call.
1502 * Rather than having the parent do it as a magic kind of
1503 * signal handler, we just set this to tell do_exit that we
1504 * can be cleaned up without becoming a zombie. Note that
1505 * we still call __wake_up_parent in this case, because a
1506 * blocked sys_wait4 might now return -ECHILD.
1508 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1509 * is implementation-defined: we do (if you don't want
1510 * it, just use SIG_IGN instead).
1512 tsk->exit_signal = -1;
1513 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1516 if (valid_signal(sig) && sig > 0)
1517 __group_send_sig_info(sig, &info, tsk->parent);
1518 __wake_up_parent(tsk, tsk->parent);
1519 spin_unlock_irqrestore(&psig->siglock, flags);
1522 static void do_notify_parent_cldstop(struct task_struct *tsk, int to_self, int why)
1524 struct siginfo info;
1525 unsigned long flags;
1526 struct task_struct *parent;
1527 struct sighand_struct *sighand;
1530 parent = tsk->parent;
1532 tsk = tsk->group_leader;
1533 parent = tsk->real_parent;
1536 info.si_signo = SIGCHLD;
1538 info.si_pid = tsk->pid;
1539 info.si_uid = tsk->uid;
1541 /* FIXME: find out whether or not this is supposed to be c*time. */
1542 info.si_utime = cputime_to_jiffies(tsk->utime);
1543 info.si_stime = cputime_to_jiffies(tsk->stime);
1548 info.si_status = SIGCONT;
1551 info.si_status = tsk->signal->group_exit_code & 0x7f;
1554 info.si_status = tsk->exit_code & 0x7f;
1560 sighand = parent->sighand;
1561 spin_lock_irqsave(&sighand->siglock, flags);
1562 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1563 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1564 __group_send_sig_info(SIGCHLD, &info, parent);
1566 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1568 __wake_up_parent(tsk, parent);
1569 spin_unlock_irqrestore(&sighand->siglock, flags);
1573 * This must be called with current->sighand->siglock held.
1575 * This should be the path for all ptrace stops.
1576 * We always set current->last_siginfo while stopped here.
1577 * That makes it a way to test a stopped process for
1578 * being ptrace-stopped vs being job-control-stopped.
1580 * If we actually decide not to stop at all because the tracer is gone,
1581 * we leave nostop_code in current->exit_code.
1583 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1586 * If there is a group stop in progress,
1587 * we must participate in the bookkeeping.
1589 if (current->signal->group_stop_count > 0)
1590 --current->signal->group_stop_count;
1592 current->last_siginfo = info;
1593 current->exit_code = exit_code;
1595 /* Let the debugger run. */
1596 set_current_state(TASK_TRACED);
1597 spin_unlock_irq(¤t->sighand->siglock);
1598 read_lock(&tasklist_lock);
1599 if (likely(current->ptrace & PT_PTRACED) &&
1600 likely(current->parent != current->real_parent ||
1601 !(current->ptrace & PT_ATTACHED)) &&
1602 (likely(current->parent->signal != current->signal) ||
1603 !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
1604 do_notify_parent_cldstop(current, 1, CLD_TRAPPED);
1605 read_unlock(&tasklist_lock);
1609 * By the time we got the lock, our tracer went away.
1612 read_unlock(&tasklist_lock);
1613 set_current_state(TASK_RUNNING);
1614 current->exit_code = nostop_code;
1618 * We are back. Now reacquire the siglock before touching
1619 * last_siginfo, so that we are sure to have synchronized with
1620 * any signal-sending on another CPU that wants to examine it.
1622 spin_lock_irq(¤t->sighand->siglock);
1623 current->last_siginfo = NULL;
1626 * Queued signals ignored us while we were stopped for tracing.
1627 * So check for any that we should take before resuming user mode.
1629 recalc_sigpending();
1632 void ptrace_notify(int exit_code)
1636 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1638 memset(&info, 0, sizeof info);
1639 info.si_signo = SIGTRAP;
1640 info.si_code = exit_code;
1641 info.si_pid = current->pid;
1642 info.si_uid = current->uid;
1644 /* Let the debugger run. */
1645 spin_lock_irq(¤t->sighand->siglock);
1646 ptrace_stop(exit_code, 0, &info);
1647 spin_unlock_irq(¤t->sighand->siglock);
1651 finish_stop(int stop_count)
1656 * If there are no other threads in the group, or if there is
1657 * a group stop in progress and we are the last to stop,
1658 * report to the parent. When ptraced, every thread reports itself.
1660 if (stop_count < 0 || (current->ptrace & PT_PTRACED))
1662 else if (stop_count == 0)
1667 read_lock(&tasklist_lock);
1668 do_notify_parent_cldstop(current, to_self, CLD_STOPPED);
1669 read_unlock(&tasklist_lock);
1674 * Now we don't run again until continued.
1676 current->exit_code = 0;
1680 * This performs the stopping for SIGSTOP and other stop signals.
1681 * We have to stop all threads in the thread group.
1682 * Returns nonzero if we've actually stopped and released the siglock.
1683 * Returns zero if we didn't stop and still hold the siglock.
1686 do_signal_stop(int signr)
1688 struct signal_struct *sig = current->signal;
1689 struct sighand_struct *sighand = current->sighand;
1690 int stop_count = -1;
1692 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1695 if (sig->group_stop_count > 0) {
1697 * There is a group stop in progress. We don't need to
1698 * start another one.
1700 signr = sig->group_exit_code;
1701 stop_count = --sig->group_stop_count;
1702 current->exit_code = signr;
1703 set_current_state(TASK_STOPPED);
1704 if (stop_count == 0)
1705 sig->flags = SIGNAL_STOP_STOPPED;
1706 spin_unlock_irq(&sighand->siglock);
1708 else if (thread_group_empty(current)) {
1710 * Lock must be held through transition to stopped state.
1712 current->exit_code = current->signal->group_exit_code = signr;
1713 set_current_state(TASK_STOPPED);
1714 sig->flags = SIGNAL_STOP_STOPPED;
1715 spin_unlock_irq(&sighand->siglock);
1719 * There is no group stop already in progress.
1720 * We must initiate one now, but that requires
1721 * dropping siglock to get both the tasklist lock
1722 * and siglock again in the proper order. Note that
1723 * this allows an intervening SIGCONT to be posted.
1724 * We need to check for that and bail out if necessary.
1726 struct task_struct *t;
1728 spin_unlock_irq(&sighand->siglock);
1730 /* signals can be posted during this window */
1732 read_lock(&tasklist_lock);
1733 spin_lock_irq(&sighand->siglock);
1735 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED)) {
1737 * Another stop or continue happened while we
1738 * didn't have the lock. We can just swallow this
1739 * signal now. If we raced with a SIGCONT, that
1740 * should have just cleared it now. If we raced
1741 * with another processor delivering a stop signal,
1742 * then the SIGCONT that wakes us up should clear it.
1744 read_unlock(&tasklist_lock);
1748 if (sig->group_stop_count == 0) {
1749 sig->group_exit_code = signr;
1751 for (t = next_thread(current); t != current;
1754 * Setting state to TASK_STOPPED for a group
1755 * stop is always done with the siglock held,
1756 * so this check has no races.
1758 if (!t->exit_state &&
1759 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1761 signal_wake_up(t, 0);
1763 sig->group_stop_count = stop_count;
1766 /* A race with another thread while unlocked. */
1767 signr = sig->group_exit_code;
1768 stop_count = --sig->group_stop_count;
1771 current->exit_code = signr;
1772 set_current_state(TASK_STOPPED);
1773 if (stop_count == 0)
1774 sig->flags = SIGNAL_STOP_STOPPED;
1776 spin_unlock_irq(&sighand->siglock);
1777 read_unlock(&tasklist_lock);
1780 finish_stop(stop_count);
1785 * Do appropriate magic when group_stop_count > 0.
1786 * We return nonzero if we stopped, after releasing the siglock.
1787 * We return zero if we still hold the siglock and should look
1788 * for another signal without checking group_stop_count again.
1790 static int handle_group_stop(void)
1794 if (current->signal->group_exit_task == current) {
1796 * Group stop is so we can do a core dump,
1797 * We are the initiating thread, so get on with it.
1799 current->signal->group_exit_task = NULL;
1803 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1805 * Group stop is so another thread can do a core dump,
1806 * or else we are racing against a death signal.
1807 * Just punt the stop so we can get the next signal.
1812 * There is a group stop in progress. We stop
1813 * without any associated signal being in our queue.
1815 stop_count = --current->signal->group_stop_count;
1816 if (stop_count == 0)
1817 current->signal->flags = SIGNAL_STOP_STOPPED;
1818 current->exit_code = current->signal->group_exit_code;
1819 set_current_state(TASK_STOPPED);
1820 spin_unlock_irq(¤t->sighand->siglock);
1821 finish_stop(stop_count);
1825 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1826 struct pt_regs *regs, void *cookie)
1828 sigset_t *mask = ¤t->blocked;
1834 spin_lock_irq(¤t->sighand->siglock);
1836 struct k_sigaction *ka;
1838 if (unlikely(current->signal->group_stop_count > 0) &&
1839 handle_group_stop())
1842 signr = dequeue_signal(current, mask, info);
1845 break; /* will return 0 */
1847 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1848 ptrace_signal_deliver(regs, cookie);
1850 /* Let the debugger run. */
1851 ptrace_stop(signr, signr, info);
1853 /* We're back. Did the debugger cancel the sig or group_exit? */
1854 signr = current->exit_code;
1855 if (signr == 0 || current->signal->flags & SIGNAL_GROUP_EXIT)
1858 current->exit_code = 0;
1860 /* Update the siginfo structure if the signal has
1861 changed. If the debugger wanted something
1862 specific in the siginfo structure then it should
1863 have updated *info via PTRACE_SETSIGINFO. */
1864 if (signr != info->si_signo) {
1865 info->si_signo = signr;
1867 info->si_code = SI_USER;
1868 info->si_pid = current->parent->pid;
1869 info->si_uid = current->parent->uid;
1872 /* If the (new) signal is now blocked, requeue it. */
1873 if (sigismember(¤t->blocked, signr)) {
1874 specific_send_sig_info(signr, info, current);
1879 ka = ¤t->sighand->action[signr-1];
1880 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1882 if (ka->sa.sa_handler != SIG_DFL) {
1883 /* Run the handler. */
1886 if (ka->sa.sa_flags & SA_ONESHOT)
1887 ka->sa.sa_handler = SIG_DFL;
1889 break; /* will return non-zero "signr" value */
1893 * Now we are doing the default action for this signal.
1895 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1898 /* Init gets no signals it doesn't want. */
1899 if (current == child_reaper)
1902 if (sig_kernel_stop(signr)) {
1904 * The default action is to stop all threads in
1905 * the thread group. The job control signals
1906 * do nothing in an orphaned pgrp, but SIGSTOP
1907 * always works. Note that siglock needs to be
1908 * dropped during the call to is_orphaned_pgrp()
1909 * because of lock ordering with tasklist_lock.
1910 * This allows an intervening SIGCONT to be posted.
1911 * We need to check for that and bail out if necessary.
1913 if (signr != SIGSTOP) {
1914 spin_unlock_irq(¤t->sighand->siglock);
1916 /* signals can be posted during this window */
1918 if (is_orphaned_pgrp(process_group(current)))
1921 spin_lock_irq(¤t->sighand->siglock);
1924 if (likely(do_signal_stop(signr))) {
1925 /* It released the siglock. */
1930 * We didn't actually stop, due to a race
1931 * with SIGCONT or something like that.
1936 spin_unlock_irq(¤t->sighand->siglock);
1939 * Anything else is fatal, maybe with a core dump.
1941 current->flags |= PF_SIGNALED;
1942 if (sig_kernel_coredump(signr)) {
1944 * If it was able to dump core, this kills all
1945 * other threads in the group and synchronizes with
1946 * their demise. If we lost the race with another
1947 * thread getting here, it set group_exit_code
1948 * first and our do_group_exit call below will use
1949 * that value and ignore the one we pass it.
1951 do_coredump((long)signr, signr, regs);
1955 * Death signals, no core dump.
1957 do_group_exit(signr);
1960 spin_unlock_irq(¤t->sighand->siglock);
1964 EXPORT_SYMBOL(recalc_sigpending);
1965 EXPORT_SYMBOL_GPL(dequeue_signal);
1966 EXPORT_SYMBOL(flush_signals);
1967 EXPORT_SYMBOL(force_sig);
1968 EXPORT_SYMBOL(kill_pg);
1969 EXPORT_SYMBOL(kill_proc);
1970 EXPORT_SYMBOL(ptrace_notify);
1971 EXPORT_SYMBOL(send_sig);
1972 EXPORT_SYMBOL(send_sig_info);
1973 EXPORT_SYMBOL(sigprocmask);
1974 EXPORT_SYMBOL(block_all_signals);
1975 EXPORT_SYMBOL(unblock_all_signals);
1979 * System call entry points.
1982 asmlinkage long sys_restart_syscall(void)
1984 struct restart_block *restart = ¤t_thread_info()->restart_block;
1985 return restart->fn(restart);
1988 long do_no_restart_syscall(struct restart_block *param)
1994 * We don't need to get the kernel lock - this is all local to this
1995 * particular thread.. (and that's good, because this is _heavily_
1996 * used by various programs)
2000 * This is also useful for kernel threads that want to temporarily
2001 * (or permanently) block certain signals.
2003 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2004 * interface happily blocks "unblockable" signals like SIGKILL
2007 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2011 spin_lock_irq(¤t->sighand->siglock);
2013 *oldset = current->blocked;
2018 sigorsets(¤t->blocked, ¤t->blocked, set);
2021 signandsets(¤t->blocked, ¤t->blocked, set);
2024 current->blocked = *set;
2029 recalc_sigpending();
2030 spin_unlock_irq(¤t->sighand->siglock);
2036 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2038 int error = -EINVAL;
2039 sigset_t old_set, new_set;
2041 /* XXX: Don't preclude handling different sized sigset_t's. */
2042 if (sigsetsize != sizeof(sigset_t))
2047 if (copy_from_user(&new_set, set, sizeof(*set)))
2049 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2051 error = sigprocmask(how, &new_set, &old_set);
2057 spin_lock_irq(¤t->sighand->siglock);
2058 old_set = current->blocked;
2059 spin_unlock_irq(¤t->sighand->siglock);
2063 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2071 long do_sigpending(void __user *set, unsigned long sigsetsize)
2073 long error = -EINVAL;
2076 if (sigsetsize > sizeof(sigset_t))
2079 spin_lock_irq(¤t->sighand->siglock);
2080 sigorsets(&pending, ¤t->pending.signal,
2081 ¤t->signal->shared_pending.signal);
2082 spin_unlock_irq(¤t->sighand->siglock);
2084 /* Outside the lock because only this thread touches it. */
2085 sigandsets(&pending, ¤t->blocked, &pending);
2088 if (!copy_to_user(set, &pending, sigsetsize))
2096 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2098 return do_sigpending(set, sigsetsize);
2101 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2103 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2107 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2109 if (from->si_code < 0)
2110 return __copy_to_user(to, from, sizeof(siginfo_t))
2113 * If you change siginfo_t structure, please be sure
2114 * this code is fixed accordingly.
2115 * It should never copy any pad contained in the structure
2116 * to avoid security leaks, but must copy the generic
2117 * 3 ints plus the relevant union member.
2119 err = __put_user(from->si_signo, &to->si_signo);
2120 err |= __put_user(from->si_errno, &to->si_errno);
2121 err |= __put_user((short)from->si_code, &to->si_code);
2122 switch (from->si_code & __SI_MASK) {
2124 err |= __put_user(from->si_pid, &to->si_pid);
2125 err |= __put_user(from->si_uid, &to->si_uid);
2128 err |= __put_user(from->si_tid, &to->si_tid);
2129 err |= __put_user(from->si_overrun, &to->si_overrun);
2130 err |= __put_user(from->si_ptr, &to->si_ptr);
2133 err |= __put_user(from->si_band, &to->si_band);
2134 err |= __put_user(from->si_fd, &to->si_fd);
2137 err |= __put_user(from->si_addr, &to->si_addr);
2138 #ifdef __ARCH_SI_TRAPNO
2139 err |= __put_user(from->si_trapno, &to->si_trapno);
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_status, &to->si_status);
2146 err |= __put_user(from->si_utime, &to->si_utime);
2147 err |= __put_user(from->si_stime, &to->si_stime);
2149 case __SI_RT: /* This is not generated by the kernel as of now. */
2150 case __SI_MESGQ: /* But this is */
2151 err |= __put_user(from->si_pid, &to->si_pid);
2152 err |= __put_user(from->si_uid, &to->si_uid);
2153 err |= __put_user(from->si_ptr, &to->si_ptr);
2155 default: /* this is just in case for now ... */
2156 err |= __put_user(from->si_pid, &to->si_pid);
2157 err |= __put_user(from->si_uid, &to->si_uid);
2166 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2167 siginfo_t __user *uinfo,
2168 const struct timespec __user *uts,
2177 /* XXX: Don't preclude handling different sized sigset_t's. */
2178 if (sigsetsize != sizeof(sigset_t))
2181 if (copy_from_user(&these, uthese, sizeof(these)))
2185 * Invert the set of allowed signals to get those we
2188 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2192 if (copy_from_user(&ts, uts, sizeof(ts)))
2194 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2199 spin_lock_irq(¤t->sighand->siglock);
2200 sig = dequeue_signal(current, &these, &info);
2202 timeout = MAX_SCHEDULE_TIMEOUT;
2204 timeout = (timespec_to_jiffies(&ts)
2205 + (ts.tv_sec || ts.tv_nsec));
2208 /* None ready -- temporarily unblock those we're
2209 * interested while we are sleeping in so that we'll
2210 * be awakened when they arrive. */
2211 current->real_blocked = current->blocked;
2212 sigandsets(¤t->blocked, ¤t->blocked, &these);
2213 recalc_sigpending();
2214 spin_unlock_irq(¤t->sighand->siglock);
2216 timeout = schedule_timeout_interruptible(timeout);
2218 spin_lock_irq(¤t->sighand->siglock);
2219 sig = dequeue_signal(current, &these, &info);
2220 current->blocked = current->real_blocked;
2221 siginitset(¤t->real_blocked, 0);
2222 recalc_sigpending();
2225 spin_unlock_irq(¤t->sighand->siglock);
2230 if (copy_siginfo_to_user(uinfo, &info))
2243 sys_kill(int pid, int sig)
2245 struct siginfo info;
2247 info.si_signo = sig;
2249 info.si_code = SI_USER;
2250 info.si_pid = current->tgid;
2251 info.si_uid = current->uid;
2253 return kill_something_info(sig, &info, pid);
2256 static int do_tkill(int tgid, int pid, int sig)
2259 struct siginfo info;
2260 struct task_struct *p;
2263 info.si_signo = sig;
2265 info.si_code = SI_TKILL;
2266 info.si_pid = current->tgid;
2267 info.si_uid = current->uid;
2269 read_lock(&tasklist_lock);
2270 p = find_task_by_pid(pid);
2271 if (p && (tgid <= 0 || p->tgid == tgid)) {
2272 error = check_kill_permission(sig, &info, p);
2274 * The null signal is a permissions and process existence
2275 * probe. No signal is actually delivered.
2277 if (!error && sig && p->sighand) {
2278 spin_lock_irq(&p->sighand->siglock);
2279 handle_stop_signal(sig, p);
2280 error = specific_send_sig_info(sig, &info, p);
2281 spin_unlock_irq(&p->sighand->siglock);
2284 read_unlock(&tasklist_lock);
2290 * sys_tgkill - send signal to one specific thread
2291 * @tgid: the thread group ID of the thread
2292 * @pid: the PID of the thread
2293 * @sig: signal to be sent
2295 * This syscall also checks the tgid and returns -ESRCH even if the PID
2296 * exists but it's not belonging to the target process anymore. This
2297 * method solves the problem of threads exiting and PIDs getting reused.
2299 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2301 /* This is only valid for single tasks */
2302 if (pid <= 0 || tgid <= 0)
2305 return do_tkill(tgid, pid, sig);
2309 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2312 sys_tkill(int pid, int sig)
2314 /* This is only valid for single tasks */
2318 return do_tkill(0, pid, sig);
2322 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2326 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2329 /* Not even root can pretend to send signals from the kernel.
2330 Nor can they impersonate a kill(), which adds source info. */
2331 if (info.si_code >= 0)
2333 info.si_signo = sig;
2335 /* POSIX.1b doesn't mention process groups. */
2336 return kill_proc_info(sig, &info, pid);
2340 do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2342 struct k_sigaction *k;
2345 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2348 k = ¤t->sighand->action[sig-1];
2350 spin_lock_irq(¤t->sighand->siglock);
2351 if (signal_pending(current)) {
2353 * If there might be a fatal signal pending on multiple
2354 * threads, make sure we take it before changing the action.
2356 spin_unlock_irq(¤t->sighand->siglock);
2357 return -ERESTARTNOINTR;
2364 sigdelsetmask(&act->sa.sa_mask,
2365 sigmask(SIGKILL) | sigmask(SIGSTOP));
2368 * "Setting a signal action to SIG_IGN for a signal that is
2369 * pending shall cause the pending signal to be discarded,
2370 * whether or not it is blocked."
2372 * "Setting a signal action to SIG_DFL for a signal that is
2373 * pending and whose default action is to ignore the signal
2374 * (for example, SIGCHLD), shall cause the pending signal to
2375 * be discarded, whether or not it is blocked"
2377 if (act->sa.sa_handler == SIG_IGN ||
2378 (act->sa.sa_handler == SIG_DFL &&
2379 sig_kernel_ignore(sig))) {
2381 * This is a fairly rare case, so we only take the
2382 * tasklist_lock once we're sure we'll need it.
2383 * Now we must do this little unlock and relock
2384 * dance to maintain the lock hierarchy.
2386 struct task_struct *t = current;
2387 spin_unlock_irq(&t->sighand->siglock);
2388 read_lock(&tasklist_lock);
2389 spin_lock_irq(&t->sighand->siglock);
2392 sigaddset(&mask, sig);
2393 rm_from_queue_full(&mask, &t->signal->shared_pending);
2395 rm_from_queue_full(&mask, &t->pending);
2396 recalc_sigpending_tsk(t);
2398 } while (t != current);
2399 spin_unlock_irq(¤t->sighand->siglock);
2400 read_unlock(&tasklist_lock);
2407 spin_unlock_irq(¤t->sighand->siglock);
2412 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2418 oss.ss_sp = (void __user *) current->sas_ss_sp;
2419 oss.ss_size = current->sas_ss_size;
2420 oss.ss_flags = sas_ss_flags(sp);
2429 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2430 || __get_user(ss_sp, &uss->ss_sp)
2431 || __get_user(ss_flags, &uss->ss_flags)
2432 || __get_user(ss_size, &uss->ss_size))
2436 if (on_sig_stack(sp))
2442 * Note - this code used to test ss_flags incorrectly
2443 * old code may have been written using ss_flags==0
2444 * to mean ss_flags==SS_ONSTACK (as this was the only
2445 * way that worked) - this fix preserves that older
2448 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2451 if (ss_flags == SS_DISABLE) {
2456 if (ss_size < MINSIGSTKSZ)
2460 current->sas_ss_sp = (unsigned long) ss_sp;
2461 current->sas_ss_size = ss_size;
2466 if (copy_to_user(uoss, &oss, sizeof(oss)))
2475 #ifdef __ARCH_WANT_SYS_SIGPENDING
2478 sys_sigpending(old_sigset_t __user *set)
2480 return do_sigpending(set, sizeof(*set));
2485 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2486 /* Some platforms have their own version with special arguments others
2487 support only sys_rt_sigprocmask. */
2490 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2493 old_sigset_t old_set, new_set;
2497 if (copy_from_user(&new_set, set, sizeof(*set)))
2499 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2501 spin_lock_irq(¤t->sighand->siglock);
2502 old_set = current->blocked.sig[0];
2510 sigaddsetmask(¤t->blocked, new_set);
2513 sigdelsetmask(¤t->blocked, new_set);
2516 current->blocked.sig[0] = new_set;
2520 recalc_sigpending();
2521 spin_unlock_irq(¤t->sighand->siglock);
2527 old_set = current->blocked.sig[0];
2530 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2537 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2539 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2541 sys_rt_sigaction(int sig,
2542 const struct sigaction __user *act,
2543 struct sigaction __user *oact,
2546 struct k_sigaction new_sa, old_sa;
2549 /* XXX: Don't preclude handling different sized sigset_t's. */
2550 if (sigsetsize != sizeof(sigset_t))
2554 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2558 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2561 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2567 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2569 #ifdef __ARCH_WANT_SYS_SGETMASK
2572 * For backwards compatibility. Functionality superseded by sigprocmask.
2578 return current->blocked.sig[0];
2582 sys_ssetmask(int newmask)
2586 spin_lock_irq(¤t->sighand->siglock);
2587 old = current->blocked.sig[0];
2589 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2591 recalc_sigpending();
2592 spin_unlock_irq(¤t->sighand->siglock);
2596 #endif /* __ARCH_WANT_SGETMASK */
2598 #ifdef __ARCH_WANT_SYS_SIGNAL
2600 * For backwards compatibility. Functionality superseded by sigaction.
2602 asmlinkage unsigned long
2603 sys_signal(int sig, __sighandler_t handler)
2605 struct k_sigaction new_sa, old_sa;
2608 new_sa.sa.sa_handler = handler;
2609 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2610 sigemptyset(&new_sa.sa.sa_mask);
2612 ret = do_sigaction(sig, &new_sa, &old_sa);
2614 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2616 #endif /* __ARCH_WANT_SYS_SIGNAL */
2618 #ifdef __ARCH_WANT_SYS_PAUSE
2623 current->state = TASK_INTERRUPTIBLE;
2625 return -ERESTARTNOHAND;
2630 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2631 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2635 /* XXX: Don't preclude handling different sized sigset_t's. */
2636 if (sigsetsize != sizeof(sigset_t))
2639 if (copy_from_user(&newset, unewset, sizeof(newset)))
2641 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2643 spin_lock_irq(¤t->sighand->siglock);
2644 current->saved_sigmask = current->blocked;
2645 current->blocked = newset;
2646 recalc_sigpending();
2647 spin_unlock_irq(¤t->sighand->siglock);
2649 current->state = TASK_INTERRUPTIBLE;
2651 set_thread_flag(TIF_RESTORE_SIGMASK);
2652 return -ERESTARTNOHAND;
2654 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2656 void __init signals_init(void)
2659 kmem_cache_create("sigqueue",
2660 sizeof(struct sigqueue),
2661 __alignof__(struct sigqueue),
2662 SLAB_PANIC, NULL, NULL);