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/posix-timers.h>
26 #include <linux/signal.h>
27 #include <linux/audit.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_user_defined(t, signr) \
150 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
151 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
153 #define sig_fatal(t, signr) \
154 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
155 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
157 static int sig_ignored(struct task_struct *t, int sig)
159 void __user * handler;
162 * Tracers always want to know about signals..
164 if (t->ptrace & PT_PTRACED)
168 * Blocked signals are never ignored, since the
169 * signal handler may change by the time it is
172 if (sigismember(&t->blocked, sig))
175 /* Is it explicitly or implicitly ignored? */
176 handler = t->sighand->action[sig-1].sa.sa_handler;
177 return handler == SIG_IGN ||
178 (handler == SIG_DFL && sig_kernel_ignore(sig));
182 * Re-calculate pending state from the set of locally pending
183 * signals, globally pending signals, and blocked signals.
185 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
190 switch (_NSIG_WORDS) {
192 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
193 ready |= signal->sig[i] &~ blocked->sig[i];
196 case 4: ready = signal->sig[3] &~ blocked->sig[3];
197 ready |= signal->sig[2] &~ blocked->sig[2];
198 ready |= signal->sig[1] &~ blocked->sig[1];
199 ready |= signal->sig[0] &~ blocked->sig[0];
202 case 2: ready = signal->sig[1] &~ blocked->sig[1];
203 ready |= signal->sig[0] &~ blocked->sig[0];
206 case 1: ready = signal->sig[0] &~ blocked->sig[0];
211 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
213 fastcall void recalc_sigpending_tsk(struct task_struct *t)
215 if (t->signal->group_stop_count > 0 ||
217 PENDING(&t->pending, &t->blocked) ||
218 PENDING(&t->signal->shared_pending, &t->blocked))
219 set_tsk_thread_flag(t, TIF_SIGPENDING);
221 clear_tsk_thread_flag(t, TIF_SIGPENDING);
224 void recalc_sigpending(void)
226 recalc_sigpending_tsk(current);
229 /* Given the mask, find the first available signal that should be serviced. */
232 next_signal(struct sigpending *pending, sigset_t *mask)
234 unsigned long i, *s, *m, x;
237 s = pending->signal.sig;
239 switch (_NSIG_WORDS) {
241 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
242 if ((x = *s &~ *m) != 0) {
243 sig = ffz(~x) + i*_NSIG_BPW + 1;
248 case 2: if ((x = s[0] &~ m[0]) != 0)
250 else if ((x = s[1] &~ m[1]) != 0)
257 case 1: if ((x = *s &~ *m) != 0)
265 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
268 struct sigqueue *q = NULL;
270 atomic_inc(&t->user->sigpending);
271 if (override_rlimit ||
272 atomic_read(&t->user->sigpending) <=
273 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
274 q = kmem_cache_alloc(sigqueue_cachep, flags);
275 if (unlikely(q == NULL)) {
276 atomic_dec(&t->user->sigpending);
278 INIT_LIST_HEAD(&q->list);
280 q->user = get_uid(t->user);
285 static inline void __sigqueue_free(struct sigqueue *q)
287 if (q->flags & SIGQUEUE_PREALLOC)
289 atomic_dec(&q->user->sigpending);
291 kmem_cache_free(sigqueue_cachep, q);
294 static void flush_sigqueue(struct sigpending *queue)
298 sigemptyset(&queue->signal);
299 while (!list_empty(&queue->list)) {
300 q = list_entry(queue->list.next, struct sigqueue , list);
301 list_del_init(&q->list);
307 * Flush all pending signals for a task.
311 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 * This function expects the tasklist_lock write-locked.
325 void __exit_sighand(struct task_struct *tsk)
327 struct sighand_struct * sighand = tsk->sighand;
329 /* Ok, we're done with the signal handlers */
331 if (atomic_dec_and_test(&sighand->count))
332 kmem_cache_free(sighand_cachep, sighand);
335 void exit_sighand(struct task_struct *tsk)
337 write_lock_irq(&tasklist_lock);
339 write_unlock_irq(&tasklist_lock);
343 * This function expects the tasklist_lock write-locked.
345 void __exit_signal(struct task_struct *tsk)
347 struct signal_struct * sig = tsk->signal;
348 struct sighand_struct * sighand = tsk->sighand;
352 if (!atomic_read(&sig->count))
354 spin_lock(&sighand->siglock);
355 posix_cpu_timers_exit(tsk);
356 if (atomic_dec_and_test(&sig->count)) {
357 posix_cpu_timers_exit_group(tsk);
358 if (tsk == sig->curr_target)
359 sig->curr_target = next_thread(tsk);
361 spin_unlock(&sighand->siglock);
362 flush_sigqueue(&sig->shared_pending);
365 * If there is any task waiting for the group exit
368 if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
369 wake_up_process(sig->group_exit_task);
370 sig->group_exit_task = NULL;
372 if (tsk == sig->curr_target)
373 sig->curr_target = next_thread(tsk);
376 * Accumulate here the counters for all threads but the
377 * group leader as they die, so they can be added into
378 * the process-wide totals when those are taken.
379 * The group leader stays around as a zombie as long
380 * as there are other threads. When it gets reaped,
381 * the exit.c code will add its counts into these totals.
382 * We won't ever get here for the group leader, since it
383 * will have been the last reference on the signal_struct.
385 sig->utime = cputime_add(sig->utime, tsk->utime);
386 sig->stime = cputime_add(sig->stime, tsk->stime);
387 sig->min_flt += tsk->min_flt;
388 sig->maj_flt += tsk->maj_flt;
389 sig->nvcsw += tsk->nvcsw;
390 sig->nivcsw += tsk->nivcsw;
391 sig->sched_time += tsk->sched_time;
392 spin_unlock(&sighand->siglock);
393 sig = NULL; /* Marker for below. */
395 clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
396 flush_sigqueue(&tsk->pending);
399 * We are cleaning up the signal_struct here.
401 exit_thread_group_keys(sig);
402 kmem_cache_free(signal_cachep, sig);
406 void exit_signal(struct task_struct *tsk)
408 atomic_dec(&tsk->signal->live);
410 write_lock_irq(&tasklist_lock);
412 write_unlock_irq(&tasklist_lock);
416 * Flush all handlers for a task.
420 flush_signal_handlers(struct task_struct *t, int force_default)
423 struct k_sigaction *ka = &t->sighand->action[0];
424 for (i = _NSIG ; i != 0 ; i--) {
425 if (force_default || ka->sa.sa_handler != SIG_IGN)
426 ka->sa.sa_handler = SIG_DFL;
428 sigemptyset(&ka->sa.sa_mask);
434 /* Notify the system that a driver wants to block all signals for this
435 * process, and wants to be notified if any signals at all were to be
436 * sent/acted upon. If the notifier routine returns non-zero, then the
437 * signal will be acted upon after all. If the notifier routine returns 0,
438 * then then signal will be blocked. Only one block per process is
439 * allowed. priv is a pointer to private data that the notifier routine
440 * can use to determine if the signal should be blocked or not. */
443 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
447 spin_lock_irqsave(¤t->sighand->siglock, flags);
448 current->notifier_mask = mask;
449 current->notifier_data = priv;
450 current->notifier = notifier;
451 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
454 /* Notify the system that blocking has ended. */
457 unblock_all_signals(void)
461 spin_lock_irqsave(¤t->sighand->siglock, flags);
462 current->notifier = NULL;
463 current->notifier_data = NULL;
465 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
468 static inline int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
470 struct sigqueue *q, *first = NULL;
471 int still_pending = 0;
473 if (unlikely(!sigismember(&list->signal, sig)))
477 * Collect the siginfo appropriate to this signal. Check if
478 * there is another siginfo for the same signal.
480 list_for_each_entry(q, &list->list, list) {
481 if (q->info.si_signo == sig) {
490 list_del_init(&first->list);
491 copy_siginfo(info, &first->info);
492 __sigqueue_free(first);
494 sigdelset(&list->signal, sig);
497 /* Ok, it wasn't in the queue. This must be
498 a fast-pathed signal or we must have been
499 out of queue space. So zero out the info.
501 sigdelset(&list->signal, sig);
502 info->si_signo = sig;
511 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
516 /* SIGKILL must have priority, otherwise it is quite easy
517 * to create an unkillable process, sending sig < SIGKILL
519 if (unlikely(sigismember(&pending->signal, SIGKILL))) {
520 if (!sigismember(mask, SIGKILL))
525 sig = next_signal(pending, mask);
527 if (current->notifier) {
528 if (sigismember(current->notifier_mask, sig)) {
529 if (!(current->notifier)(current->notifier_data)) {
530 clear_thread_flag(TIF_SIGPENDING);
536 if (!collect_signal(sig, pending, info))
546 * Dequeue a signal and return the element to the caller, which is
547 * expected to free it.
549 * All callers have to hold the siglock.
551 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
553 int signr = __dequeue_signal(&tsk->pending, mask, info);
555 signr = __dequeue_signal(&tsk->signal->shared_pending,
557 if (signr && unlikely(sig_kernel_stop(signr))) {
559 * Set a marker that we have dequeued a stop signal. Our
560 * caller might release the siglock and then the pending
561 * stop signal it is about to process is no longer in the
562 * pending bitmasks, but must still be cleared by a SIGCONT
563 * (and overruled by a SIGKILL). So those cases clear this
564 * shared flag after we've set it. Note that this flag may
565 * remain set after the signal we return is ignored or
566 * handled. That doesn't matter because its only purpose
567 * is to alert stop-signal processing code when another
568 * processor has come along and cleared the flag.
570 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
571 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
574 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
575 info->si_sys_private){
577 * Release the siglock to ensure proper locking order
578 * of timer locks outside of siglocks. Note, we leave
579 * irqs disabled here, since the posix-timers code is
580 * about to disable them again anyway.
582 spin_unlock(&tsk->sighand->siglock);
583 do_schedule_next_timer(info);
584 spin_lock(&tsk->sighand->siglock);
590 * Tell a process that it has a new active signal..
592 * NOTE! we rely on the previous spin_lock to
593 * lock interrupts for us! We can only be called with
594 * "siglock" held, and the local interrupt must
595 * have been disabled when that got acquired!
597 * No need to set need_resched since signal event passing
598 * goes through ->blocked
600 void signal_wake_up(struct task_struct *t, int resume)
604 set_tsk_thread_flag(t, TIF_SIGPENDING);
607 * For SIGKILL, we want to wake it up in the stopped/traced case.
608 * We don't check t->state here because there is a race with it
609 * executing another processor and just now entering stopped state.
610 * By using wake_up_state, we ensure the process will wake up and
611 * handle its death signal.
613 mask = TASK_INTERRUPTIBLE;
615 mask |= TASK_STOPPED | TASK_TRACED;
616 if (!wake_up_state(t, mask))
621 * Remove signals in mask from the pending set and queue.
622 * Returns 1 if any signals were found.
624 * All callers must be holding the siglock.
626 static int rm_from_queue(unsigned long mask, struct sigpending *s)
628 struct sigqueue *q, *n;
630 if (!sigtestsetmask(&s->signal, mask))
633 sigdelsetmask(&s->signal, mask);
634 list_for_each_entry_safe(q, n, &s->list, list) {
635 if (q->info.si_signo < SIGRTMIN &&
636 (mask & sigmask(q->info.si_signo))) {
637 list_del_init(&q->list);
645 * Bad permissions for sending the signal
647 static int check_kill_permission(int sig, struct siginfo *info,
648 struct task_struct *t)
651 if (!valid_signal(sig))
654 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
655 && ((sig != SIGCONT) ||
656 (current->signal->session != t->signal->session))
657 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
658 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
659 && !capable(CAP_KILL))
662 error = security_task_kill(t, info, sig);
664 audit_signal_info(sig, t); /* Let audit system see the signal */
669 static void do_notify_parent_cldstop(struct task_struct *tsk,
674 * Handle magic process-wide effects of stop/continue signals.
675 * Unlike the signal actions, these happen immediately at signal-generation
676 * time regardless of blocking, ignoring, or handling. This does the
677 * actual continuing for SIGCONT, but not the actual stopping for stop
678 * signals. The process stop is done as a signal action for SIG_DFL.
680 static void handle_stop_signal(int sig, struct task_struct *p)
682 struct task_struct *t;
684 if (p->signal->flags & SIGNAL_GROUP_EXIT)
686 * The process is in the middle of dying already.
690 if (sig_kernel_stop(sig)) {
692 * This is a stop signal. Remove SIGCONT from all queues.
694 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
697 rm_from_queue(sigmask(SIGCONT), &t->pending);
700 } else if (sig == SIGCONT) {
702 * Remove all stop signals from all queues,
703 * and wake all threads.
705 if (unlikely(p->signal->group_stop_count > 0)) {
707 * There was a group stop in progress. We'll
708 * pretend it finished before we got here. We are
709 * obliged to report it to the parent: if the
710 * SIGSTOP happened "after" this SIGCONT, then it
711 * would have cleared this pending SIGCONT. If it
712 * happened "before" this SIGCONT, then the parent
713 * got the SIGCHLD about the stop finishing before
714 * the continue happened. We do the notification
715 * now, and it's as if the stop had finished and
716 * the SIGCHLD was pending on entry to this kill.
718 p->signal->group_stop_count = 0;
719 p->signal->flags = SIGNAL_STOP_CONTINUED;
720 spin_unlock(&p->sighand->siglock);
721 do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_STOPPED);
722 spin_lock(&p->sighand->siglock);
724 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
728 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
731 * If there is a handler for SIGCONT, we must make
732 * sure that no thread returns to user mode before
733 * we post the signal, in case it was the only
734 * thread eligible to run the signal handler--then
735 * it must not do anything between resuming and
736 * running the handler. With the TIF_SIGPENDING
737 * flag set, the thread will pause and acquire the
738 * siglock that we hold now and until we've queued
739 * the pending signal.
741 * Wake up the stopped thread _after_ setting
744 state = TASK_STOPPED;
745 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
746 set_tsk_thread_flag(t, TIF_SIGPENDING);
747 state |= TASK_INTERRUPTIBLE;
749 wake_up_state(t, state);
754 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
756 * We were in fact stopped, and are now continued.
757 * Notify the parent with CLD_CONTINUED.
759 p->signal->flags = SIGNAL_STOP_CONTINUED;
760 p->signal->group_exit_code = 0;
761 spin_unlock(&p->sighand->siglock);
762 do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_CONTINUED);
763 spin_lock(&p->sighand->siglock);
766 * We are not stopped, but there could be a stop
767 * signal in the middle of being processed after
768 * being removed from the queue. Clear that too.
770 p->signal->flags = 0;
772 } else if (sig == SIGKILL) {
774 * Make sure that any pending stop signal already dequeued
775 * is undone by the wakeup for SIGKILL.
777 p->signal->flags = 0;
781 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
782 struct sigpending *signals)
784 struct sigqueue * q = NULL;
788 * fast-pathed signals for kernel-internal things like SIGSTOP
791 if (info == SEND_SIG_FORCED)
794 /* Real-time signals must be queued if sent by sigqueue, or
795 some other real-time mechanism. It is implementation
796 defined whether kill() does so. We attempt to do so, on
797 the principle of least surprise, but since kill is not
798 allowed to fail with EAGAIN when low on memory we just
799 make sure at least one signal gets delivered and don't
800 pass on the info struct. */
802 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
803 (is_si_special(info) ||
804 info->si_code >= 0)));
806 list_add_tail(&q->list, &signals->list);
807 switch ((unsigned long) info) {
808 case (unsigned long) SEND_SIG_NOINFO:
809 q->info.si_signo = sig;
810 q->info.si_errno = 0;
811 q->info.si_code = SI_USER;
812 q->info.si_pid = current->pid;
813 q->info.si_uid = current->uid;
815 case (unsigned long) SEND_SIG_PRIV:
816 q->info.si_signo = sig;
817 q->info.si_errno = 0;
818 q->info.si_code = SI_KERNEL;
823 copy_siginfo(&q->info, info);
826 } else if (!is_si_special(info)) {
827 if (sig >= SIGRTMIN && info->si_code != SI_USER)
829 * Queue overflow, abort. We may abort if the signal was rt
830 * and sent by user using something other than kill().
836 sigaddset(&signals->signal, sig);
840 #define LEGACY_QUEUE(sigptr, sig) \
841 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
845 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
849 if (!irqs_disabled())
851 assert_spin_locked(&t->sighand->siglock);
853 /* Short-circuit ignored signals. */
854 if (sig_ignored(t, sig))
857 /* Support queueing exactly one non-rt signal, so that we
858 can get more detailed information about the cause of
860 if (LEGACY_QUEUE(&t->pending, sig))
863 ret = send_signal(sig, info, t, &t->pending);
864 if (!ret && !sigismember(&t->blocked, sig))
865 signal_wake_up(t, sig == SIGKILL);
871 * Force a signal that the process can't ignore: if necessary
872 * we unblock the signal and change any SIG_IGN to SIG_DFL.
876 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
878 unsigned long int flags;
881 spin_lock_irqsave(&t->sighand->siglock, flags);
882 if (sigismember(&t->blocked, sig) || t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
883 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
884 sigdelset(&t->blocked, sig);
885 recalc_sigpending_tsk(t);
887 ret = specific_send_sig_info(sig, info, t);
888 spin_unlock_irqrestore(&t->sighand->siglock, flags);
894 force_sig_specific(int sig, struct task_struct *t)
896 unsigned long int flags;
898 spin_lock_irqsave(&t->sighand->siglock, flags);
899 if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN)
900 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
901 sigdelset(&t->blocked, sig);
902 recalc_sigpending_tsk(t);
903 specific_send_sig_info(sig, SEND_SIG_FORCED, t);
904 spin_unlock_irqrestore(&t->sighand->siglock, flags);
908 * Test if P wants to take SIG. After we've checked all threads with this,
909 * it's equivalent to finding no threads not blocking SIG. Any threads not
910 * blocking SIG were ruled out because they are not running and already
911 * have pending signals. Such threads will dequeue from the shared queue
912 * as soon as they're available, so putting the signal on the shared queue
913 * will be equivalent to sending it to one such thread.
915 static inline int wants_signal(int sig, struct task_struct *p)
917 if (sigismember(&p->blocked, sig))
919 if (p->flags & PF_EXITING)
923 if (p->state & (TASK_STOPPED | TASK_TRACED))
925 return task_curr(p) || !signal_pending(p);
929 __group_complete_signal(int sig, struct task_struct *p)
931 struct task_struct *t;
934 * Now find a thread we can wake up to take the signal off the queue.
936 * If the main thread wants the signal, it gets first crack.
937 * Probably the least surprising to the average bear.
939 if (wants_signal(sig, p))
941 else if (thread_group_empty(p))
943 * There is just one thread and it does not need to be woken.
944 * It will dequeue unblocked signals before it runs again.
949 * Otherwise try to find a suitable thread.
951 t = p->signal->curr_target;
953 /* restart balancing at this thread */
954 t = p->signal->curr_target = p;
955 BUG_ON(t->tgid != p->tgid);
957 while (!wants_signal(sig, t)) {
959 if (t == p->signal->curr_target)
961 * No thread needs to be woken.
962 * Any eligible threads will see
963 * the signal in the queue soon.
967 p->signal->curr_target = t;
971 * Found a killable thread. If the signal will be fatal,
972 * then start taking the whole group down immediately.
974 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
975 !sigismember(&t->real_blocked, sig) &&
976 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
978 * This signal will be fatal to the whole group.
980 if (!sig_kernel_coredump(sig)) {
982 * Start a group exit and wake everybody up.
983 * This way we don't have other threads
984 * running and doing things after a slower
985 * thread has the fatal signal pending.
987 p->signal->flags = SIGNAL_GROUP_EXIT;
988 p->signal->group_exit_code = sig;
989 p->signal->group_stop_count = 0;
992 sigaddset(&t->pending.signal, SIGKILL);
993 signal_wake_up(t, 1);
1000 * There will be a core dump. We make all threads other
1001 * than the chosen one go into a group stop so that nothing
1002 * happens until it gets scheduled, takes the signal off
1003 * the shared queue, and does the core dump. This is a
1004 * little more complicated than strictly necessary, but it
1005 * keeps the signal state that winds up in the core dump
1006 * unchanged from the death state, e.g. which thread had
1007 * the core-dump signal unblocked.
1009 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
1010 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
1011 p->signal->group_stop_count = 0;
1012 p->signal->group_exit_task = t;
1015 p->signal->group_stop_count++;
1016 signal_wake_up(t, 0);
1019 wake_up_process(p->signal->group_exit_task);
1024 * The signal is already in the shared-pending queue.
1025 * Tell the chosen thread to wake up and dequeue it.
1027 signal_wake_up(t, sig == SIGKILL);
1032 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1036 assert_spin_locked(&p->sighand->siglock);
1037 handle_stop_signal(sig, p);
1039 /* Short-circuit ignored signals. */
1040 if (sig_ignored(p, sig))
1043 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
1044 /* This is a non-RT signal and we already have one queued. */
1048 * Put this signal on the shared-pending queue, or fail with EAGAIN.
1049 * We always use the shared queue for process-wide signals,
1050 * to avoid several races.
1052 ret = send_signal(sig, info, p, &p->signal->shared_pending);
1056 __group_complete_signal(sig, p);
1061 * Nuke all other threads in the group.
1063 void zap_other_threads(struct task_struct *p)
1065 struct task_struct *t;
1067 p->signal->flags = SIGNAL_GROUP_EXIT;
1068 p->signal->group_stop_count = 0;
1070 if (thread_group_empty(p))
1073 for (t = next_thread(p); t != p; t = next_thread(t)) {
1075 * Don't bother with already dead threads
1081 * We don't want to notify the parent, since we are
1082 * killed as part of a thread group due to another
1083 * thread doing an execve() or similar. So set the
1084 * exit signal to -1 to allow immediate reaping of
1085 * the process. But don't detach the thread group
1088 if (t != p->group_leader)
1089 t->exit_signal = -1;
1091 /* SIGKILL will be handled before any pending SIGSTOP */
1092 sigaddset(&t->pending.signal, SIGKILL);
1093 signal_wake_up(t, 1);
1098 * Must be called with the tasklist_lock held for reading!
1100 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1102 unsigned long flags;
1105 ret = check_kill_permission(sig, info, p);
1106 if (!ret && sig && p->sighand) {
1107 spin_lock_irqsave(&p->sighand->siglock, flags);
1108 ret = __group_send_sig_info(sig, info, p);
1109 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1116 * kill_pg_info() sends a signal to a process group: this is what the tty
1117 * control characters do (^C, ^Z etc)
1120 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1122 struct task_struct *p = NULL;
1123 int retval, success;
1130 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1131 int err = group_send_sig_info(sig, info, p);
1134 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1135 return success ? 0 : retval;
1139 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1143 read_lock(&tasklist_lock);
1144 retval = __kill_pg_info(sig, info, pgrp);
1145 read_unlock(&tasklist_lock);
1151 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1154 struct task_struct *p;
1156 read_lock(&tasklist_lock);
1157 p = find_task_by_pid(pid);
1160 error = group_send_sig_info(sig, info, p);
1161 read_unlock(&tasklist_lock);
1165 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1166 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1167 uid_t uid, uid_t euid)
1170 struct task_struct *p;
1172 if (!valid_signal(sig))
1175 read_lock(&tasklist_lock);
1176 p = find_task_by_pid(pid);
1181 if ((!info || ((unsigned long)info != 1 &&
1182 (unsigned long)info != 2 && SI_FROMUSER(info)))
1183 && (euid != p->suid) && (euid != p->uid)
1184 && (uid != p->suid) && (uid != p->uid)) {
1188 if (sig && p->sighand) {
1189 unsigned long flags;
1190 spin_lock_irqsave(&p->sighand->siglock, flags);
1191 ret = __group_send_sig_info(sig, info, p);
1192 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1195 read_unlock(&tasklist_lock);
1198 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1201 * kill_something_info() interprets pid in interesting ways just like kill(2).
1203 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1204 * is probably wrong. Should make it like BSD or SYSV.
1207 static int kill_something_info(int sig, struct siginfo *info, int pid)
1210 return kill_pg_info(sig, info, process_group(current));
1211 } else if (pid == -1) {
1212 int retval = 0, count = 0;
1213 struct task_struct * p;
1215 read_lock(&tasklist_lock);
1216 for_each_process(p) {
1217 if (p->pid > 1 && p->tgid != current->tgid) {
1218 int err = group_send_sig_info(sig, info, p);
1224 read_unlock(&tasklist_lock);
1225 return count ? retval : -ESRCH;
1226 } else if (pid < 0) {
1227 return kill_pg_info(sig, info, -pid);
1229 return kill_proc_info(sig, info, pid);
1234 * These are for backward compatibility with the rest of the kernel source.
1238 * These two are the most common entry points. They send a signal
1239 * just to the specific thread.
1242 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1245 unsigned long flags;
1248 * Make sure legacy kernel users don't send in bad values
1249 * (normal paths check this in check_kill_permission).
1251 if (!valid_signal(sig))
1255 * We need the tasklist lock even for the specific
1256 * thread case (when we don't need to follow the group
1257 * lists) in order to avoid races with "p->sighand"
1258 * going away or changing from under us.
1260 read_lock(&tasklist_lock);
1261 spin_lock_irqsave(&p->sighand->siglock, flags);
1262 ret = specific_send_sig_info(sig, info, p);
1263 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1264 read_unlock(&tasklist_lock);
1268 #define __si_special(priv) \
1269 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1272 send_sig(int sig, struct task_struct *p, int priv)
1274 return send_sig_info(sig, __si_special(priv), p);
1278 * This is the entry point for "process-wide" signals.
1279 * They will go to an appropriate thread in the thread group.
1282 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1285 read_lock(&tasklist_lock);
1286 ret = group_send_sig_info(sig, info, p);
1287 read_unlock(&tasklist_lock);
1292 force_sig(int sig, struct task_struct *p)
1294 force_sig_info(sig, SEND_SIG_PRIV, p);
1298 * When things go south during signal handling, we
1299 * will force a SIGSEGV. And if the signal that caused
1300 * the problem was already a SIGSEGV, we'll want to
1301 * make sure we don't even try to deliver the signal..
1304 force_sigsegv(int sig, struct task_struct *p)
1306 if (sig == SIGSEGV) {
1307 unsigned long flags;
1308 spin_lock_irqsave(&p->sighand->siglock, flags);
1309 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1310 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1312 force_sig(SIGSEGV, p);
1317 kill_pg(pid_t pgrp, int sig, int priv)
1319 return kill_pg_info(sig, __si_special(priv), pgrp);
1323 kill_proc(pid_t pid, int sig, int priv)
1325 return kill_proc_info(sig, __si_special(priv), pid);
1329 * These functions support sending signals using preallocated sigqueue
1330 * structures. This is needed "because realtime applications cannot
1331 * afford to lose notifications of asynchronous events, like timer
1332 * expirations or I/O completions". In the case of Posix Timers
1333 * we allocate the sigqueue structure from the timer_create. If this
1334 * allocation fails we are able to report the failure to the application
1335 * with an EAGAIN error.
1338 struct sigqueue *sigqueue_alloc(void)
1342 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1343 q->flags |= SIGQUEUE_PREALLOC;
1347 void sigqueue_free(struct sigqueue *q)
1349 unsigned long flags;
1350 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1352 * If the signal is still pending remove it from the
1355 if (unlikely(!list_empty(&q->list))) {
1356 spinlock_t *lock = ¤t->sighand->siglock;
1357 read_lock(&tasklist_lock);
1358 spin_lock_irqsave(lock, flags);
1359 if (!list_empty(&q->list))
1360 list_del_init(&q->list);
1361 spin_unlock_irqrestore(lock, flags);
1362 read_unlock(&tasklist_lock);
1364 q->flags &= ~SIGQUEUE_PREALLOC;
1369 send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1371 unsigned long flags;
1374 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1375 read_lock(&tasklist_lock);
1377 if (unlikely(p->flags & PF_EXITING)) {
1382 spin_lock_irqsave(&p->sighand->siglock, flags);
1384 if (unlikely(!list_empty(&q->list))) {
1386 * If an SI_TIMER entry is already queue just increment
1387 * the overrun count.
1389 if (q->info.si_code != SI_TIMER)
1391 q->info.si_overrun++;
1394 /* Short-circuit ignored signals. */
1395 if (sig_ignored(p, sig)) {
1400 list_add_tail(&q->list, &p->pending.list);
1401 sigaddset(&p->pending.signal, sig);
1402 if (!sigismember(&p->blocked, sig))
1403 signal_wake_up(p, sig == SIGKILL);
1406 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1408 read_unlock(&tasklist_lock);
1414 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1416 unsigned long flags;
1419 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1420 read_lock(&tasklist_lock);
1421 spin_lock_irqsave(&p->sighand->siglock, flags);
1422 handle_stop_signal(sig, p);
1424 /* Short-circuit ignored signals. */
1425 if (sig_ignored(p, sig)) {
1430 if (unlikely(!list_empty(&q->list))) {
1432 * If an SI_TIMER entry is already queue just increment
1433 * the overrun count. Other uses should not try to
1434 * send the signal multiple times.
1436 if (q->info.si_code != SI_TIMER)
1438 q->info.si_overrun++;
1443 * Put this signal on the shared-pending queue.
1444 * We always use the shared queue for process-wide signals,
1445 * to avoid several races.
1447 list_add_tail(&q->list, &p->signal->shared_pending.list);
1448 sigaddset(&p->signal->shared_pending.signal, sig);
1450 __group_complete_signal(sig, p);
1452 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1453 read_unlock(&tasklist_lock);
1458 * Wake up any threads in the parent blocked in wait* syscalls.
1460 static inline void __wake_up_parent(struct task_struct *p,
1461 struct task_struct *parent)
1463 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1467 * Let a parent know about the death of a child.
1468 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1471 void do_notify_parent(struct task_struct *tsk, int sig)
1473 struct siginfo info;
1474 unsigned long flags;
1475 struct sighand_struct *psig;
1479 /* do_notify_parent_cldstop should have been called instead. */
1480 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1482 BUG_ON(!tsk->ptrace &&
1483 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1485 info.si_signo = sig;
1487 info.si_pid = tsk->pid;
1488 info.si_uid = tsk->uid;
1490 /* FIXME: find out whether or not this is supposed to be c*time. */
1491 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1492 tsk->signal->utime));
1493 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1494 tsk->signal->stime));
1496 info.si_status = tsk->exit_code & 0x7f;
1497 if (tsk->exit_code & 0x80)
1498 info.si_code = CLD_DUMPED;
1499 else if (tsk->exit_code & 0x7f)
1500 info.si_code = CLD_KILLED;
1502 info.si_code = CLD_EXITED;
1503 info.si_status = tsk->exit_code >> 8;
1506 psig = tsk->parent->sighand;
1507 spin_lock_irqsave(&psig->siglock, flags);
1508 if (sig == SIGCHLD &&
1509 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1510 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1512 * We are exiting and our parent doesn't care. POSIX.1
1513 * defines special semantics for setting SIGCHLD to SIG_IGN
1514 * or setting the SA_NOCLDWAIT flag: we should be reaped
1515 * automatically and not left for our parent's wait4 call.
1516 * Rather than having the parent do it as a magic kind of
1517 * signal handler, we just set this to tell do_exit that we
1518 * can be cleaned up without becoming a zombie. Note that
1519 * we still call __wake_up_parent in this case, because a
1520 * blocked sys_wait4 might now return -ECHILD.
1522 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1523 * is implementation-defined: we do (if you don't want
1524 * it, just use SIG_IGN instead).
1526 tsk->exit_signal = -1;
1527 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1530 if (valid_signal(sig) && sig > 0)
1531 __group_send_sig_info(sig, &info, tsk->parent);
1532 __wake_up_parent(tsk, tsk->parent);
1533 spin_unlock_irqrestore(&psig->siglock, flags);
1536 static void do_notify_parent_cldstop(struct task_struct *tsk, int to_self, int why)
1538 struct siginfo info;
1539 unsigned long flags;
1540 struct task_struct *parent;
1541 struct sighand_struct *sighand;
1544 parent = tsk->parent;
1546 tsk = tsk->group_leader;
1547 parent = tsk->real_parent;
1550 info.si_signo = SIGCHLD;
1552 info.si_pid = tsk->pid;
1553 info.si_uid = tsk->uid;
1555 /* FIXME: find out whether or not this is supposed to be c*time. */
1556 info.si_utime = cputime_to_jiffies(tsk->utime);
1557 info.si_stime = cputime_to_jiffies(tsk->stime);
1562 info.si_status = SIGCONT;
1565 info.si_status = tsk->signal->group_exit_code & 0x7f;
1568 info.si_status = tsk->exit_code & 0x7f;
1574 sighand = parent->sighand;
1575 spin_lock_irqsave(&sighand->siglock, flags);
1576 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1577 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1578 __group_send_sig_info(SIGCHLD, &info, parent);
1580 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1582 __wake_up_parent(tsk, parent);
1583 spin_unlock_irqrestore(&sighand->siglock, flags);
1587 * This must be called with current->sighand->siglock held.
1589 * This should be the path for all ptrace stops.
1590 * We always set current->last_siginfo while stopped here.
1591 * That makes it a way to test a stopped process for
1592 * being ptrace-stopped vs being job-control-stopped.
1594 * If we actually decide not to stop at all because the tracer is gone,
1595 * we leave nostop_code in current->exit_code.
1597 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1600 * If there is a group stop in progress,
1601 * we must participate in the bookkeeping.
1603 if (current->signal->group_stop_count > 0)
1604 --current->signal->group_stop_count;
1606 current->last_siginfo = info;
1607 current->exit_code = exit_code;
1609 /* Let the debugger run. */
1610 set_current_state(TASK_TRACED);
1611 spin_unlock_irq(¤t->sighand->siglock);
1612 read_lock(&tasklist_lock);
1613 if (likely(current->ptrace & PT_PTRACED) &&
1614 likely(current->parent != current->real_parent ||
1615 !(current->ptrace & PT_ATTACHED)) &&
1616 (likely(current->parent->signal != current->signal) ||
1617 !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
1618 do_notify_parent_cldstop(current, 1, CLD_TRAPPED);
1619 read_unlock(&tasklist_lock);
1623 * By the time we got the lock, our tracer went away.
1626 read_unlock(&tasklist_lock);
1627 set_current_state(TASK_RUNNING);
1628 current->exit_code = nostop_code;
1632 * We are back. Now reacquire the siglock before touching
1633 * last_siginfo, so that we are sure to have synchronized with
1634 * any signal-sending on another CPU that wants to examine it.
1636 spin_lock_irq(¤t->sighand->siglock);
1637 current->last_siginfo = NULL;
1640 * Queued signals ignored us while we were stopped for tracing.
1641 * So check for any that we should take before resuming user mode.
1643 recalc_sigpending();
1646 void ptrace_notify(int exit_code)
1650 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1652 memset(&info, 0, sizeof info);
1653 info.si_signo = SIGTRAP;
1654 info.si_code = exit_code;
1655 info.si_pid = current->pid;
1656 info.si_uid = current->uid;
1658 /* Let the debugger run. */
1659 spin_lock_irq(¤t->sighand->siglock);
1660 ptrace_stop(exit_code, 0, &info);
1661 spin_unlock_irq(¤t->sighand->siglock);
1665 finish_stop(int stop_count)
1670 * If there are no other threads in the group, or if there is
1671 * a group stop in progress and we are the last to stop,
1672 * report to the parent. When ptraced, every thread reports itself.
1674 if (stop_count < 0 || (current->ptrace & PT_PTRACED))
1676 else if (stop_count == 0)
1681 read_lock(&tasklist_lock);
1682 do_notify_parent_cldstop(current, to_self, CLD_STOPPED);
1683 read_unlock(&tasklist_lock);
1688 * Now we don't run again until continued.
1690 current->exit_code = 0;
1694 * This performs the stopping for SIGSTOP and other stop signals.
1695 * We have to stop all threads in the thread group.
1696 * Returns nonzero if we've actually stopped and released the siglock.
1697 * Returns zero if we didn't stop and still hold the siglock.
1700 do_signal_stop(int signr)
1702 struct signal_struct *sig = current->signal;
1703 struct sighand_struct *sighand = current->sighand;
1704 int stop_count = -1;
1706 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1709 if (sig->group_stop_count > 0) {
1711 * There is a group stop in progress. We don't need to
1712 * start another one.
1714 signr = sig->group_exit_code;
1715 stop_count = --sig->group_stop_count;
1716 current->exit_code = signr;
1717 set_current_state(TASK_STOPPED);
1718 if (stop_count == 0)
1719 sig->flags = SIGNAL_STOP_STOPPED;
1720 spin_unlock_irq(&sighand->siglock);
1722 else if (thread_group_empty(current)) {
1724 * Lock must be held through transition to stopped state.
1726 current->exit_code = current->signal->group_exit_code = signr;
1727 set_current_state(TASK_STOPPED);
1728 sig->flags = SIGNAL_STOP_STOPPED;
1729 spin_unlock_irq(&sighand->siglock);
1733 * There is no group stop already in progress.
1734 * We must initiate one now, but that requires
1735 * dropping siglock to get both the tasklist lock
1736 * and siglock again in the proper order. Note that
1737 * this allows an intervening SIGCONT to be posted.
1738 * We need to check for that and bail out if necessary.
1740 struct task_struct *t;
1742 spin_unlock_irq(&sighand->siglock);
1744 /* signals can be posted during this window */
1746 read_lock(&tasklist_lock);
1747 spin_lock_irq(&sighand->siglock);
1749 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED)) {
1751 * Another stop or continue happened while we
1752 * didn't have the lock. We can just swallow this
1753 * signal now. If we raced with a SIGCONT, that
1754 * should have just cleared it now. If we raced
1755 * with another processor delivering a stop signal,
1756 * then the SIGCONT that wakes us up should clear it.
1758 read_unlock(&tasklist_lock);
1762 if (sig->group_stop_count == 0) {
1763 sig->group_exit_code = signr;
1765 for (t = next_thread(current); t != current;
1768 * Setting state to TASK_STOPPED for a group
1769 * stop is always done with the siglock held,
1770 * so this check has no races.
1772 if (!t->exit_state &&
1773 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1775 signal_wake_up(t, 0);
1777 sig->group_stop_count = stop_count;
1780 /* A race with another thread while unlocked. */
1781 signr = sig->group_exit_code;
1782 stop_count = --sig->group_stop_count;
1785 current->exit_code = signr;
1786 set_current_state(TASK_STOPPED);
1787 if (stop_count == 0)
1788 sig->flags = SIGNAL_STOP_STOPPED;
1790 spin_unlock_irq(&sighand->siglock);
1791 read_unlock(&tasklist_lock);
1794 finish_stop(stop_count);
1799 * Do appropriate magic when group_stop_count > 0.
1800 * We return nonzero if we stopped, after releasing the siglock.
1801 * We return zero if we still hold the siglock and should look
1802 * for another signal without checking group_stop_count again.
1804 static inline int handle_group_stop(void)
1808 if (current->signal->group_exit_task == current) {
1810 * Group stop is so we can do a core dump,
1811 * We are the initiating thread, so get on with it.
1813 current->signal->group_exit_task = NULL;
1817 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1819 * Group stop is so another thread can do a core dump,
1820 * or else we are racing against a death signal.
1821 * Just punt the stop so we can get the next signal.
1826 * There is a group stop in progress. We stop
1827 * without any associated signal being in our queue.
1829 stop_count = --current->signal->group_stop_count;
1830 if (stop_count == 0)
1831 current->signal->flags = SIGNAL_STOP_STOPPED;
1832 current->exit_code = current->signal->group_exit_code;
1833 set_current_state(TASK_STOPPED);
1834 spin_unlock_irq(¤t->sighand->siglock);
1835 finish_stop(stop_count);
1839 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1840 struct pt_regs *regs, void *cookie)
1842 sigset_t *mask = ¤t->blocked;
1846 spin_lock_irq(¤t->sighand->siglock);
1848 struct k_sigaction *ka;
1850 if (unlikely(current->signal->group_stop_count > 0) &&
1851 handle_group_stop())
1854 signr = dequeue_signal(current, mask, info);
1857 break; /* will return 0 */
1859 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1860 ptrace_signal_deliver(regs, cookie);
1862 /* Let the debugger run. */
1863 ptrace_stop(signr, signr, info);
1865 /* We're back. Did the debugger cancel the sig or group_exit? */
1866 signr = current->exit_code;
1867 if (signr == 0 || current->signal->flags & SIGNAL_GROUP_EXIT)
1870 current->exit_code = 0;
1872 /* Update the siginfo structure if the signal has
1873 changed. If the debugger wanted something
1874 specific in the siginfo structure then it should
1875 have updated *info via PTRACE_SETSIGINFO. */
1876 if (signr != info->si_signo) {
1877 info->si_signo = signr;
1879 info->si_code = SI_USER;
1880 info->si_pid = current->parent->pid;
1881 info->si_uid = current->parent->uid;
1884 /* If the (new) signal is now blocked, requeue it. */
1885 if (sigismember(¤t->blocked, signr)) {
1886 specific_send_sig_info(signr, info, current);
1891 ka = ¤t->sighand->action[signr-1];
1892 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1894 if (ka->sa.sa_handler != SIG_DFL) {
1895 /* Run the handler. */
1898 if (ka->sa.sa_flags & SA_ONESHOT)
1899 ka->sa.sa_handler = SIG_DFL;
1901 break; /* will return non-zero "signr" value */
1905 * Now we are doing the default action for this signal.
1907 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1910 /* Init gets no signals it doesn't want. */
1911 if (current->pid == 1)
1914 if (sig_kernel_stop(signr)) {
1916 * The default action is to stop all threads in
1917 * the thread group. The job control signals
1918 * do nothing in an orphaned pgrp, but SIGSTOP
1919 * always works. Note that siglock needs to be
1920 * dropped during the call to is_orphaned_pgrp()
1921 * because of lock ordering with tasklist_lock.
1922 * This allows an intervening SIGCONT to be posted.
1923 * We need to check for that and bail out if necessary.
1925 if (signr != SIGSTOP) {
1926 spin_unlock_irq(¤t->sighand->siglock);
1928 /* signals can be posted during this window */
1930 if (is_orphaned_pgrp(process_group(current)))
1933 spin_lock_irq(¤t->sighand->siglock);
1936 if (likely(do_signal_stop(signr))) {
1937 /* It released the siglock. */
1942 * We didn't actually stop, due to a race
1943 * with SIGCONT or something like that.
1948 spin_unlock_irq(¤t->sighand->siglock);
1951 * Anything else is fatal, maybe with a core dump.
1953 current->flags |= PF_SIGNALED;
1954 if (sig_kernel_coredump(signr)) {
1956 * If it was able to dump core, this kills all
1957 * other threads in the group and synchronizes with
1958 * their demise. If we lost the race with another
1959 * thread getting here, it set group_exit_code
1960 * first and our do_group_exit call below will use
1961 * that value and ignore the one we pass it.
1963 do_coredump((long)signr, signr, regs);
1967 * Death signals, no core dump.
1969 do_group_exit(signr);
1972 spin_unlock_irq(¤t->sighand->siglock);
1976 EXPORT_SYMBOL(recalc_sigpending);
1977 EXPORT_SYMBOL_GPL(dequeue_signal);
1978 EXPORT_SYMBOL(flush_signals);
1979 EXPORT_SYMBOL(force_sig);
1980 EXPORT_SYMBOL(kill_pg);
1981 EXPORT_SYMBOL(kill_proc);
1982 EXPORT_SYMBOL(ptrace_notify);
1983 EXPORT_SYMBOL(send_sig);
1984 EXPORT_SYMBOL(send_sig_info);
1985 EXPORT_SYMBOL(sigprocmask);
1986 EXPORT_SYMBOL(block_all_signals);
1987 EXPORT_SYMBOL(unblock_all_signals);
1991 * System call entry points.
1994 asmlinkage long sys_restart_syscall(void)
1996 struct restart_block *restart = ¤t_thread_info()->restart_block;
1997 return restart->fn(restart);
2000 long do_no_restart_syscall(struct restart_block *param)
2006 * We don't need to get the kernel lock - this is all local to this
2007 * particular thread.. (and that's good, because this is _heavily_
2008 * used by various programs)
2012 * This is also useful for kernel threads that want to temporarily
2013 * (or permanently) block certain signals.
2015 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2016 * interface happily blocks "unblockable" signals like SIGKILL
2019 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2024 spin_lock_irq(¤t->sighand->siglock);
2025 old_block = current->blocked;
2029 sigorsets(¤t->blocked, ¤t->blocked, set);
2032 signandsets(¤t->blocked, ¤t->blocked, set);
2035 current->blocked = *set;
2040 recalc_sigpending();
2041 spin_unlock_irq(¤t->sighand->siglock);
2043 *oldset = old_block;
2048 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2050 int error = -EINVAL;
2051 sigset_t old_set, new_set;
2053 /* XXX: Don't preclude handling different sized sigset_t's. */
2054 if (sigsetsize != sizeof(sigset_t))
2059 if (copy_from_user(&new_set, set, sizeof(*set)))
2061 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2063 error = sigprocmask(how, &new_set, &old_set);
2069 spin_lock_irq(¤t->sighand->siglock);
2070 old_set = current->blocked;
2071 spin_unlock_irq(¤t->sighand->siglock);
2075 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2083 long do_sigpending(void __user *set, unsigned long sigsetsize)
2085 long error = -EINVAL;
2088 if (sigsetsize > sizeof(sigset_t))
2091 spin_lock_irq(¤t->sighand->siglock);
2092 sigorsets(&pending, ¤t->pending.signal,
2093 ¤t->signal->shared_pending.signal);
2094 spin_unlock_irq(¤t->sighand->siglock);
2096 /* Outside the lock because only this thread touches it. */
2097 sigandsets(&pending, ¤t->blocked, &pending);
2100 if (!copy_to_user(set, &pending, sigsetsize))
2108 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2110 return do_sigpending(set, sigsetsize);
2113 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2115 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2119 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2121 if (from->si_code < 0)
2122 return __copy_to_user(to, from, sizeof(siginfo_t))
2125 * If you change siginfo_t structure, please be sure
2126 * this code is fixed accordingly.
2127 * It should never copy any pad contained in the structure
2128 * to avoid security leaks, but must copy the generic
2129 * 3 ints plus the relevant union member.
2131 err = __put_user(from->si_signo, &to->si_signo);
2132 err |= __put_user(from->si_errno, &to->si_errno);
2133 err |= __put_user((short)from->si_code, &to->si_code);
2134 switch (from->si_code & __SI_MASK) {
2136 err |= __put_user(from->si_pid, &to->si_pid);
2137 err |= __put_user(from->si_uid, &to->si_uid);
2140 err |= __put_user(from->si_tid, &to->si_tid);
2141 err |= __put_user(from->si_overrun, &to->si_overrun);
2142 err |= __put_user(from->si_ptr, &to->si_ptr);
2145 err |= __put_user(from->si_band, &to->si_band);
2146 err |= __put_user(from->si_fd, &to->si_fd);
2149 err |= __put_user(from->si_addr, &to->si_addr);
2150 #ifdef __ARCH_SI_TRAPNO
2151 err |= __put_user(from->si_trapno, &to->si_trapno);
2155 err |= __put_user(from->si_pid, &to->si_pid);
2156 err |= __put_user(from->si_uid, &to->si_uid);
2157 err |= __put_user(from->si_status, &to->si_status);
2158 err |= __put_user(from->si_utime, &to->si_utime);
2159 err |= __put_user(from->si_stime, &to->si_stime);
2161 case __SI_RT: /* This is not generated by the kernel as of now. */
2162 case __SI_MESGQ: /* But this is */
2163 err |= __put_user(from->si_pid, &to->si_pid);
2164 err |= __put_user(from->si_uid, &to->si_uid);
2165 err |= __put_user(from->si_ptr, &to->si_ptr);
2167 default: /* this is just in case for now ... */
2168 err |= __put_user(from->si_pid, &to->si_pid);
2169 err |= __put_user(from->si_uid, &to->si_uid);
2178 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2179 siginfo_t __user *uinfo,
2180 const struct timespec __user *uts,
2189 /* XXX: Don't preclude handling different sized sigset_t's. */
2190 if (sigsetsize != sizeof(sigset_t))
2193 if (copy_from_user(&these, uthese, sizeof(these)))
2197 * Invert the set of allowed signals to get those we
2200 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2204 if (copy_from_user(&ts, uts, sizeof(ts)))
2206 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2211 spin_lock_irq(¤t->sighand->siglock);
2212 sig = dequeue_signal(current, &these, &info);
2214 timeout = MAX_SCHEDULE_TIMEOUT;
2216 timeout = (timespec_to_jiffies(&ts)
2217 + (ts.tv_sec || ts.tv_nsec));
2220 /* None ready -- temporarily unblock those we're
2221 * interested while we are sleeping in so that we'll
2222 * be awakened when they arrive. */
2223 current->real_blocked = current->blocked;
2224 sigandsets(¤t->blocked, ¤t->blocked, &these);
2225 recalc_sigpending();
2226 spin_unlock_irq(¤t->sighand->siglock);
2228 timeout = schedule_timeout_interruptible(timeout);
2231 spin_lock_irq(¤t->sighand->siglock);
2232 sig = dequeue_signal(current, &these, &info);
2233 current->blocked = current->real_blocked;
2234 siginitset(¤t->real_blocked, 0);
2235 recalc_sigpending();
2238 spin_unlock_irq(¤t->sighand->siglock);
2243 if (copy_siginfo_to_user(uinfo, &info))
2256 sys_kill(int pid, int sig)
2258 struct siginfo info;
2260 info.si_signo = sig;
2262 info.si_code = SI_USER;
2263 info.si_pid = current->tgid;
2264 info.si_uid = current->uid;
2266 return kill_something_info(sig, &info, pid);
2269 static int do_tkill(int tgid, int pid, int sig)
2272 struct siginfo info;
2273 struct task_struct *p;
2276 info.si_signo = sig;
2278 info.si_code = SI_TKILL;
2279 info.si_pid = current->tgid;
2280 info.si_uid = current->uid;
2282 read_lock(&tasklist_lock);
2283 p = find_task_by_pid(pid);
2284 if (p && (tgid <= 0 || p->tgid == tgid)) {
2285 error = check_kill_permission(sig, &info, p);
2287 * The null signal is a permissions and process existence
2288 * probe. No signal is actually delivered.
2290 if (!error && sig && p->sighand) {
2291 spin_lock_irq(&p->sighand->siglock);
2292 handle_stop_signal(sig, p);
2293 error = specific_send_sig_info(sig, &info, p);
2294 spin_unlock_irq(&p->sighand->siglock);
2297 read_unlock(&tasklist_lock);
2303 * sys_tgkill - send signal to one specific thread
2304 * @tgid: the thread group ID of the thread
2305 * @pid: the PID of the thread
2306 * @sig: signal to be sent
2308 * This syscall also checks the tgid and returns -ESRCH even if the PID
2309 * exists but it's not belonging to the target process anymore. This
2310 * method solves the problem of threads exiting and PIDs getting reused.
2312 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2314 /* This is only valid for single tasks */
2315 if (pid <= 0 || tgid <= 0)
2318 return do_tkill(tgid, pid, sig);
2322 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2325 sys_tkill(int pid, int sig)
2327 /* This is only valid for single tasks */
2331 return do_tkill(0, pid, sig);
2335 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2339 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2342 /* Not even root can pretend to send signals from the kernel.
2343 Nor can they impersonate a kill(), which adds source info. */
2344 if (info.si_code >= 0)
2346 info.si_signo = sig;
2348 /* POSIX.1b doesn't mention process groups. */
2349 return kill_proc_info(sig, &info, pid);
2353 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
2355 struct k_sigaction *k;
2357 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2360 k = ¤t->sighand->action[sig-1];
2362 spin_lock_irq(¤t->sighand->siglock);
2363 if (signal_pending(current)) {
2365 * If there might be a fatal signal pending on multiple
2366 * threads, make sure we take it before changing the action.
2368 spin_unlock_irq(¤t->sighand->siglock);
2369 return -ERESTARTNOINTR;
2378 * "Setting a signal action to SIG_IGN for a signal that is
2379 * pending shall cause the pending signal to be discarded,
2380 * whether or not it is blocked."
2382 * "Setting a signal action to SIG_DFL for a signal that is
2383 * pending and whose default action is to ignore the signal
2384 * (for example, SIGCHLD), shall cause the pending signal to
2385 * be discarded, whether or not it is blocked"
2387 if (act->sa.sa_handler == SIG_IGN ||
2388 (act->sa.sa_handler == SIG_DFL &&
2389 sig_kernel_ignore(sig))) {
2391 * This is a fairly rare case, so we only take the
2392 * tasklist_lock once we're sure we'll need it.
2393 * Now we must do this little unlock and relock
2394 * dance to maintain the lock hierarchy.
2396 struct task_struct *t = current;
2397 spin_unlock_irq(&t->sighand->siglock);
2398 read_lock(&tasklist_lock);
2399 spin_lock_irq(&t->sighand->siglock);
2401 sigdelsetmask(&k->sa.sa_mask,
2402 sigmask(SIGKILL) | sigmask(SIGSTOP));
2403 rm_from_queue(sigmask(sig), &t->signal->shared_pending);
2405 rm_from_queue(sigmask(sig), &t->pending);
2406 recalc_sigpending_tsk(t);
2408 } while (t != current);
2409 spin_unlock_irq(¤t->sighand->siglock);
2410 read_unlock(&tasklist_lock);
2415 sigdelsetmask(&k->sa.sa_mask,
2416 sigmask(SIGKILL) | sigmask(SIGSTOP));
2419 spin_unlock_irq(¤t->sighand->siglock);
2424 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2430 oss.ss_sp = (void __user *) current->sas_ss_sp;
2431 oss.ss_size = current->sas_ss_size;
2432 oss.ss_flags = sas_ss_flags(sp);
2441 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2442 || __get_user(ss_sp, &uss->ss_sp)
2443 || __get_user(ss_flags, &uss->ss_flags)
2444 || __get_user(ss_size, &uss->ss_size))
2448 if (on_sig_stack(sp))
2454 * Note - this code used to test ss_flags incorrectly
2455 * old code may have been written using ss_flags==0
2456 * to mean ss_flags==SS_ONSTACK (as this was the only
2457 * way that worked) - this fix preserves that older
2460 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2463 if (ss_flags == SS_DISABLE) {
2468 if (ss_size < MINSIGSTKSZ)
2472 current->sas_ss_sp = (unsigned long) ss_sp;
2473 current->sas_ss_size = ss_size;
2478 if (copy_to_user(uoss, &oss, sizeof(oss)))
2487 #ifdef __ARCH_WANT_SYS_SIGPENDING
2490 sys_sigpending(old_sigset_t __user *set)
2492 return do_sigpending(set, sizeof(*set));
2497 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2498 /* Some platforms have their own version with special arguments others
2499 support only sys_rt_sigprocmask. */
2502 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2505 old_sigset_t old_set, new_set;
2509 if (copy_from_user(&new_set, set, sizeof(*set)))
2511 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2513 spin_lock_irq(¤t->sighand->siglock);
2514 old_set = current->blocked.sig[0];
2522 sigaddsetmask(¤t->blocked, new_set);
2525 sigdelsetmask(¤t->blocked, new_set);
2528 current->blocked.sig[0] = new_set;
2532 recalc_sigpending();
2533 spin_unlock_irq(¤t->sighand->siglock);
2539 old_set = current->blocked.sig[0];
2542 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2549 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2551 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2553 sys_rt_sigaction(int sig,
2554 const struct sigaction __user *act,
2555 struct sigaction __user *oact,
2558 struct k_sigaction new_sa, old_sa;
2561 /* XXX: Don't preclude handling different sized sigset_t's. */
2562 if (sigsetsize != sizeof(sigset_t))
2566 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2570 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2573 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2579 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2581 #ifdef __ARCH_WANT_SYS_SGETMASK
2584 * For backwards compatibility. Functionality superseded by sigprocmask.
2590 return current->blocked.sig[0];
2594 sys_ssetmask(int newmask)
2598 spin_lock_irq(¤t->sighand->siglock);
2599 old = current->blocked.sig[0];
2601 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2603 recalc_sigpending();
2604 spin_unlock_irq(¤t->sighand->siglock);
2608 #endif /* __ARCH_WANT_SGETMASK */
2610 #ifdef __ARCH_WANT_SYS_SIGNAL
2612 * For backwards compatibility. Functionality superseded by sigaction.
2614 asmlinkage unsigned long
2615 sys_signal(int sig, __sighandler_t handler)
2617 struct k_sigaction new_sa, old_sa;
2620 new_sa.sa.sa_handler = handler;
2621 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2623 ret = do_sigaction(sig, &new_sa, &old_sa);
2625 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2627 #endif /* __ARCH_WANT_SYS_SIGNAL */
2629 #ifdef __ARCH_WANT_SYS_PAUSE
2634 current->state = TASK_INTERRUPTIBLE;
2636 return -ERESTARTNOHAND;
2641 void __init signals_init(void)
2644 kmem_cache_create("sigqueue",
2645 sizeof(struct sigqueue),
2646 __alignof__(struct sigqueue),
2647 SLAB_PANIC, NULL, NULL);