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 <linux/vs_cvirt.h>
29 #include <asm/param.h>
30 #include <asm/uaccess.h>
31 #include <asm/unistd.h>
32 #include <asm/siginfo.h>
35 * SLAB caches for signal bits.
38 static kmem_cache_t *sigqueue_cachep;
41 * In POSIX a signal is sent either to a specific thread (Linux task)
42 * or to the process as a whole (Linux thread group). How the signal
43 * is sent determines whether it's to one thread or the whole group,
44 * which determines which signal mask(s) are involved in blocking it
45 * from being delivered until later. When the signal is delivered,
46 * either it's caught or ignored by a user handler or it has a default
47 * effect that applies to the whole thread group (POSIX process).
49 * The possible effects an unblocked signal set to SIG_DFL can have are:
50 * ignore - Nothing Happens
51 * terminate - kill the process, i.e. all threads in the group,
52 * similar to exit_group. The group leader (only) reports
53 * WIFSIGNALED status to its parent.
54 * coredump - write a core dump file describing all threads using
55 * the same mm and then kill all those threads
56 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
58 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
59 * Other signals when not blocked and set to SIG_DFL behaves as follows.
60 * The job control signals also have other special effects.
62 * +--------------------+------------------+
63 * | POSIX signal | default action |
64 * +--------------------+------------------+
65 * | SIGHUP | terminate |
66 * | SIGINT | terminate |
67 * | SIGQUIT | coredump |
68 * | SIGILL | coredump |
69 * | SIGTRAP | coredump |
70 * | SIGABRT/SIGIOT | coredump |
71 * | SIGBUS | coredump |
72 * | SIGFPE | coredump |
73 * | SIGKILL | terminate(+) |
74 * | SIGUSR1 | terminate |
75 * | SIGSEGV | coredump |
76 * | SIGUSR2 | terminate |
77 * | SIGPIPE | terminate |
78 * | SIGALRM | terminate |
79 * | SIGTERM | terminate |
80 * | SIGCHLD | ignore |
81 * | SIGCONT | ignore(*) |
82 * | SIGSTOP | stop(*)(+) |
83 * | SIGTSTP | stop(*) |
84 * | SIGTTIN | stop(*) |
85 * | SIGTTOU | stop(*) |
87 * | SIGXCPU | coredump |
88 * | SIGXFSZ | coredump |
89 * | SIGVTALRM | terminate |
90 * | SIGPROF | terminate |
91 * | SIGPOLL/SIGIO | terminate |
92 * | SIGSYS/SIGUNUSED | coredump |
93 * | SIGSTKFLT | terminate |
94 * | SIGWINCH | ignore |
95 * | SIGPWR | terminate |
96 * | SIGRTMIN-SIGRTMAX | terminate |
97 * +--------------------+------------------+
98 * | non-POSIX signal | default action |
99 * +--------------------+------------------+
100 * | SIGEMT | coredump |
101 * +--------------------+------------------+
103 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
104 * (*) Special job control effects:
105 * When SIGCONT is sent, it resumes the process (all threads in the group)
106 * from TASK_STOPPED state and also clears any pending/queued stop signals
107 * (any of those marked with "stop(*)"). This happens regardless of blocking,
108 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
109 * any pending/queued SIGCONT signals; this happens regardless of blocking,
110 * catching, or ignored the stop signal, though (except for SIGSTOP) the
111 * default action of stopping the process may happen later or never.
115 #define M_SIGEMT M(SIGEMT)
120 #if SIGRTMIN > BITS_PER_LONG
121 #define M(sig) (1ULL << ((sig)-1))
123 #define M(sig) (1UL << ((sig)-1))
125 #define T(sig, mask) (M(sig) & (mask))
127 #define SIG_KERNEL_ONLY_MASK (\
128 M(SIGKILL) | M(SIGSTOP) )
130 #define SIG_KERNEL_STOP_MASK (\
131 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
133 #define SIG_KERNEL_COREDUMP_MASK (\
134 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
135 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
136 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
138 #define SIG_KERNEL_IGNORE_MASK (\
139 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
141 #define sig_kernel_only(sig) \
142 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
143 #define sig_kernel_coredump(sig) \
144 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
145 #define sig_kernel_ignore(sig) \
146 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
147 #define sig_kernel_stop(sig) \
148 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
150 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
152 #define sig_user_defined(t, signr) \
153 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
154 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
156 #define sig_fatal(t, signr) \
157 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
158 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
160 static int sig_ignored(struct task_struct *t, int sig)
162 void __user * handler;
165 * Tracers always want to know about signals..
167 if (t->ptrace & PT_PTRACED)
171 * Blocked signals are never ignored, since the
172 * signal handler may change by the time it is
175 if (sigismember(&t->blocked, sig))
178 /* Is it explicitly or implicitly ignored? */
179 handler = t->sighand->action[sig-1].sa.sa_handler;
180 return handler == SIG_IGN ||
181 (handler == SIG_DFL && sig_kernel_ignore(sig));
185 * Re-calculate pending state from the set of locally pending
186 * signals, globally pending signals, and blocked signals.
188 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
193 switch (_NSIG_WORDS) {
195 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
196 ready |= signal->sig[i] &~ blocked->sig[i];
199 case 4: ready = signal->sig[3] &~ blocked->sig[3];
200 ready |= signal->sig[2] &~ blocked->sig[2];
201 ready |= signal->sig[1] &~ blocked->sig[1];
202 ready |= signal->sig[0] &~ blocked->sig[0];
205 case 2: ready = signal->sig[1] &~ blocked->sig[1];
206 ready |= signal->sig[0] &~ blocked->sig[0];
209 case 1: ready = signal->sig[0] &~ blocked->sig[0];
214 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
216 fastcall void recalc_sigpending_tsk(struct task_struct *t)
218 if (t->signal->group_stop_count > 0 ||
220 PENDING(&t->pending, &t->blocked) ||
221 PENDING(&t->signal->shared_pending, &t->blocked))
222 set_tsk_thread_flag(t, TIF_SIGPENDING);
224 clear_tsk_thread_flag(t, TIF_SIGPENDING);
227 void recalc_sigpending(void)
229 recalc_sigpending_tsk(current);
232 /* Given the mask, find the first available signal that should be serviced. */
235 next_signal(struct sigpending *pending, sigset_t *mask)
237 unsigned long i, *s, *m, x;
240 s = pending->signal.sig;
242 switch (_NSIG_WORDS) {
244 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
245 if ((x = *s &~ *m) != 0) {
246 sig = ffz(~x) + i*_NSIG_BPW + 1;
251 case 2: if ((x = s[0] &~ m[0]) != 0)
253 else if ((x = s[1] &~ m[1]) != 0)
260 case 1: if ((x = *s &~ *m) != 0)
268 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
271 struct sigqueue *q = NULL;
273 atomic_inc(&t->user->sigpending);
274 if (override_rlimit ||
275 atomic_read(&t->user->sigpending) <=
276 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
277 q = kmem_cache_alloc(sigqueue_cachep, flags);
278 if (unlikely(q == NULL)) {
279 atomic_dec(&t->user->sigpending);
281 INIT_LIST_HEAD(&q->list);
283 q->user = get_uid(t->user);
288 static void __sigqueue_free(struct sigqueue *q)
290 if (q->flags & SIGQUEUE_PREALLOC)
292 atomic_dec(&q->user->sigpending);
294 kmem_cache_free(sigqueue_cachep, q);
297 void flush_sigqueue(struct sigpending *queue)
301 sigemptyset(&queue->signal);
302 while (!list_empty(&queue->list)) {
303 q = list_entry(queue->list.next, struct sigqueue , list);
304 list_del_init(&q->list);
310 * Flush all pending signals for a task.
312 void flush_signals(struct task_struct *t)
316 spin_lock_irqsave(&t->sighand->siglock, flags);
317 clear_tsk_thread_flag(t,TIF_SIGPENDING);
318 flush_sigqueue(&t->pending);
319 flush_sigqueue(&t->signal->shared_pending);
320 spin_unlock_irqrestore(&t->sighand->siglock, flags);
324 * Flush all handlers for a task.
328 flush_signal_handlers(struct task_struct *t, int force_default)
331 struct k_sigaction *ka = &t->sighand->action[0];
332 for (i = _NSIG ; i != 0 ; i--) {
333 if (force_default || ka->sa.sa_handler != SIG_IGN)
334 ka->sa.sa_handler = SIG_DFL;
336 sigemptyset(&ka->sa.sa_mask);
341 EXPORT_SYMBOL_GPL(flush_signal_handlers);
343 /* Notify the system that a driver wants to block all signals for this
344 * process, and wants to be notified if any signals at all were to be
345 * sent/acted upon. If the notifier routine returns non-zero, then the
346 * signal will be acted upon after all. If the notifier routine returns 0,
347 * then then signal will be blocked. Only one block per process is
348 * allowed. priv is a pointer to private data that the notifier routine
349 * can use to determine if the signal should be blocked or not. */
352 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
356 spin_lock_irqsave(¤t->sighand->siglock, flags);
357 current->notifier_mask = mask;
358 current->notifier_data = priv;
359 current->notifier = notifier;
360 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
363 /* Notify the system that blocking has ended. */
366 unblock_all_signals(void)
370 spin_lock_irqsave(¤t->sighand->siglock, flags);
371 current->notifier = NULL;
372 current->notifier_data = NULL;
374 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
377 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
379 struct sigqueue *q, *first = NULL;
380 int still_pending = 0;
382 if (unlikely(!sigismember(&list->signal, sig)))
386 * Collect the siginfo appropriate to this signal. Check if
387 * there is another siginfo for the same signal.
389 list_for_each_entry(q, &list->list, list) {
390 if (q->info.si_signo == sig) {
399 list_del_init(&first->list);
400 copy_siginfo(info, &first->info);
401 __sigqueue_free(first);
403 sigdelset(&list->signal, sig);
406 /* Ok, it wasn't in the queue. This must be
407 a fast-pathed signal or we must have been
408 out of queue space. So zero out the info.
410 sigdelset(&list->signal, sig);
411 info->si_signo = sig;
420 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
425 sig = next_signal(pending, mask);
427 if (current->notifier) {
428 if (sigismember(current->notifier_mask, sig)) {
429 if (!(current->notifier)(current->notifier_data)) {
430 clear_thread_flag(TIF_SIGPENDING);
436 if (!collect_signal(sig, pending, info))
446 * Dequeue a signal and return the element to the caller, which is
447 * expected to free it.
449 * All callers have to hold the siglock.
451 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
453 int signr = __dequeue_signal(&tsk->pending, mask, info);
455 signr = __dequeue_signal(&tsk->signal->shared_pending,
457 if (signr && unlikely(sig_kernel_stop(signr))) {
459 * Set a marker that we have dequeued a stop signal. Our
460 * caller might release the siglock and then the pending
461 * stop signal it is about to process is no longer in the
462 * pending bitmasks, but must still be cleared by a SIGCONT
463 * (and overruled by a SIGKILL). So those cases clear this
464 * shared flag after we've set it. Note that this flag may
465 * remain set after the signal we return is ignored or
466 * handled. That doesn't matter because its only purpose
467 * is to alert stop-signal processing code when another
468 * processor has come along and cleared the flag.
470 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
471 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
474 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
475 info->si_sys_private){
477 * Release the siglock to ensure proper locking order
478 * of timer locks outside of siglocks. Note, we leave
479 * irqs disabled here, since the posix-timers code is
480 * about to disable them again anyway.
482 spin_unlock(&tsk->sighand->siglock);
483 do_schedule_next_timer(info);
484 spin_lock(&tsk->sighand->siglock);
490 * Tell a process that it has a new active signal..
492 * NOTE! we rely on the previous spin_lock to
493 * lock interrupts for us! We can only be called with
494 * "siglock" held, and the local interrupt must
495 * have been disabled when that got acquired!
497 * No need to set need_resched since signal event passing
498 * goes through ->blocked
500 void signal_wake_up(struct task_struct *t, int resume)
504 set_tsk_thread_flag(t, TIF_SIGPENDING);
507 * For SIGKILL, we want to wake it up in the stopped/traced case.
508 * We don't check t->state here because there is a race with it
509 * executing another processor and just now entering stopped state.
510 * By using wake_up_state, we ensure the process will wake up and
511 * handle its death signal.
513 mask = TASK_INTERRUPTIBLE;
515 mask |= TASK_STOPPED | TASK_TRACED;
516 if (!wake_up_state(t, mask))
521 * Remove signals in mask from the pending set and queue.
522 * Returns 1 if any signals were found.
524 * All callers must be holding the siglock.
526 * This version takes a sigset mask and looks at all signals,
527 * not just those in the first mask word.
529 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
531 struct sigqueue *q, *n;
534 sigandsets(&m, mask, &s->signal);
535 if (sigisemptyset(&m))
538 signandsets(&s->signal, &s->signal, mask);
539 list_for_each_entry_safe(q, n, &s->list, list) {
540 if (sigismember(mask, q->info.si_signo)) {
541 list_del_init(&q->list);
548 * Remove signals in mask from the pending set and queue.
549 * Returns 1 if any signals were found.
551 * All callers must be holding the siglock.
553 static int rm_from_queue(unsigned long mask, struct sigpending *s)
555 struct sigqueue *q, *n;
557 if (!sigtestsetmask(&s->signal, mask))
560 sigdelsetmask(&s->signal, mask);
561 list_for_each_entry_safe(q, n, &s->list, list) {
562 if (q->info.si_signo < SIGRTMIN &&
563 (mask & sigmask(q->info.si_signo))) {
564 list_del_init(&q->list);
572 * Bad permissions for sending the signal
574 static int check_kill_permission(int sig, struct siginfo *info,
575 struct task_struct *t)
580 if (!valid_signal(sig))
583 user = ((info == SEND_SIG_NOINFO) ||
584 (!is_si_special(info) && SI_FROMUSER(info)));
587 if (user && ((sig != SIGCONT) ||
588 (current->signal->session != t->signal->session))
589 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
590 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
591 && !capable(CAP_KILL))
595 if (user && !vx_check(vx_task_xid(t), VX_ADMIN|VX_IDENT))
598 error = security_task_kill(t, info, sig);
600 audit_signal_info(sig, t); /* Let audit system see the signal */
605 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
608 * Handle magic process-wide effects of stop/continue signals.
609 * Unlike the signal actions, these happen immediately at signal-generation
610 * time regardless of blocking, ignoring, or handling. This does the
611 * actual continuing for SIGCONT, but not the actual stopping for stop
612 * signals. The process stop is done as a signal action for SIG_DFL.
614 static void handle_stop_signal(int sig, struct task_struct *p)
616 struct task_struct *t;
618 if (p->signal->flags & SIGNAL_GROUP_EXIT)
620 * The process is in the middle of dying already.
624 if (sig_kernel_stop(sig)) {
626 * This is a stop signal. Remove SIGCONT from all queues.
628 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
631 rm_from_queue(sigmask(SIGCONT), &t->pending);
634 } else if (sig == SIGCONT) {
636 * Remove all stop signals from all queues,
637 * and wake all threads.
639 if (unlikely(p->signal->group_stop_count > 0)) {
641 * There was a group stop in progress. We'll
642 * pretend it finished before we got here. We are
643 * obliged to report it to the parent: if the
644 * SIGSTOP happened "after" this SIGCONT, then it
645 * would have cleared this pending SIGCONT. If it
646 * happened "before" this SIGCONT, then the parent
647 * got the SIGCHLD about the stop finishing before
648 * the continue happened. We do the notification
649 * now, and it's as if the stop had finished and
650 * the SIGCHLD was pending on entry to this kill.
652 p->signal->group_stop_count = 0;
653 p->signal->flags = SIGNAL_STOP_CONTINUED;
654 spin_unlock(&p->sighand->siglock);
655 do_notify_parent_cldstop(p, CLD_STOPPED);
656 spin_lock(&p->sighand->siglock);
658 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
662 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
665 * If there is a handler for SIGCONT, we must make
666 * sure that no thread returns to user mode before
667 * we post the signal, in case it was the only
668 * thread eligible to run the signal handler--then
669 * it must not do anything between resuming and
670 * running the handler. With the TIF_SIGPENDING
671 * flag set, the thread will pause and acquire the
672 * siglock that we hold now and until we've queued
673 * the pending signal.
675 * Wake up the stopped thread _after_ setting
678 state = TASK_STOPPED;
679 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
680 set_tsk_thread_flag(t, TIF_SIGPENDING);
681 state |= TASK_INTERRUPTIBLE;
683 wake_up_state(t, state);
688 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
690 * We were in fact stopped, and are now continued.
691 * Notify the parent with CLD_CONTINUED.
693 p->signal->flags = SIGNAL_STOP_CONTINUED;
694 p->signal->group_exit_code = 0;
695 spin_unlock(&p->sighand->siglock);
696 do_notify_parent_cldstop(p, CLD_CONTINUED);
697 spin_lock(&p->sighand->siglock);
700 * We are not stopped, but there could be a stop
701 * signal in the middle of being processed after
702 * being removed from the queue. Clear that too.
704 p->signal->flags = 0;
706 } else if (sig == SIGKILL) {
708 * Make sure that any pending stop signal already dequeued
709 * is undone by the wakeup for SIGKILL.
711 p->signal->flags = 0;
715 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
716 struct sigpending *signals)
718 struct sigqueue * q = NULL;
722 * fast-pathed signals for kernel-internal things like SIGSTOP
725 if (info == SEND_SIG_FORCED)
728 /* Real-time signals must be queued if sent by sigqueue, or
729 some other real-time mechanism. It is implementation
730 defined whether kill() does so. We attempt to do so, on
731 the principle of least surprise, but since kill is not
732 allowed to fail with EAGAIN when low on memory we just
733 make sure at least one signal gets delivered and don't
734 pass on the info struct. */
736 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
737 (is_si_special(info) ||
738 info->si_code >= 0)));
740 list_add_tail(&q->list, &signals->list);
741 switch ((unsigned long) info) {
742 case (unsigned long) SEND_SIG_NOINFO:
743 q->info.si_signo = sig;
744 q->info.si_errno = 0;
745 q->info.si_code = SI_USER;
746 q->info.si_pid = current->pid;
747 q->info.si_uid = current->uid;
749 case (unsigned long) SEND_SIG_PRIV:
750 q->info.si_signo = sig;
751 q->info.si_errno = 0;
752 q->info.si_code = SI_KERNEL;
757 copy_siginfo(&q->info, info);
760 } else if (!is_si_special(info)) {
761 if (sig >= SIGRTMIN && info->si_code != SI_USER)
763 * Queue overflow, abort. We may abort if the signal was rt
764 * and sent by user using something other than kill().
770 sigaddset(&signals->signal, sig);
774 #define LEGACY_QUEUE(sigptr, sig) \
775 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
777 int print_fatal_signals = 0;
779 static void print_fatal_signal(struct pt_regs *regs, int signr)
781 printk("%s/%d: potentially unexpected fatal signal %d.\n",
782 current->comm, current->pid, signr);
785 printk("code at %08lx: ", regs->eip);
788 for (i = 0; i < 16; i++) {
791 __get_user(insn, (unsigned char *)(regs->eip + i));
792 printk("%02x ", insn);
800 static int __init setup_print_fatal_signals(char *str)
802 get_option (&str, &print_fatal_signals);
807 __setup("print-fatal-signals=", setup_print_fatal_signals);
810 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
814 BUG_ON(!irqs_disabled());
815 assert_spin_locked(&t->sighand->siglock);
817 /* Short-circuit ignored signals. */
818 if (sig_ignored(t, sig))
821 /* Support queueing exactly one non-rt signal, so that we
822 can get more detailed information about the cause of
824 if (LEGACY_QUEUE(&t->pending, sig))
827 ret = send_signal(sig, info, t, &t->pending);
828 if (!ret && !sigismember(&t->blocked, sig))
829 signal_wake_up(t, sig == SIGKILL);
835 * Force a signal that the process can't ignore: if necessary
836 * we unblock the signal and change any SIG_IGN to SIG_DFL.
840 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
842 unsigned long int flags;
845 spin_lock_irqsave(&t->sighand->siglock, flags);
846 if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
847 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
849 if (sigismember(&t->blocked, sig)) {
850 sigdelset(&t->blocked, sig);
852 recalc_sigpending_tsk(t);
853 ret = specific_send_sig_info(sig, info, t);
854 spin_unlock_irqrestore(&t->sighand->siglock, flags);
860 force_sig_specific(int sig, struct task_struct *t)
862 force_sig_info(sig, SEND_SIG_FORCED, t);
866 * Test if P wants to take SIG. After we've checked all threads with this,
867 * it's equivalent to finding no threads not blocking SIG. Any threads not
868 * blocking SIG were ruled out because they are not running and already
869 * have pending signals. Such threads will dequeue from the shared queue
870 * as soon as they're available, so putting the signal on the shared queue
871 * will be equivalent to sending it to one such thread.
873 static inline int wants_signal(int sig, struct task_struct *p)
875 if (sigismember(&p->blocked, sig))
877 if (p->flags & PF_EXITING)
881 if (p->state & (TASK_STOPPED | TASK_TRACED))
883 return task_curr(p) || !signal_pending(p);
887 __group_complete_signal(int sig, struct task_struct *p)
889 struct task_struct *t;
892 * Now find a thread we can wake up to take the signal off the queue.
894 * If the main thread wants the signal, it gets first crack.
895 * Probably the least surprising to the average bear.
897 if (wants_signal(sig, p))
899 else if (thread_group_empty(p))
901 * There is just one thread and it does not need to be woken.
902 * It will dequeue unblocked signals before it runs again.
907 * Otherwise try to find a suitable thread.
909 t = p->signal->curr_target;
911 /* restart balancing at this thread */
912 t = p->signal->curr_target = p;
914 while (!wants_signal(sig, t)) {
916 if (t == p->signal->curr_target)
918 * No thread needs to be woken.
919 * Any eligible threads will see
920 * the signal in the queue soon.
924 p->signal->curr_target = t;
928 * Found a killable thread. If the signal will be fatal,
929 * then start taking the whole group down immediately.
931 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
932 !sigismember(&t->real_blocked, sig) &&
933 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
935 * This signal will be fatal to the whole group.
937 if (!sig_kernel_coredump(sig)) {
939 * Start a group exit and wake everybody up.
940 * This way we don't have other threads
941 * running and doing things after a slower
942 * thread has the fatal signal pending.
944 p->signal->flags = SIGNAL_GROUP_EXIT;
945 p->signal->group_exit_code = sig;
946 p->signal->group_stop_count = 0;
949 sigaddset(&t->pending.signal, SIGKILL);
950 signal_wake_up(t, 1);
957 * There will be a core dump. We make all threads other
958 * than the chosen one go into a group stop so that nothing
959 * happens until it gets scheduled, takes the signal off
960 * the shared queue, and does the core dump. This is a
961 * little more complicated than strictly necessary, but it
962 * keeps the signal state that winds up in the core dump
963 * unchanged from the death state, e.g. which thread had
964 * the core-dump signal unblocked.
966 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
967 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
968 p->signal->group_stop_count = 0;
969 p->signal->group_exit_task = t;
972 p->signal->group_stop_count++;
973 signal_wake_up(t, 0);
976 wake_up_process(p->signal->group_exit_task);
981 * The signal is already in the shared-pending queue.
982 * Tell the chosen thread to wake up and dequeue it.
984 signal_wake_up(t, sig == SIGKILL);
989 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
993 assert_spin_locked(&p->sighand->siglock);
994 handle_stop_signal(sig, p);
996 /* Short-circuit ignored signals. */
997 if (sig_ignored(p, sig))
1000 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
1001 /* This is a non-RT signal and we already have one queued. */
1005 * Put this signal on the shared-pending queue, or fail with EAGAIN.
1006 * We always use the shared queue for process-wide signals,
1007 * to avoid several races.
1009 ret = send_signal(sig, info, p, &p->signal->shared_pending);
1013 __group_complete_signal(sig, p);
1018 * Nuke all other threads in the group.
1020 void zap_other_threads(struct task_struct *p)
1022 struct task_struct *t;
1024 p->signal->flags = SIGNAL_GROUP_EXIT;
1025 p->signal->group_stop_count = 0;
1027 if (thread_group_empty(p))
1030 for (t = next_thread(p); t != p; t = next_thread(t)) {
1032 * Don't bother with already dead threads
1038 * We don't want to notify the parent, since we are
1039 * killed as part of a thread group due to another
1040 * thread doing an execve() or similar. So set the
1041 * exit signal to -1 to allow immediate reaping of
1042 * the process. But don't detach the thread group
1045 if (t != p->group_leader)
1046 t->exit_signal = -1;
1048 /* SIGKILL will be handled before any pending SIGSTOP */
1049 sigaddset(&t->pending.signal, SIGKILL);
1050 signal_wake_up(t, 1);
1055 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1057 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1059 struct sighand_struct *sighand;
1062 sighand = rcu_dereference(tsk->sighand);
1063 if (unlikely(sighand == NULL))
1066 spin_lock_irqsave(&sighand->siglock, *flags);
1067 if (likely(sighand == tsk->sighand))
1069 spin_unlock_irqrestore(&sighand->siglock, *flags);
1075 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1077 unsigned long flags;
1080 ret = check_kill_permission(sig, info, p);
1084 if (lock_task_sighand(p, &flags)) {
1085 ret = __group_send_sig_info(sig, info, p);
1086 unlock_task_sighand(p, &flags);
1094 * kill_pg_info() sends a signal to a process group: this is what the tty
1095 * control characters do (^C, ^Z etc)
1098 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1100 struct task_struct *p = NULL;
1101 int retval, success;
1108 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1109 int err = group_send_sig_info(sig, info, p);
1112 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1113 return success ? 0 : retval;
1117 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1121 read_lock(&tasklist_lock);
1122 retval = __kill_pg_info(sig, info, pgrp);
1123 read_unlock(&tasklist_lock);
1129 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1132 int acquired_tasklist_lock = 0;
1133 struct task_struct *p;
1136 if (unlikely(sig_needs_tasklist(sig))) {
1137 read_lock(&tasklist_lock);
1138 acquired_tasklist_lock = 1;
1140 p = find_task_by_pid(pid);
1143 error = group_send_sig_info(sig, info, p);
1144 if (unlikely(acquired_tasklist_lock))
1145 read_unlock(&tasklist_lock);
1150 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1151 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1152 uid_t uid, uid_t euid)
1155 struct task_struct *p;
1157 if (!valid_signal(sig))
1160 read_lock(&tasklist_lock);
1161 p = find_task_by_pid(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 if (sig && p->sighand) {
1173 unsigned long flags;
1174 spin_lock_irqsave(&p->sighand->siglock, flags);
1175 ret = __group_send_sig_info(sig, info, p);
1176 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1179 read_unlock(&tasklist_lock);
1182 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1185 * kill_something_info() interprets pid in interesting ways just like kill(2).
1187 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1188 * is probably wrong. Should make it like BSD or SYSV.
1191 static int kill_something_info(int sig, struct siginfo *info, int pid)
1194 return kill_pg_info(sig, info, process_group(current));
1195 } else if (pid == -1) {
1196 int retval = 0, count = 0;
1197 struct task_struct * p;
1199 read_lock(&tasklist_lock);
1200 for_each_process(p) {
1201 if (p->pid > 1 && p->tgid != current->tgid) {
1202 int err = group_send_sig_info(sig, info, p);
1208 read_unlock(&tasklist_lock);
1209 return count ? retval : -ESRCH;
1210 } else if (pid < 0) {
1211 return kill_pg_info(sig, info, -pid);
1213 return kill_proc_info(sig, info, pid);
1218 * These are for backward compatibility with the rest of the kernel source.
1222 * These two are the most common entry points. They send a signal
1223 * just to the specific thread.
1226 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1229 unsigned long flags;
1232 * Make sure legacy kernel users don't send in bad values
1233 * (normal paths check this in check_kill_permission).
1235 if (!valid_signal(sig))
1239 * We need the tasklist lock even for the specific
1240 * thread case (when we don't need to follow the group
1241 * lists) in order to avoid races with "p->sighand"
1242 * going away or changing from under us.
1244 read_lock(&tasklist_lock);
1245 spin_lock_irqsave(&p->sighand->siglock, flags);
1246 ret = specific_send_sig_info(sig, info, p);
1247 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1248 read_unlock(&tasklist_lock);
1252 #define __si_special(priv) \
1253 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1256 send_sig(int sig, struct task_struct *p, int priv)
1258 return send_sig_info(sig, __si_special(priv), p);
1262 * This is the entry point for "process-wide" signals.
1263 * They will go to an appropriate thread in the thread group.
1266 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1269 read_lock(&tasklist_lock);
1270 ret = group_send_sig_info(sig, info, p);
1271 read_unlock(&tasklist_lock);
1276 force_sig(int sig, struct task_struct *p)
1278 force_sig_info(sig, SEND_SIG_PRIV, p);
1282 * When things go south during signal handling, we
1283 * will force a SIGSEGV. And if the signal that caused
1284 * the problem was already a SIGSEGV, we'll want to
1285 * make sure we don't even try to deliver the signal..
1288 force_sigsegv(int sig, struct task_struct *p)
1290 if (sig == SIGSEGV) {
1291 unsigned long flags;
1292 spin_lock_irqsave(&p->sighand->siglock, flags);
1293 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1294 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1296 force_sig(SIGSEGV, p);
1301 kill_pg(pid_t pgrp, int sig, int priv)
1303 return kill_pg_info(sig, __si_special(priv), pgrp);
1307 kill_proc(pid_t pid, int sig, int priv)
1309 return kill_proc_info(sig, __si_special(priv), pid);
1313 * These functions support sending signals using preallocated sigqueue
1314 * structures. This is needed "because realtime applications cannot
1315 * afford to lose notifications of asynchronous events, like timer
1316 * expirations or I/O completions". In the case of Posix Timers
1317 * we allocate the sigqueue structure from the timer_create. If this
1318 * allocation fails we are able to report the failure to the application
1319 * with an EAGAIN error.
1322 struct sigqueue *sigqueue_alloc(void)
1326 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1327 q->flags |= SIGQUEUE_PREALLOC;
1331 void sigqueue_free(struct sigqueue *q)
1333 unsigned long flags;
1334 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1336 * If the signal is still pending remove it from the
1339 if (unlikely(!list_empty(&q->list))) {
1340 spinlock_t *lock = ¤t->sighand->siglock;
1341 read_lock(&tasklist_lock);
1342 spin_lock_irqsave(lock, flags);
1343 if (!list_empty(&q->list))
1344 list_del_init(&q->list);
1345 spin_unlock_irqrestore(lock, flags);
1346 read_unlock(&tasklist_lock);
1348 q->flags &= ~SIGQUEUE_PREALLOC;
1352 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1354 unsigned long flags;
1357 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1360 * The rcu based delayed sighand destroy makes it possible to
1361 * run this without tasklist lock held. The task struct itself
1362 * cannot go away as create_timer did get_task_struct().
1364 * We return -1, when the task is marked exiting, so
1365 * posix_timer_event can redirect it to the group leader
1369 if (!likely(lock_task_sighand(p, &flags))) {
1374 if (unlikely(!list_empty(&q->list))) {
1376 * If an SI_TIMER entry is already queue just increment
1377 * the overrun count.
1379 BUG_ON(q->info.si_code != SI_TIMER);
1380 q->info.si_overrun++;
1383 /* Short-circuit ignored signals. */
1384 if (sig_ignored(p, sig)) {
1389 list_add_tail(&q->list, &p->pending.list);
1390 sigaddset(&p->pending.signal, sig);
1391 if (!sigismember(&p->blocked, sig))
1392 signal_wake_up(p, sig == SIGKILL);
1395 unlock_task_sighand(p, &flags);
1403 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1405 unsigned long flags;
1408 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1410 read_lock(&tasklist_lock);
1411 /* Since it_lock is held, p->sighand cannot be NULL. */
1412 spin_lock_irqsave(&p->sighand->siglock, flags);
1413 handle_stop_signal(sig, p);
1415 /* Short-circuit ignored signals. */
1416 if (sig_ignored(p, sig)) {
1421 if (unlikely(!list_empty(&q->list))) {
1423 * If an SI_TIMER entry is already queue just increment
1424 * the overrun count. Other uses should not try to
1425 * send the signal multiple times.
1427 BUG_ON(q->info.si_code != SI_TIMER);
1428 q->info.si_overrun++;
1433 * Put this signal on the shared-pending queue.
1434 * We always use the shared queue for process-wide signals,
1435 * to avoid several races.
1437 list_add_tail(&q->list, &p->signal->shared_pending.list);
1438 sigaddset(&p->signal->shared_pending.signal, sig);
1440 __group_complete_signal(sig, p);
1442 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1443 read_unlock(&tasklist_lock);
1448 * Wake up any threads in the parent blocked in wait* syscalls.
1450 static inline void __wake_up_parent(struct task_struct *p,
1451 struct task_struct *parent)
1453 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1457 * Let a parent know about the death of a child.
1458 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1461 void do_notify_parent(struct task_struct *tsk, int sig)
1463 struct siginfo info;
1464 unsigned long flags;
1465 struct sighand_struct *psig;
1469 /* do_notify_parent_cldstop should have been called instead. */
1470 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1472 BUG_ON(!tsk->ptrace &&
1473 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1475 info.si_signo = sig;
1477 info.si_pid = tsk->pid;
1478 info.si_uid = tsk->uid;
1480 /* FIXME: find out whether or not this is supposed to be c*time. */
1481 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1482 tsk->signal->utime));
1483 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1484 tsk->signal->stime));
1486 info.si_status = tsk->exit_code & 0x7f;
1487 if (tsk->exit_code & 0x80)
1488 info.si_code = CLD_DUMPED;
1489 else if (tsk->exit_code & 0x7f)
1490 info.si_code = CLD_KILLED;
1492 info.si_code = CLD_EXITED;
1493 info.si_status = tsk->exit_code >> 8;
1496 psig = tsk->parent->sighand;
1497 spin_lock_irqsave(&psig->siglock, flags);
1498 if (!tsk->ptrace && sig == SIGCHLD &&
1499 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1500 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1502 * We are exiting and our parent doesn't care. POSIX.1
1503 * defines special semantics for setting SIGCHLD to SIG_IGN
1504 * or setting the SA_NOCLDWAIT flag: we should be reaped
1505 * automatically and not left for our parent's wait4 call.
1506 * Rather than having the parent do it as a magic kind of
1507 * signal handler, we just set this to tell do_exit that we
1508 * can be cleaned up without becoming a zombie. Note that
1509 * we still call __wake_up_parent in this case, because a
1510 * blocked sys_wait4 might now return -ECHILD.
1512 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1513 * is implementation-defined: we do (if you don't want
1514 * it, just use SIG_IGN instead).
1516 tsk->exit_signal = -1;
1517 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1520 if (valid_signal(sig) && sig > 0)
1521 __group_send_sig_info(sig, &info, tsk->parent);
1522 __wake_up_parent(tsk, tsk->parent);
1523 spin_unlock_irqrestore(&psig->siglock, flags);
1526 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1528 struct siginfo info;
1529 unsigned long flags;
1530 struct task_struct *parent;
1531 struct sighand_struct *sighand;
1533 if (tsk->ptrace & PT_PTRACED)
1534 parent = tsk->parent;
1536 tsk = tsk->group_leader;
1537 parent = tsk->real_parent;
1540 info.si_signo = SIGCHLD;
1542 info.si_pid = tsk->pid;
1543 info.si_uid = tsk->uid;
1545 /* FIXME: find out whether or not this is supposed to be c*time. */
1546 info.si_utime = cputime_to_jiffies(tsk->utime);
1547 info.si_stime = cputime_to_jiffies(tsk->stime);
1552 info.si_status = SIGCONT;
1555 info.si_status = tsk->signal->group_exit_code & 0x7f;
1558 info.si_status = tsk->exit_code & 0x7f;
1564 sighand = parent->sighand;
1565 spin_lock_irqsave(&sighand->siglock, flags);
1566 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1567 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1568 __group_send_sig_info(SIGCHLD, &info, parent);
1570 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1572 __wake_up_parent(tsk, parent);
1573 spin_unlock_irqrestore(&sighand->siglock, flags);
1577 * This must be called with current->sighand->siglock held.
1579 * This should be the path for all ptrace stops.
1580 * We always set current->last_siginfo while stopped here.
1581 * That makes it a way to test a stopped process for
1582 * being ptrace-stopped vs being job-control-stopped.
1584 * If we actually decide not to stop at all because the tracer is gone,
1585 * we leave nostop_code in current->exit_code.
1587 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1590 * If there is a group stop in progress,
1591 * we must participate in the bookkeeping.
1593 if (current->signal->group_stop_count > 0)
1594 --current->signal->group_stop_count;
1596 current->last_siginfo = info;
1597 current->exit_code = exit_code;
1599 /* Let the debugger run. */
1600 set_current_state(TASK_TRACED);
1601 spin_unlock_irq(¤t->sighand->siglock);
1603 read_lock(&tasklist_lock);
1604 if (likely(current->ptrace & PT_PTRACED) &&
1605 likely(current->parent != current->real_parent ||
1606 !(current->ptrace & PT_ATTACHED)) &&
1607 (likely(current->parent->signal != current->signal) ||
1608 !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
1609 do_notify_parent_cldstop(current, CLD_TRAPPED);
1610 read_unlock(&tasklist_lock);
1614 * By the time we got the lock, our tracer went away.
1617 read_unlock(&tasklist_lock);
1618 set_current_state(TASK_RUNNING);
1619 current->exit_code = nostop_code;
1623 * We are back. Now reacquire the siglock before touching
1624 * last_siginfo, so that we are sure to have synchronized with
1625 * any signal-sending on another CPU that wants to examine it.
1627 spin_lock_irq(¤t->sighand->siglock);
1628 current->last_siginfo = NULL;
1631 * Queued signals ignored us while we were stopped for tracing.
1632 * So check for any that we should take before resuming user mode.
1634 recalc_sigpending();
1637 void ptrace_notify(int exit_code)
1641 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1643 memset(&info, 0, sizeof info);
1644 info.si_signo = SIGTRAP;
1645 info.si_code = exit_code;
1646 info.si_pid = current->pid;
1647 info.si_uid = current->uid;
1649 /* Let the debugger run. */
1650 spin_lock_irq(¤t->sighand->siglock);
1651 ptrace_stop(exit_code, 0, &info);
1652 spin_unlock_irq(¤t->sighand->siglock);
1656 finish_stop(int stop_count)
1659 * If there are no other threads in the group, or if there is
1660 * a group stop in progress and we are the last to stop,
1661 * report to the parent. When ptraced, every thread reports itself.
1663 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1664 read_lock(&tasklist_lock);
1665 do_notify_parent_cldstop(current, CLD_STOPPED);
1666 read_unlock(&tasklist_lock);
1671 * Now we don't run again until continued.
1673 current->exit_code = 0;
1677 * This performs the stopping for SIGSTOP and other stop signals.
1678 * We have to stop all threads in the thread group.
1679 * Returns nonzero if we've actually stopped and released the siglock.
1680 * Returns zero if we didn't stop and still hold the siglock.
1682 static int do_signal_stop(int signr)
1684 struct signal_struct *sig = current->signal;
1687 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1690 if (sig->group_stop_count > 0) {
1692 * There is a group stop in progress. We don't need to
1693 * start another one.
1695 stop_count = --sig->group_stop_count;
1698 * There is no group stop already in progress.
1699 * We must initiate one now.
1701 struct task_struct *t;
1703 sig->group_exit_code = signr;
1706 for (t = next_thread(current); t != current; t = next_thread(t))
1708 * Setting state to TASK_STOPPED for a group
1709 * stop is always done with the siglock held,
1710 * so this check has no races.
1712 if (!t->exit_state &&
1713 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1715 signal_wake_up(t, 0);
1717 sig->group_stop_count = stop_count;
1720 if (stop_count == 0)
1721 sig->flags = SIGNAL_STOP_STOPPED;
1722 current->exit_code = sig->group_exit_code;
1723 __set_current_state(TASK_STOPPED);
1725 spin_unlock_irq(¤t->sighand->siglock);
1726 finish_stop(stop_count);
1731 * Do appropriate magic when group_stop_count > 0.
1732 * We return nonzero if we stopped, after releasing the siglock.
1733 * We return zero if we still hold the siglock and should look
1734 * for another signal without checking group_stop_count again.
1736 static int handle_group_stop(void)
1740 if (current->signal->group_exit_task == current) {
1742 * Group stop is so we can do a core dump,
1743 * We are the initiating thread, so get on with it.
1745 current->signal->group_exit_task = NULL;
1749 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1751 * Group stop is so another thread can do a core dump,
1752 * or else we are racing against a death signal.
1753 * Just punt the stop so we can get the next signal.
1758 * There is a group stop in progress. We stop
1759 * without any associated signal being in our queue.
1761 stop_count = --current->signal->group_stop_count;
1762 if (stop_count == 0)
1763 current->signal->flags = SIGNAL_STOP_STOPPED;
1764 current->exit_code = current->signal->group_exit_code;
1765 set_current_state(TASK_STOPPED);
1766 spin_unlock_irq(¤t->sighand->siglock);
1767 finish_stop(stop_count);
1771 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1772 struct pt_regs *regs, void *cookie)
1774 sigset_t *mask = ¤t->blocked;
1780 spin_lock_irq(¤t->sighand->siglock);
1782 struct k_sigaction *ka;
1784 if (unlikely(current->signal->group_stop_count > 0) &&
1785 handle_group_stop())
1788 signr = dequeue_signal(current, mask, info);
1791 break; /* will return 0 */
1793 if ((signr == SIGSEGV) && print_fatal_signals) {
1794 spin_unlock_irq(¤t->sighand->siglock);
1795 print_fatal_signal(regs, signr);
1796 spin_lock_irq(¤t->sighand->siglock);
1798 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1799 ptrace_signal_deliver(regs, cookie);
1801 /* Let the debugger run. */
1802 ptrace_stop(signr, signr, info);
1804 /* We're back. Did the debugger cancel the sig? */
1805 signr = current->exit_code;
1809 current->exit_code = 0;
1811 /* Update the siginfo structure if the signal has
1812 changed. If the debugger wanted something
1813 specific in the siginfo structure then it should
1814 have updated *info via PTRACE_SETSIGINFO. */
1815 if (signr != info->si_signo) {
1816 info->si_signo = signr;
1818 info->si_code = SI_USER;
1819 info->si_pid = current->parent->pid;
1820 info->si_uid = current->parent->uid;
1823 /* If the (new) signal is now blocked, requeue it. */
1824 if (sigismember(¤t->blocked, signr)) {
1825 specific_send_sig_info(signr, info, current);
1830 ka = ¤t->sighand->action[signr-1];
1831 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1833 if (ka->sa.sa_handler != SIG_DFL) {
1834 /* Run the handler. */
1837 if (ka->sa.sa_flags & SA_ONESHOT)
1838 ka->sa.sa_handler = SIG_DFL;
1840 break; /* will return non-zero "signr" value */
1844 * Now we are doing the default action for this signal.
1846 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1849 /* Init gets no signals it doesn't want. */
1850 if (current == child_reaper)
1853 /* virtual init is protected against user signals */
1854 if ((info->si_code == SI_USER) &&
1855 vx_current_initpid(current->pid))
1858 if (sig_kernel_stop(signr)) {
1860 * The default action is to stop all threads in
1861 * the thread group. The job control signals
1862 * do nothing in an orphaned pgrp, but SIGSTOP
1863 * always works. Note that siglock needs to be
1864 * dropped during the call to is_orphaned_pgrp()
1865 * because of lock ordering with tasklist_lock.
1866 * This allows an intervening SIGCONT to be posted.
1867 * We need to check for that and bail out if necessary.
1869 if (signr != SIGSTOP) {
1870 spin_unlock_irq(¤t->sighand->siglock);
1872 /* signals can be posted during this window */
1874 if (is_orphaned_pgrp(process_group(current)))
1877 spin_lock_irq(¤t->sighand->siglock);
1880 if (likely(do_signal_stop(signr))) {
1881 /* It released the siglock. */
1886 * We didn't actually stop, due to a race
1887 * with SIGCONT or something like that.
1892 spin_unlock_irq(¤t->sighand->siglock);
1895 * Anything else is fatal, maybe with a core dump.
1897 current->flags |= PF_SIGNALED;
1898 if (print_fatal_signals)
1899 print_fatal_signal(regs, signr);
1900 if (sig_kernel_coredump(signr)) {
1902 * If it was able to dump core, this kills all
1903 * other threads in the group and synchronizes with
1904 * their demise. If we lost the race with another
1905 * thread getting here, it set group_exit_code
1906 * first and our do_group_exit call below will use
1907 * that value and ignore the one we pass it.
1909 do_coredump((long)signr, signr, regs);
1913 * Death signals, no core dump.
1915 do_group_exit(signr);
1918 spin_unlock_irq(¤t->sighand->siglock);
1922 EXPORT_SYMBOL(recalc_sigpending);
1923 EXPORT_SYMBOL_GPL(dequeue_signal);
1924 EXPORT_SYMBOL(flush_signals);
1925 EXPORT_SYMBOL(force_sig);
1926 EXPORT_SYMBOL(kill_pg);
1927 EXPORT_SYMBOL(kill_proc);
1928 EXPORT_SYMBOL(ptrace_notify);
1929 EXPORT_SYMBOL(send_sig);
1930 EXPORT_SYMBOL(send_sig_info);
1931 EXPORT_SYMBOL(sigprocmask);
1932 EXPORT_SYMBOL(block_all_signals);
1933 EXPORT_SYMBOL(unblock_all_signals);
1937 * System call entry points.
1940 asmlinkage long sys_restart_syscall(void)
1942 struct restart_block *restart = ¤t_thread_info()->restart_block;
1943 return restart->fn(restart);
1946 long do_no_restart_syscall(struct restart_block *param)
1952 * We don't need to get the kernel lock - this is all local to this
1953 * particular thread.. (and that's good, because this is _heavily_
1954 * used by various programs)
1958 * This is also useful for kernel threads that want to temporarily
1959 * (or permanently) block certain signals.
1961 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1962 * interface happily blocks "unblockable" signals like SIGKILL
1965 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1969 spin_lock_irq(¤t->sighand->siglock);
1971 *oldset = current->blocked;
1976 sigorsets(¤t->blocked, ¤t->blocked, set);
1979 signandsets(¤t->blocked, ¤t->blocked, set);
1982 current->blocked = *set;
1987 recalc_sigpending();
1988 spin_unlock_irq(¤t->sighand->siglock);
1994 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
1996 int error = -EINVAL;
1997 sigset_t old_set, new_set;
1999 /* XXX: Don't preclude handling different sized sigset_t's. */
2000 if (sigsetsize != sizeof(sigset_t))
2005 if (copy_from_user(&new_set, set, sizeof(*set)))
2007 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2009 error = sigprocmask(how, &new_set, &old_set);
2015 spin_lock_irq(¤t->sighand->siglock);
2016 old_set = current->blocked;
2017 spin_unlock_irq(¤t->sighand->siglock);
2021 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2029 long do_sigpending(void __user *set, unsigned long sigsetsize)
2031 long error = -EINVAL;
2034 if (sigsetsize > sizeof(sigset_t))
2037 spin_lock_irq(¤t->sighand->siglock);
2038 sigorsets(&pending, ¤t->pending.signal,
2039 ¤t->signal->shared_pending.signal);
2040 spin_unlock_irq(¤t->sighand->siglock);
2042 /* Outside the lock because only this thread touches it. */
2043 sigandsets(&pending, ¤t->blocked, &pending);
2046 if (!copy_to_user(set, &pending, sigsetsize))
2054 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2056 return do_sigpending(set, sigsetsize);
2059 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2061 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2065 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2067 if (from->si_code < 0)
2068 return __copy_to_user(to, from, sizeof(siginfo_t))
2071 * If you change siginfo_t structure, please be sure
2072 * this code is fixed accordingly.
2073 * It should never copy any pad contained in the structure
2074 * to avoid security leaks, but must copy the generic
2075 * 3 ints plus the relevant union member.
2077 err = __put_user(from->si_signo, &to->si_signo);
2078 err |= __put_user(from->si_errno, &to->si_errno);
2079 err |= __put_user((short)from->si_code, &to->si_code);
2080 switch (from->si_code & __SI_MASK) {
2082 err |= __put_user(from->si_pid, &to->si_pid);
2083 err |= __put_user(from->si_uid, &to->si_uid);
2086 err |= __put_user(from->si_tid, &to->si_tid);
2087 err |= __put_user(from->si_overrun, &to->si_overrun);
2088 err |= __put_user(from->si_ptr, &to->si_ptr);
2091 err |= __put_user(from->si_band, &to->si_band);
2092 err |= __put_user(from->si_fd, &to->si_fd);
2095 err |= __put_user(from->si_addr, &to->si_addr);
2096 #ifdef __ARCH_SI_TRAPNO
2097 err |= __put_user(from->si_trapno, &to->si_trapno);
2101 err |= __put_user(from->si_pid, &to->si_pid);
2102 err |= __put_user(from->si_uid, &to->si_uid);
2103 err |= __put_user(from->si_status, &to->si_status);
2104 err |= __put_user(from->si_utime, &to->si_utime);
2105 err |= __put_user(from->si_stime, &to->si_stime);
2107 case __SI_RT: /* This is not generated by the kernel as of now. */
2108 case __SI_MESGQ: /* But this is */
2109 err |= __put_user(from->si_pid, &to->si_pid);
2110 err |= __put_user(from->si_uid, &to->si_uid);
2111 err |= __put_user(from->si_ptr, &to->si_ptr);
2113 default: /* this is just in case for now ... */
2114 err |= __put_user(from->si_pid, &to->si_pid);
2115 err |= __put_user(from->si_uid, &to->si_uid);
2124 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2125 siginfo_t __user *uinfo,
2126 const struct timespec __user *uts,
2135 /* XXX: Don't preclude handling different sized sigset_t's. */
2136 if (sigsetsize != sizeof(sigset_t))
2139 if (copy_from_user(&these, uthese, sizeof(these)))
2143 * Invert the set of allowed signals to get those we
2146 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2150 if (copy_from_user(&ts, uts, sizeof(ts)))
2152 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2157 spin_lock_irq(¤t->sighand->siglock);
2158 sig = dequeue_signal(current, &these, &info);
2160 timeout = MAX_SCHEDULE_TIMEOUT;
2162 timeout = (timespec_to_jiffies(&ts)
2163 + (ts.tv_sec || ts.tv_nsec));
2166 /* None ready -- temporarily unblock those we're
2167 * interested while we are sleeping in so that we'll
2168 * be awakened when they arrive. */
2169 current->real_blocked = current->blocked;
2170 sigandsets(¤t->blocked, ¤t->blocked, &these);
2171 recalc_sigpending();
2172 spin_unlock_irq(¤t->sighand->siglock);
2174 timeout = schedule_timeout_interruptible(timeout);
2176 spin_lock_irq(¤t->sighand->siglock);
2177 sig = dequeue_signal(current, &these, &info);
2178 current->blocked = current->real_blocked;
2179 siginitset(¤t->real_blocked, 0);
2180 recalc_sigpending();
2183 spin_unlock_irq(¤t->sighand->siglock);
2188 if (copy_siginfo_to_user(uinfo, &info))
2201 sys_kill(int pid, int sig)
2203 struct siginfo info;
2205 info.si_signo = sig;
2207 info.si_code = SI_USER;
2208 info.si_pid = current->tgid;
2209 info.si_uid = current->uid;
2211 return kill_something_info(sig, &info, pid);
2214 static int do_tkill(int tgid, int pid, int sig)
2217 struct siginfo info;
2218 struct task_struct *p;
2221 info.si_signo = sig;
2223 info.si_code = SI_TKILL;
2224 info.si_pid = current->tgid;
2225 info.si_uid = current->uid;
2227 read_lock(&tasklist_lock);
2228 p = find_task_by_pid(pid);
2229 if (p && (tgid <= 0 || p->tgid == tgid)) {
2230 error = check_kill_permission(sig, &info, p);
2232 * The null signal is a permissions and process existence
2233 * probe. No signal is actually delivered.
2235 if (!error && sig && p->sighand) {
2236 spin_lock_irq(&p->sighand->siglock);
2237 handle_stop_signal(sig, p);
2238 error = specific_send_sig_info(sig, &info, p);
2239 spin_unlock_irq(&p->sighand->siglock);
2242 read_unlock(&tasklist_lock);
2248 * sys_tgkill - send signal to one specific thread
2249 * @tgid: the thread group ID of the thread
2250 * @pid: the PID of the thread
2251 * @sig: signal to be sent
2253 * This syscall also checks the tgid and returns -ESRCH even if the PID
2254 * exists but it's not belonging to the target process anymore. This
2255 * method solves the problem of threads exiting and PIDs getting reused.
2257 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2259 /* This is only valid for single tasks */
2260 if (pid <= 0 || tgid <= 0)
2263 return do_tkill(tgid, pid, sig);
2267 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2270 sys_tkill(int pid, int sig)
2272 /* This is only valid for single tasks */
2276 return do_tkill(0, pid, sig);
2280 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2284 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2287 /* Not even root can pretend to send signals from the kernel.
2288 Nor can they impersonate a kill(), which adds source info. */
2289 if (info.si_code >= 0)
2291 info.si_signo = sig;
2293 /* POSIX.1b doesn't mention process groups. */
2294 return kill_proc_info(sig, &info, pid);
2297 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2299 struct k_sigaction *k;
2302 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2305 k = ¤t->sighand->action[sig-1];
2307 spin_lock_irq(¤t->sighand->siglock);
2308 if (signal_pending(current)) {
2310 * If there might be a fatal signal pending on multiple
2311 * threads, make sure we take it before changing the action.
2313 spin_unlock_irq(¤t->sighand->siglock);
2314 return -ERESTARTNOINTR;
2321 sigdelsetmask(&act->sa.sa_mask,
2322 sigmask(SIGKILL) | sigmask(SIGSTOP));
2326 * "Setting a signal action to SIG_IGN for a signal that is
2327 * pending shall cause the pending signal to be discarded,
2328 * whether or not it is blocked."
2330 * "Setting a signal action to SIG_DFL for a signal that is
2331 * pending and whose default action is to ignore the signal
2332 * (for example, SIGCHLD), shall cause the pending signal to
2333 * be discarded, whether or not it is blocked"
2335 if (act->sa.sa_handler == SIG_IGN ||
2336 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2337 struct task_struct *t = current;
2339 sigaddset(&mask, sig);
2340 rm_from_queue_full(&mask, &t->signal->shared_pending);
2342 rm_from_queue_full(&mask, &t->pending);
2343 recalc_sigpending_tsk(t);
2345 } while (t != current);
2349 spin_unlock_irq(¤t->sighand->siglock);
2354 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2360 oss.ss_sp = (void __user *) current->sas_ss_sp;
2361 oss.ss_size = current->sas_ss_size;
2362 oss.ss_flags = sas_ss_flags(sp);
2371 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2372 || __get_user(ss_sp, &uss->ss_sp)
2373 || __get_user(ss_flags, &uss->ss_flags)
2374 || __get_user(ss_size, &uss->ss_size))
2378 if (on_sig_stack(sp))
2384 * Note - this code used to test ss_flags incorrectly
2385 * old code may have been written using ss_flags==0
2386 * to mean ss_flags==SS_ONSTACK (as this was the only
2387 * way that worked) - this fix preserves that older
2390 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2393 if (ss_flags == SS_DISABLE) {
2398 if (ss_size < MINSIGSTKSZ)
2402 current->sas_ss_sp = (unsigned long) ss_sp;
2403 current->sas_ss_size = ss_size;
2408 if (copy_to_user(uoss, &oss, sizeof(oss)))
2417 #ifdef __ARCH_WANT_SYS_SIGPENDING
2420 sys_sigpending(old_sigset_t __user *set)
2422 return do_sigpending(set, sizeof(*set));
2427 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2428 /* Some platforms have their own version with special arguments others
2429 support only sys_rt_sigprocmask. */
2432 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2435 old_sigset_t old_set, new_set;
2439 if (copy_from_user(&new_set, set, sizeof(*set)))
2441 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2443 spin_lock_irq(¤t->sighand->siglock);
2444 old_set = current->blocked.sig[0];
2452 sigaddsetmask(¤t->blocked, new_set);
2455 sigdelsetmask(¤t->blocked, new_set);
2458 current->blocked.sig[0] = new_set;
2462 recalc_sigpending();
2463 spin_unlock_irq(¤t->sighand->siglock);
2469 old_set = current->blocked.sig[0];
2472 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2479 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2481 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2483 sys_rt_sigaction(int sig,
2484 const struct sigaction __user *act,
2485 struct sigaction __user *oact,
2488 struct k_sigaction new_sa, old_sa;
2491 /* XXX: Don't preclude handling different sized sigset_t's. */
2492 if (sigsetsize != sizeof(sigset_t))
2496 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2500 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2503 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2509 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2511 #ifdef __ARCH_WANT_SYS_SGETMASK
2514 * For backwards compatibility. Functionality superseded by sigprocmask.
2520 return current->blocked.sig[0];
2524 sys_ssetmask(int newmask)
2528 spin_lock_irq(¤t->sighand->siglock);
2529 old = current->blocked.sig[0];
2531 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2533 recalc_sigpending();
2534 spin_unlock_irq(¤t->sighand->siglock);
2538 #endif /* __ARCH_WANT_SGETMASK */
2540 #ifdef __ARCH_WANT_SYS_SIGNAL
2542 * For backwards compatibility. Functionality superseded by sigaction.
2544 asmlinkage unsigned long
2545 sys_signal(int sig, __sighandler_t handler)
2547 struct k_sigaction new_sa, old_sa;
2550 new_sa.sa.sa_handler = handler;
2551 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2552 sigemptyset(&new_sa.sa.sa_mask);
2554 ret = do_sigaction(sig, &new_sa, &old_sa);
2556 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2558 #endif /* __ARCH_WANT_SYS_SIGNAL */
2560 #ifdef __ARCH_WANT_SYS_PAUSE
2565 current->state = TASK_INTERRUPTIBLE;
2567 return -ERESTARTNOHAND;
2572 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2573 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2577 /* XXX: Don't preclude handling different sized sigset_t's. */
2578 if (sigsetsize != sizeof(sigset_t))
2581 if (copy_from_user(&newset, unewset, sizeof(newset)))
2583 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2585 spin_lock_irq(¤t->sighand->siglock);
2586 current->saved_sigmask = current->blocked;
2587 current->blocked = newset;
2588 recalc_sigpending();
2589 spin_unlock_irq(¤t->sighand->siglock);
2591 current->state = TASK_INTERRUPTIBLE;
2593 set_thread_flag(TIF_RESTORE_SIGMASK);
2594 return -ERESTARTNOHAND;
2596 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2598 void __init signals_init(void)
2601 kmem_cache_create("sigqueue",
2602 sizeof(struct sigqueue),
2603 __alignof__(struct sigqueue),
2604 SLAB_PANIC, NULL, NULL);