2 * linux/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
13 #include <linux/config.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/smp_lock.h>
17 #include <linux/init.h>
18 #include <linux/sched.h>
20 #include <linux/tty.h>
21 #include <linux/binfmts.h>
22 #include <linux/security.h>
23 #include <linux/syscalls.h>
24 #include <linux/ptrace.h>
25 #include <linux/signal.h>
26 #include <linux/audit.h>
27 #include <linux/capability.h>
28 #include <asm/param.h>
29 #include <asm/uaccess.h>
30 #include <asm/unistd.h>
31 #include <asm/siginfo.h>
34 * SLAB caches for signal bits.
37 static kmem_cache_t *sigqueue_cachep;
40 * In POSIX a signal is sent either to a specific thread (Linux task)
41 * or to the process as a whole (Linux thread group). How the signal
42 * is sent determines whether it's to one thread or the whole group,
43 * which determines which signal mask(s) are involved in blocking it
44 * from being delivered until later. When the signal is delivered,
45 * either it's caught or ignored by a user handler or it has a default
46 * effect that applies to the whole thread group (POSIX process).
48 * The possible effects an unblocked signal set to SIG_DFL can have are:
49 * ignore - Nothing Happens
50 * terminate - kill the process, i.e. all threads in the group,
51 * similar to exit_group. The group leader (only) reports
52 * WIFSIGNALED status to its parent.
53 * coredump - write a core dump file describing all threads using
54 * the same mm and then kill all those threads
55 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
57 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
58 * Other signals when not blocked and set to SIG_DFL behaves as follows.
59 * The job control signals also have other special effects.
61 * +--------------------+------------------+
62 * | POSIX signal | default action |
63 * +--------------------+------------------+
64 * | SIGHUP | terminate |
65 * | SIGINT | terminate |
66 * | SIGQUIT | coredump |
67 * | SIGILL | coredump |
68 * | SIGTRAP | coredump |
69 * | SIGABRT/SIGIOT | coredump |
70 * | SIGBUS | coredump |
71 * | SIGFPE | coredump |
72 * | SIGKILL | terminate(+) |
73 * | SIGUSR1 | terminate |
74 * | SIGSEGV | coredump |
75 * | SIGUSR2 | terminate |
76 * | SIGPIPE | terminate |
77 * | SIGALRM | terminate |
78 * | SIGTERM | terminate |
79 * | SIGCHLD | ignore |
80 * | SIGCONT | ignore(*) |
81 * | SIGSTOP | stop(*)(+) |
82 * | SIGTSTP | stop(*) |
83 * | SIGTTIN | stop(*) |
84 * | SIGTTOU | stop(*) |
86 * | SIGXCPU | coredump |
87 * | SIGXFSZ | coredump |
88 * | SIGVTALRM | terminate |
89 * | SIGPROF | terminate |
90 * | SIGPOLL/SIGIO | terminate |
91 * | SIGSYS/SIGUNUSED | coredump |
92 * | SIGSTKFLT | terminate |
93 * | SIGWINCH | ignore |
94 * | SIGPWR | terminate |
95 * | SIGRTMIN-SIGRTMAX | terminate |
96 * +--------------------+------------------+
97 * | non-POSIX signal | default action |
98 * +--------------------+------------------+
99 * | SIGEMT | coredump |
100 * +--------------------+------------------+
102 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
103 * (*) Special job control effects:
104 * When SIGCONT is sent, it resumes the process (all threads in the group)
105 * from TASK_STOPPED state and also clears any pending/queued stop signals
106 * (any of those marked with "stop(*)"). This happens regardless of blocking,
107 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
108 * any pending/queued SIGCONT signals; this happens regardless of blocking,
109 * catching, or ignored the stop signal, though (except for SIGSTOP) the
110 * default action of stopping the process may happen later or never.
114 #define M_SIGEMT M(SIGEMT)
119 #if SIGRTMIN > BITS_PER_LONG
120 #define M(sig) (1ULL << ((sig)-1))
122 #define M(sig) (1UL << ((sig)-1))
124 #define T(sig, mask) (M(sig) & (mask))
126 #define SIG_KERNEL_ONLY_MASK (\
127 M(SIGKILL) | M(SIGSTOP) )
129 #define SIG_KERNEL_STOP_MASK (\
130 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
132 #define SIG_KERNEL_COREDUMP_MASK (\
133 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
134 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
135 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
137 #define SIG_KERNEL_IGNORE_MASK (\
138 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
140 #define sig_kernel_only(sig) \
141 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
142 #define sig_kernel_coredump(sig) \
143 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
144 #define sig_kernel_ignore(sig) \
145 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
146 #define sig_kernel_stop(sig) \
147 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
149 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
151 #define sig_user_defined(t, signr) \
152 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
153 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
155 #define sig_fatal(t, signr) \
156 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
157 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
159 static int sig_ignored(struct task_struct *t, int sig)
161 void __user * handler;
164 * Tracers always want to know about signals..
166 if (t->ptrace & PT_PTRACED)
170 * Blocked signals are never ignored, since the
171 * signal handler may change by the time it is
174 if (sigismember(&t->blocked, sig))
177 /* Is it explicitly or implicitly ignored? */
178 handler = t->sighand->action[sig-1].sa.sa_handler;
179 return handler == SIG_IGN ||
180 (handler == SIG_DFL && sig_kernel_ignore(sig));
184 * Re-calculate pending state from the set of locally pending
185 * signals, globally pending signals, and blocked signals.
187 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
192 switch (_NSIG_WORDS) {
194 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
195 ready |= signal->sig[i] &~ blocked->sig[i];
198 case 4: ready = signal->sig[3] &~ blocked->sig[3];
199 ready |= signal->sig[2] &~ blocked->sig[2];
200 ready |= signal->sig[1] &~ blocked->sig[1];
201 ready |= signal->sig[0] &~ blocked->sig[0];
204 case 2: ready = signal->sig[1] &~ blocked->sig[1];
205 ready |= signal->sig[0] &~ blocked->sig[0];
208 case 1: ready = signal->sig[0] &~ blocked->sig[0];
213 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
215 fastcall void recalc_sigpending_tsk(struct task_struct *t)
217 if (t->signal->group_stop_count > 0 ||
219 PENDING(&t->pending, &t->blocked) ||
220 PENDING(&t->signal->shared_pending, &t->blocked))
221 set_tsk_thread_flag(t, TIF_SIGPENDING);
223 clear_tsk_thread_flag(t, TIF_SIGPENDING);
226 void recalc_sigpending(void)
228 recalc_sigpending_tsk(current);
231 /* Given the mask, find the first available signal that should be serviced. */
234 next_signal(struct sigpending *pending, sigset_t *mask)
236 unsigned long i, *s, *m, x;
239 s = pending->signal.sig;
241 switch (_NSIG_WORDS) {
243 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
244 if ((x = *s &~ *m) != 0) {
245 sig = ffz(~x) + i*_NSIG_BPW + 1;
250 case 2: if ((x = s[0] &~ m[0]) != 0)
252 else if ((x = s[1] &~ m[1]) != 0)
259 case 1: if ((x = *s &~ *m) != 0)
267 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
270 struct sigqueue *q = NULL;
272 atomic_inc(&t->user->sigpending);
273 if (override_rlimit ||
274 atomic_read(&t->user->sigpending) <=
275 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
276 q = kmem_cache_alloc(sigqueue_cachep, flags);
277 if (unlikely(q == NULL)) {
278 atomic_dec(&t->user->sigpending);
280 INIT_LIST_HEAD(&q->list);
282 q->user = get_uid(t->user);
287 static void __sigqueue_free(struct sigqueue *q)
289 if (q->flags & SIGQUEUE_PREALLOC)
291 atomic_dec(&q->user->sigpending);
293 kmem_cache_free(sigqueue_cachep, q);
296 void flush_sigqueue(struct sigpending *queue)
300 sigemptyset(&queue->signal);
301 while (!list_empty(&queue->list)) {
302 q = list_entry(queue->list.next, struct sigqueue , list);
303 list_del_init(&q->list);
309 * Flush all pending signals for a task.
311 void flush_signals(struct task_struct *t)
315 spin_lock_irqsave(&t->sighand->siglock, flags);
316 clear_tsk_thread_flag(t,TIF_SIGPENDING);
317 flush_sigqueue(&t->pending);
318 flush_sigqueue(&t->signal->shared_pending);
319 spin_unlock_irqrestore(&t->sighand->siglock, flags);
323 * Flush all handlers for a task.
327 flush_signal_handlers(struct task_struct *t, int force_default)
330 struct k_sigaction *ka = &t->sighand->action[0];
331 for (i = _NSIG ; i != 0 ; i--) {
332 if (force_default || ka->sa.sa_handler != SIG_IGN)
333 ka->sa.sa_handler = SIG_DFL;
335 sigemptyset(&ka->sa.sa_mask);
341 /* Notify the system that a driver wants to block all signals for this
342 * process, and wants to be notified if any signals at all were to be
343 * sent/acted upon. If the notifier routine returns non-zero, then the
344 * signal will be acted upon after all. If the notifier routine returns 0,
345 * then then signal will be blocked. Only one block per process is
346 * allowed. priv is a pointer to private data that the notifier routine
347 * can use to determine if the signal should be blocked or not. */
350 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
354 spin_lock_irqsave(¤t->sighand->siglock, flags);
355 current->notifier_mask = mask;
356 current->notifier_data = priv;
357 current->notifier = notifier;
358 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
361 /* Notify the system that blocking has ended. */
364 unblock_all_signals(void)
368 spin_lock_irqsave(¤t->sighand->siglock, flags);
369 current->notifier = NULL;
370 current->notifier_data = NULL;
372 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
375 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
377 struct sigqueue *q, *first = NULL;
378 int still_pending = 0;
380 if (unlikely(!sigismember(&list->signal, sig)))
384 * Collect the siginfo appropriate to this signal. Check if
385 * there is another siginfo for the same signal.
387 list_for_each_entry(q, &list->list, list) {
388 if (q->info.si_signo == sig) {
397 list_del_init(&first->list);
398 copy_siginfo(info, &first->info);
399 __sigqueue_free(first);
401 sigdelset(&list->signal, sig);
404 /* Ok, it wasn't in the queue. This must be
405 a fast-pathed signal or we must have been
406 out of queue space. So zero out the info.
408 sigdelset(&list->signal, sig);
409 info->si_signo = sig;
418 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
423 sig = next_signal(pending, mask);
425 if (current->notifier) {
426 if (sigismember(current->notifier_mask, sig)) {
427 if (!(current->notifier)(current->notifier_data)) {
428 clear_thread_flag(TIF_SIGPENDING);
434 if (!collect_signal(sig, pending, info))
444 * Dequeue a signal and return the element to the caller, which is
445 * expected to free it.
447 * All callers have to hold the siglock.
449 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
451 int signr = __dequeue_signal(&tsk->pending, mask, info);
453 signr = __dequeue_signal(&tsk->signal->shared_pending,
455 if (signr && unlikely(sig_kernel_stop(signr))) {
457 * Set a marker that we have dequeued a stop signal. Our
458 * caller might release the siglock and then the pending
459 * stop signal it is about to process is no longer in the
460 * pending bitmasks, but must still be cleared by a SIGCONT
461 * (and overruled by a SIGKILL). So those cases clear this
462 * shared flag after we've set it. Note that this flag may
463 * remain set after the signal we return is ignored or
464 * handled. That doesn't matter because its only purpose
465 * is to alert stop-signal processing code when another
466 * processor has come along and cleared the flag.
468 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
469 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
472 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
473 info->si_sys_private){
475 * Release the siglock to ensure proper locking order
476 * of timer locks outside of siglocks. Note, we leave
477 * irqs disabled here, since the posix-timers code is
478 * about to disable them again anyway.
480 spin_unlock(&tsk->sighand->siglock);
481 do_schedule_next_timer(info);
482 spin_lock(&tsk->sighand->siglock);
488 * Tell a process that it has a new active signal..
490 * NOTE! we rely on the previous spin_lock to
491 * lock interrupts for us! We can only be called with
492 * "siglock" held, and the local interrupt must
493 * have been disabled when that got acquired!
495 * No need to set need_resched since signal event passing
496 * goes through ->blocked
498 void signal_wake_up(struct task_struct *t, int resume)
502 set_tsk_thread_flag(t, TIF_SIGPENDING);
505 * For SIGKILL, we want to wake it up in the stopped/traced case.
506 * We don't check t->state here because there is a race with it
507 * executing another processor and just now entering stopped state.
508 * By using wake_up_state, we ensure the process will wake up and
509 * handle its death signal.
511 mask = TASK_INTERRUPTIBLE;
513 mask |= TASK_STOPPED | TASK_TRACED;
514 if (!wake_up_state(t, mask))
519 * Remove signals in mask from the pending set and queue.
520 * Returns 1 if any signals were found.
522 * All callers must be holding the siglock.
524 * This version takes a sigset mask and looks at all signals,
525 * not just those in the first mask word.
527 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
529 struct sigqueue *q, *n;
532 sigandsets(&m, mask, &s->signal);
533 if (sigisemptyset(&m))
536 signandsets(&s->signal, &s->signal, mask);
537 list_for_each_entry_safe(q, n, &s->list, list) {
538 if (sigismember(mask, q->info.si_signo)) {
539 list_del_init(&q->list);
546 * Remove signals in mask from the pending set and queue.
547 * Returns 1 if any signals were found.
549 * All callers must be holding the siglock.
551 static int rm_from_queue(unsigned long mask, struct sigpending *s)
553 struct sigqueue *q, *n;
555 if (!sigtestsetmask(&s->signal, mask))
558 sigdelsetmask(&s->signal, mask);
559 list_for_each_entry_safe(q, n, &s->list, list) {
560 if (q->info.si_signo < SIGRTMIN &&
561 (mask & sigmask(q->info.si_signo))) {
562 list_del_init(&q->list);
570 * Bad permissions for sending the signal
572 static int check_kill_permission(int sig, struct siginfo *info,
573 struct task_struct *t)
576 if (!valid_signal(sig))
579 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
580 && ((sig != SIGCONT) ||
581 (current->signal->session != t->signal->session))
582 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
583 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
584 && !capable(CAP_KILL))
587 error = security_task_kill(t, info, sig);
589 audit_signal_info(sig, t); /* Let audit system see the signal */
594 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
597 * Handle magic process-wide effects of stop/continue signals.
598 * Unlike the signal actions, these happen immediately at signal-generation
599 * time regardless of blocking, ignoring, or handling. This does the
600 * actual continuing for SIGCONT, but not the actual stopping for stop
601 * signals. The process stop is done as a signal action for SIG_DFL.
603 static void handle_stop_signal(int sig, struct task_struct *p)
605 struct task_struct *t;
607 if (p->signal->flags & SIGNAL_GROUP_EXIT)
609 * The process is in the middle of dying already.
613 if (sig_kernel_stop(sig)) {
615 * This is a stop signal. Remove SIGCONT from all queues.
617 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
620 rm_from_queue(sigmask(SIGCONT), &t->pending);
623 } else if (sig == SIGCONT) {
625 * Remove all stop signals from all queues,
626 * and wake all threads.
628 if (unlikely(p->signal->group_stop_count > 0)) {
630 * There was a group stop in progress. We'll
631 * pretend it finished before we got here. We are
632 * obliged to report it to the parent: if the
633 * SIGSTOP happened "after" this SIGCONT, then it
634 * would have cleared this pending SIGCONT. If it
635 * happened "before" this SIGCONT, then the parent
636 * got the SIGCHLD about the stop finishing before
637 * the continue happened. We do the notification
638 * now, and it's as if the stop had finished and
639 * the SIGCHLD was pending on entry to this kill.
641 p->signal->group_stop_count = 0;
642 p->signal->flags = SIGNAL_STOP_CONTINUED;
643 spin_unlock(&p->sighand->siglock);
644 do_notify_parent_cldstop(p, CLD_STOPPED);
645 spin_lock(&p->sighand->siglock);
647 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
651 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
654 * If there is a handler for SIGCONT, we must make
655 * sure that no thread returns to user mode before
656 * we post the signal, in case it was the only
657 * thread eligible to run the signal handler--then
658 * it must not do anything between resuming and
659 * running the handler. With the TIF_SIGPENDING
660 * flag set, the thread will pause and acquire the
661 * siglock that we hold now and until we've queued
662 * the pending signal.
664 * Wake up the stopped thread _after_ setting
667 state = TASK_STOPPED;
668 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
669 set_tsk_thread_flag(t, TIF_SIGPENDING);
670 state |= TASK_INTERRUPTIBLE;
672 wake_up_state(t, state);
677 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
679 * We were in fact stopped, and are now continued.
680 * Notify the parent with CLD_CONTINUED.
682 p->signal->flags = SIGNAL_STOP_CONTINUED;
683 p->signal->group_exit_code = 0;
684 spin_unlock(&p->sighand->siglock);
685 do_notify_parent_cldstop(p, CLD_CONTINUED);
686 spin_lock(&p->sighand->siglock);
689 * We are not stopped, but there could be a stop
690 * signal in the middle of being processed after
691 * being removed from the queue. Clear that too.
693 p->signal->flags = 0;
695 } else if (sig == SIGKILL) {
697 * Make sure that any pending stop signal already dequeued
698 * is undone by the wakeup for SIGKILL.
700 p->signal->flags = 0;
704 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
705 struct sigpending *signals)
707 struct sigqueue * q = NULL;
711 * fast-pathed signals for kernel-internal things like SIGSTOP
714 if (info == SEND_SIG_FORCED)
717 /* Real-time signals must be queued if sent by sigqueue, or
718 some other real-time mechanism. It is implementation
719 defined whether kill() does so. We attempt to do so, on
720 the principle of least surprise, but since kill is not
721 allowed to fail with EAGAIN when low on memory we just
722 make sure at least one signal gets delivered and don't
723 pass on the info struct. */
725 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
726 (is_si_special(info) ||
727 info->si_code >= 0)));
729 list_add_tail(&q->list, &signals->list);
730 switch ((unsigned long) info) {
731 case (unsigned long) SEND_SIG_NOINFO:
732 q->info.si_signo = sig;
733 q->info.si_errno = 0;
734 q->info.si_code = SI_USER;
735 q->info.si_pid = current->pid;
736 q->info.si_uid = current->uid;
738 case (unsigned long) SEND_SIG_PRIV:
739 q->info.si_signo = sig;
740 q->info.si_errno = 0;
741 q->info.si_code = SI_KERNEL;
746 copy_siginfo(&q->info, info);
749 } else if (!is_si_special(info)) {
750 if (sig >= SIGRTMIN && info->si_code != SI_USER)
752 * Queue overflow, abort. We may abort if the signal was rt
753 * and sent by user using something other than kill().
759 sigaddset(&signals->signal, sig);
763 #define LEGACY_QUEUE(sigptr, sig) \
764 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
768 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
772 if (!irqs_disabled())
774 assert_spin_locked(&t->sighand->siglock);
776 /* Short-circuit ignored signals. */
777 if (sig_ignored(t, sig))
780 /* Support queueing exactly one non-rt signal, so that we
781 can get more detailed information about the cause of
783 if (LEGACY_QUEUE(&t->pending, sig))
786 ret = send_signal(sig, info, t, &t->pending);
787 if (!ret && !sigismember(&t->blocked, sig))
788 signal_wake_up(t, sig == SIGKILL);
794 * Force a signal that the process can't ignore: if necessary
795 * we unblock the signal and change any SIG_IGN to SIG_DFL.
799 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
801 unsigned long int flags;
804 spin_lock_irqsave(&t->sighand->siglock, flags);
805 if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
806 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
808 if (sigismember(&t->blocked, sig)) {
809 sigdelset(&t->blocked, sig);
811 recalc_sigpending_tsk(t);
812 ret = specific_send_sig_info(sig, info, t);
813 spin_unlock_irqrestore(&t->sighand->siglock, flags);
819 force_sig_specific(int sig, struct task_struct *t)
821 force_sig_info(sig, SEND_SIG_FORCED, t);
825 * Test if P wants to take SIG. After we've checked all threads with this,
826 * it's equivalent to finding no threads not blocking SIG. Any threads not
827 * blocking SIG were ruled out because they are not running and already
828 * have pending signals. Such threads will dequeue from the shared queue
829 * as soon as they're available, so putting the signal on the shared queue
830 * will be equivalent to sending it to one such thread.
832 static inline int wants_signal(int sig, struct task_struct *p)
834 if (sigismember(&p->blocked, sig))
836 if (p->flags & PF_EXITING)
840 if (p->state & (TASK_STOPPED | TASK_TRACED))
842 return task_curr(p) || !signal_pending(p);
846 __group_complete_signal(int sig, struct task_struct *p)
848 struct task_struct *t;
851 * Now find a thread we can wake up to take the signal off the queue.
853 * If the main thread wants the signal, it gets first crack.
854 * Probably the least surprising to the average bear.
856 if (wants_signal(sig, p))
858 else if (thread_group_empty(p))
860 * There is just one thread and it does not need to be woken.
861 * It will dequeue unblocked signals before it runs again.
866 * Otherwise try to find a suitable thread.
868 t = p->signal->curr_target;
870 /* restart balancing at this thread */
871 t = p->signal->curr_target = p;
872 BUG_ON(t->tgid != p->tgid);
874 while (!wants_signal(sig, t)) {
876 if (t == p->signal->curr_target)
878 * No thread needs to be woken.
879 * Any eligible threads will see
880 * the signal in the queue soon.
884 p->signal->curr_target = t;
888 * Found a killable thread. If the signal will be fatal,
889 * then start taking the whole group down immediately.
891 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
892 !sigismember(&t->real_blocked, sig) &&
893 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
895 * This signal will be fatal to the whole group.
897 if (!sig_kernel_coredump(sig)) {
899 * Start a group exit and wake everybody up.
900 * This way we don't have other threads
901 * running and doing things after a slower
902 * thread has the fatal signal pending.
904 p->signal->flags = SIGNAL_GROUP_EXIT;
905 p->signal->group_exit_code = sig;
906 p->signal->group_stop_count = 0;
909 sigaddset(&t->pending.signal, SIGKILL);
910 signal_wake_up(t, 1);
917 * There will be a core dump. We make all threads other
918 * than the chosen one go into a group stop so that nothing
919 * happens until it gets scheduled, takes the signal off
920 * the shared queue, and does the core dump. This is a
921 * little more complicated than strictly necessary, but it
922 * keeps the signal state that winds up in the core dump
923 * unchanged from the death state, e.g. which thread had
924 * the core-dump signal unblocked.
926 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
927 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
928 p->signal->group_stop_count = 0;
929 p->signal->group_exit_task = t;
932 p->signal->group_stop_count++;
933 signal_wake_up(t, 0);
936 wake_up_process(p->signal->group_exit_task);
941 * The signal is already in the shared-pending queue.
942 * Tell the chosen thread to wake up and dequeue it.
944 signal_wake_up(t, sig == SIGKILL);
949 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
953 assert_spin_locked(&p->sighand->siglock);
954 handle_stop_signal(sig, p);
956 /* Short-circuit ignored signals. */
957 if (sig_ignored(p, sig))
960 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
961 /* This is a non-RT signal and we already have one queued. */
965 * Put this signal on the shared-pending queue, or fail with EAGAIN.
966 * We always use the shared queue for process-wide signals,
967 * to avoid several races.
969 ret = send_signal(sig, info, p, &p->signal->shared_pending);
973 __group_complete_signal(sig, p);
978 * Nuke all other threads in the group.
980 void zap_other_threads(struct task_struct *p)
982 struct task_struct *t;
984 p->signal->flags = SIGNAL_GROUP_EXIT;
985 p->signal->group_stop_count = 0;
987 if (thread_group_empty(p))
990 for (t = next_thread(p); t != p; t = next_thread(t)) {
992 * Don't bother with already dead threads
998 * We don't want to notify the parent, since we are
999 * killed as part of a thread group due to another
1000 * thread doing an execve() or similar. So set the
1001 * exit signal to -1 to allow immediate reaping of
1002 * the process. But don't detach the thread group
1005 if (t != p->group_leader)
1006 t->exit_signal = -1;
1008 /* SIGKILL will be handled before any pending SIGSTOP */
1009 sigaddset(&t->pending.signal, SIGKILL);
1010 signal_wake_up(t, 1);
1015 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1017 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1019 struct sighand_struct *sighand;
1022 sighand = rcu_dereference(tsk->sighand);
1023 if (unlikely(sighand == NULL))
1026 spin_lock_irqsave(&sighand->siglock, *flags);
1027 if (likely(sighand == tsk->sighand))
1029 spin_unlock_irqrestore(&sighand->siglock, *flags);
1035 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1037 unsigned long flags;
1040 ret = check_kill_permission(sig, info, p);
1044 if (lock_task_sighand(p, &flags)) {
1045 ret = __group_send_sig_info(sig, info, p);
1046 unlock_task_sighand(p, &flags);
1054 * kill_pg_info() sends a signal to a process group: this is what the tty
1055 * control characters do (^C, ^Z etc)
1058 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1060 struct task_struct *p = NULL;
1061 int retval, success;
1068 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1069 int err = group_send_sig_info(sig, info, p);
1072 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1073 return success ? 0 : retval;
1077 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1081 read_lock(&tasklist_lock);
1082 retval = __kill_pg_info(sig, info, pgrp);
1083 read_unlock(&tasklist_lock);
1089 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1092 int acquired_tasklist_lock = 0;
1093 struct task_struct *p;
1096 if (unlikely(sig_needs_tasklist(sig))) {
1097 read_lock(&tasklist_lock);
1098 acquired_tasklist_lock = 1;
1100 p = find_task_by_pid(pid);
1103 error = group_send_sig_info(sig, info, p);
1104 if (unlikely(acquired_tasklist_lock))
1105 read_unlock(&tasklist_lock);
1110 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1111 int kill_proc_info_as_uid(int sig, struct siginfo *info, pid_t pid,
1112 uid_t uid, uid_t euid)
1115 struct task_struct *p;
1117 if (!valid_signal(sig))
1120 read_lock(&tasklist_lock);
1121 p = find_task_by_pid(pid);
1126 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1127 && (euid != p->suid) && (euid != p->uid)
1128 && (uid != p->suid) && (uid != p->uid)) {
1132 if (sig && p->sighand) {
1133 unsigned long flags;
1134 spin_lock_irqsave(&p->sighand->siglock, flags);
1135 ret = __group_send_sig_info(sig, info, p);
1136 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1139 read_unlock(&tasklist_lock);
1142 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid);
1145 * kill_something_info() interprets pid in interesting ways just like kill(2).
1147 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1148 * is probably wrong. Should make it like BSD or SYSV.
1151 static int kill_something_info(int sig, struct siginfo *info, int pid)
1154 return kill_pg_info(sig, info, process_group(current));
1155 } else if (pid == -1) {
1156 int retval = 0, count = 0;
1157 struct task_struct * p;
1159 read_lock(&tasklist_lock);
1160 for_each_process(p) {
1161 if (p->pid > 1 && p->tgid != current->tgid) {
1162 int err = group_send_sig_info(sig, info, p);
1168 read_unlock(&tasklist_lock);
1169 return count ? retval : -ESRCH;
1170 } else if (pid < 0) {
1171 return kill_pg_info(sig, info, -pid);
1173 return kill_proc_info(sig, info, pid);
1178 * These are for backward compatibility with the rest of the kernel source.
1182 * These two are the most common entry points. They send a signal
1183 * just to the specific thread.
1186 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1189 unsigned long flags;
1192 * Make sure legacy kernel users don't send in bad values
1193 * (normal paths check this in check_kill_permission).
1195 if (!valid_signal(sig))
1199 * We need the tasklist lock even for the specific
1200 * thread case (when we don't need to follow the group
1201 * lists) in order to avoid races with "p->sighand"
1202 * going away or changing from under us.
1204 read_lock(&tasklist_lock);
1205 spin_lock_irqsave(&p->sighand->siglock, flags);
1206 ret = specific_send_sig_info(sig, info, p);
1207 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1208 read_unlock(&tasklist_lock);
1212 #define __si_special(priv) \
1213 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1216 send_sig(int sig, struct task_struct *p, int priv)
1218 return send_sig_info(sig, __si_special(priv), p);
1222 * This is the entry point for "process-wide" signals.
1223 * They will go to an appropriate thread in the thread group.
1226 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1229 read_lock(&tasklist_lock);
1230 ret = group_send_sig_info(sig, info, p);
1231 read_unlock(&tasklist_lock);
1236 force_sig(int sig, struct task_struct *p)
1238 force_sig_info(sig, SEND_SIG_PRIV, p);
1242 * When things go south during signal handling, we
1243 * will force a SIGSEGV. And if the signal that caused
1244 * the problem was already a SIGSEGV, we'll want to
1245 * make sure we don't even try to deliver the signal..
1248 force_sigsegv(int sig, struct task_struct *p)
1250 if (sig == SIGSEGV) {
1251 unsigned long flags;
1252 spin_lock_irqsave(&p->sighand->siglock, flags);
1253 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1254 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1256 force_sig(SIGSEGV, p);
1261 kill_pg(pid_t pgrp, int sig, int priv)
1263 return kill_pg_info(sig, __si_special(priv), pgrp);
1267 kill_proc(pid_t pid, int sig, int priv)
1269 return kill_proc_info(sig, __si_special(priv), pid);
1273 * These functions support sending signals using preallocated sigqueue
1274 * structures. This is needed "because realtime applications cannot
1275 * afford to lose notifications of asynchronous events, like timer
1276 * expirations or I/O completions". In the case of Posix Timers
1277 * we allocate the sigqueue structure from the timer_create. If this
1278 * allocation fails we are able to report the failure to the application
1279 * with an EAGAIN error.
1282 struct sigqueue *sigqueue_alloc(void)
1286 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1287 q->flags |= SIGQUEUE_PREALLOC;
1291 void sigqueue_free(struct sigqueue *q)
1293 unsigned long flags;
1294 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1296 * If the signal is still pending remove it from the
1299 if (unlikely(!list_empty(&q->list))) {
1300 spinlock_t *lock = ¤t->sighand->siglock;
1301 read_lock(&tasklist_lock);
1302 spin_lock_irqsave(lock, flags);
1303 if (!list_empty(&q->list))
1304 list_del_init(&q->list);
1305 spin_unlock_irqrestore(lock, flags);
1306 read_unlock(&tasklist_lock);
1308 q->flags &= ~SIGQUEUE_PREALLOC;
1313 send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1315 unsigned long flags;
1317 struct sighand_struct *sh;
1319 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1322 * The rcu based delayed sighand destroy makes it possible to
1323 * run this without tasklist lock held. The task struct itself
1324 * cannot go away as create_timer did get_task_struct().
1326 * We return -1, when the task is marked exiting, so
1327 * posix_timer_event can redirect it to the group leader
1331 if (unlikely(p->flags & PF_EXITING)) {
1337 sh = rcu_dereference(p->sighand);
1339 spin_lock_irqsave(&sh->siglock, flags);
1340 if (p->sighand != sh) {
1341 /* We raced with exec() in a multithreaded process... */
1342 spin_unlock_irqrestore(&sh->siglock, flags);
1347 * We do the check here again to handle the following scenario:
1352 * interrupt exit code running
1354 * lock sighand->siglock
1355 * unlock sighand->siglock
1357 * add(tsk->pending) flush_sigqueue(tsk->pending)
1361 if (unlikely(p->flags & PF_EXITING)) {
1366 if (unlikely(!list_empty(&q->list))) {
1368 * If an SI_TIMER entry is already queue just increment
1369 * the overrun count.
1371 if (q->info.si_code != SI_TIMER)
1373 q->info.si_overrun++;
1376 /* Short-circuit ignored signals. */
1377 if (sig_ignored(p, sig)) {
1382 list_add_tail(&q->list, &p->pending.list);
1383 sigaddset(&p->pending.signal, sig);
1384 if (!sigismember(&p->blocked, sig))
1385 signal_wake_up(p, sig == SIGKILL);
1388 spin_unlock_irqrestore(&sh->siglock, flags);
1396 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1398 unsigned long flags;
1401 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1403 read_lock(&tasklist_lock);
1404 /* Since it_lock is held, p->sighand cannot be NULL. */
1405 spin_lock_irqsave(&p->sighand->siglock, flags);
1406 handle_stop_signal(sig, p);
1408 /* Short-circuit ignored signals. */
1409 if (sig_ignored(p, sig)) {
1414 if (unlikely(!list_empty(&q->list))) {
1416 * If an SI_TIMER entry is already queue just increment
1417 * the overrun count. Other uses should not try to
1418 * send the signal multiple times.
1420 if (q->info.si_code != SI_TIMER)
1422 q->info.si_overrun++;
1427 * Put this signal on the shared-pending queue.
1428 * We always use the shared queue for process-wide signals,
1429 * to avoid several races.
1431 list_add_tail(&q->list, &p->signal->shared_pending.list);
1432 sigaddset(&p->signal->shared_pending.signal, sig);
1434 __group_complete_signal(sig, p);
1436 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1437 read_unlock(&tasklist_lock);
1442 * Wake up any threads in the parent blocked in wait* syscalls.
1444 static inline void __wake_up_parent(struct task_struct *p,
1445 struct task_struct *parent)
1447 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1451 * Let a parent know about the death of a child.
1452 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1455 void do_notify_parent(struct task_struct *tsk, int sig)
1457 struct siginfo info;
1458 unsigned long flags;
1459 struct sighand_struct *psig;
1463 /* do_notify_parent_cldstop should have been called instead. */
1464 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1466 BUG_ON(!tsk->ptrace &&
1467 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1469 info.si_signo = sig;
1471 info.si_pid = tsk->pid;
1472 info.si_uid = tsk->uid;
1474 /* FIXME: find out whether or not this is supposed to be c*time. */
1475 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1476 tsk->signal->utime));
1477 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1478 tsk->signal->stime));
1480 info.si_status = tsk->exit_code & 0x7f;
1481 if (tsk->exit_code & 0x80)
1482 info.si_code = CLD_DUMPED;
1483 else if (tsk->exit_code & 0x7f)
1484 info.si_code = CLD_KILLED;
1486 info.si_code = CLD_EXITED;
1487 info.si_status = tsk->exit_code >> 8;
1490 psig = tsk->parent->sighand;
1491 spin_lock_irqsave(&psig->siglock, flags);
1492 if (!tsk->ptrace && sig == SIGCHLD &&
1493 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1494 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1496 * We are exiting and our parent doesn't care. POSIX.1
1497 * defines special semantics for setting SIGCHLD to SIG_IGN
1498 * or setting the SA_NOCLDWAIT flag: we should be reaped
1499 * automatically and not left for our parent's wait4 call.
1500 * Rather than having the parent do it as a magic kind of
1501 * signal handler, we just set this to tell do_exit that we
1502 * can be cleaned up without becoming a zombie. Note that
1503 * we still call __wake_up_parent in this case, because a
1504 * blocked sys_wait4 might now return -ECHILD.
1506 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1507 * is implementation-defined: we do (if you don't want
1508 * it, just use SIG_IGN instead).
1510 tsk->exit_signal = -1;
1511 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1514 if (valid_signal(sig) && sig > 0)
1515 __group_send_sig_info(sig, &info, tsk->parent);
1516 __wake_up_parent(tsk, tsk->parent);
1517 spin_unlock_irqrestore(&psig->siglock, flags);
1520 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1522 struct siginfo info;
1523 unsigned long flags;
1524 struct task_struct *parent;
1525 struct sighand_struct *sighand;
1527 if (tsk->ptrace & PT_PTRACED)
1528 parent = tsk->parent;
1530 tsk = tsk->group_leader;
1531 parent = tsk->real_parent;
1534 info.si_signo = SIGCHLD;
1536 info.si_pid = tsk->pid;
1537 info.si_uid = tsk->uid;
1539 /* FIXME: find out whether or not this is supposed to be c*time. */
1540 info.si_utime = cputime_to_jiffies(tsk->utime);
1541 info.si_stime = cputime_to_jiffies(tsk->stime);
1546 info.si_status = SIGCONT;
1549 info.si_status = tsk->signal->group_exit_code & 0x7f;
1552 info.si_status = tsk->exit_code & 0x7f;
1558 sighand = parent->sighand;
1559 spin_lock_irqsave(&sighand->siglock, flags);
1560 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1561 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1562 __group_send_sig_info(SIGCHLD, &info, parent);
1564 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1566 __wake_up_parent(tsk, parent);
1567 spin_unlock_irqrestore(&sighand->siglock, flags);
1571 * This must be called with current->sighand->siglock held.
1573 * This should be the path for all ptrace stops.
1574 * We always set current->last_siginfo while stopped here.
1575 * That makes it a way to test a stopped process for
1576 * being ptrace-stopped vs being job-control-stopped.
1578 * If we actually decide not to stop at all because the tracer is gone,
1579 * we leave nostop_code in current->exit_code.
1581 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1584 * If there is a group stop in progress,
1585 * we must participate in the bookkeeping.
1587 if (current->signal->group_stop_count > 0)
1588 --current->signal->group_stop_count;
1590 current->last_siginfo = info;
1591 current->exit_code = exit_code;
1593 /* Let the debugger run. */
1594 set_current_state(TASK_TRACED);
1595 spin_unlock_irq(¤t->sighand->siglock);
1596 read_lock(&tasklist_lock);
1597 if (likely(current->ptrace & PT_PTRACED) &&
1598 likely(current->parent != current->real_parent ||
1599 !(current->ptrace & PT_ATTACHED)) &&
1600 (likely(current->parent->signal != current->signal) ||
1601 !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
1602 do_notify_parent_cldstop(current, CLD_TRAPPED);
1603 read_unlock(&tasklist_lock);
1607 * By the time we got the lock, our tracer went away.
1610 read_unlock(&tasklist_lock);
1611 set_current_state(TASK_RUNNING);
1612 current->exit_code = nostop_code;
1616 * We are back. Now reacquire the siglock before touching
1617 * last_siginfo, so that we are sure to have synchronized with
1618 * any signal-sending on another CPU that wants to examine it.
1620 spin_lock_irq(¤t->sighand->siglock);
1621 current->last_siginfo = NULL;
1624 * Queued signals ignored us while we were stopped for tracing.
1625 * So check for any that we should take before resuming user mode.
1627 recalc_sigpending();
1630 void ptrace_notify(int exit_code)
1634 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1636 memset(&info, 0, sizeof info);
1637 info.si_signo = SIGTRAP;
1638 info.si_code = exit_code;
1639 info.si_pid = current->pid;
1640 info.si_uid = current->uid;
1642 /* Let the debugger run. */
1643 spin_lock_irq(¤t->sighand->siglock);
1644 ptrace_stop(exit_code, 0, &info);
1645 spin_unlock_irq(¤t->sighand->siglock);
1649 finish_stop(int stop_count)
1652 * If there are no other threads in the group, or if there is
1653 * a group stop in progress and we are the last to stop,
1654 * report to the parent. When ptraced, every thread reports itself.
1656 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1657 read_lock(&tasklist_lock);
1658 do_notify_parent_cldstop(current, CLD_STOPPED);
1659 read_unlock(&tasklist_lock);
1664 * Now we don't run again until continued.
1666 current->exit_code = 0;
1670 * This performs the stopping for SIGSTOP and other stop signals.
1671 * We have to stop all threads in the thread group.
1672 * Returns nonzero if we've actually stopped and released the siglock.
1673 * Returns zero if we didn't stop and still hold the siglock.
1675 static int do_signal_stop(int signr)
1677 struct signal_struct *sig = current->signal;
1680 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1683 if (sig->group_stop_count > 0) {
1685 * There is a group stop in progress. We don't need to
1686 * start another one.
1688 stop_count = --sig->group_stop_count;
1691 * There is no group stop already in progress.
1692 * We must initiate one now.
1694 struct task_struct *t;
1696 sig->group_exit_code = signr;
1699 for (t = next_thread(current); t != current; t = next_thread(t))
1701 * Setting state to TASK_STOPPED for a group
1702 * stop is always done with the siglock held,
1703 * so this check has no races.
1705 if (!t->exit_state &&
1706 !(t->state & (TASK_STOPPED|TASK_TRACED))) {
1708 signal_wake_up(t, 0);
1710 sig->group_stop_count = stop_count;
1713 if (stop_count == 0)
1714 sig->flags = SIGNAL_STOP_STOPPED;
1715 current->exit_code = sig->group_exit_code;
1716 __set_current_state(TASK_STOPPED);
1718 spin_unlock_irq(¤t->sighand->siglock);
1719 finish_stop(stop_count);
1724 * Do appropriate magic when group_stop_count > 0.
1725 * We return nonzero if we stopped, after releasing the siglock.
1726 * We return zero if we still hold the siglock and should look
1727 * for another signal without checking group_stop_count again.
1729 static int handle_group_stop(void)
1733 if (current->signal->group_exit_task == current) {
1735 * Group stop is so we can do a core dump,
1736 * We are the initiating thread, so get on with it.
1738 current->signal->group_exit_task = NULL;
1742 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1744 * Group stop is so another thread can do a core dump,
1745 * or else we are racing against a death signal.
1746 * Just punt the stop so we can get the next signal.
1751 * There is a group stop in progress. We stop
1752 * without any associated signal being in our queue.
1754 stop_count = --current->signal->group_stop_count;
1755 if (stop_count == 0)
1756 current->signal->flags = SIGNAL_STOP_STOPPED;
1757 current->exit_code = current->signal->group_exit_code;
1758 set_current_state(TASK_STOPPED);
1759 spin_unlock_irq(¤t->sighand->siglock);
1760 finish_stop(stop_count);
1764 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1765 struct pt_regs *regs, void *cookie)
1767 sigset_t *mask = ¤t->blocked;
1773 spin_lock_irq(¤t->sighand->siglock);
1775 struct k_sigaction *ka;
1777 if (unlikely(current->signal->group_stop_count > 0) &&
1778 handle_group_stop())
1781 signr = dequeue_signal(current, mask, info);
1784 break; /* will return 0 */
1786 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1787 ptrace_signal_deliver(regs, cookie);
1789 /* Let the debugger run. */
1790 ptrace_stop(signr, signr, info);
1792 /* We're back. Did the debugger cancel the sig or group_exit? */
1793 signr = current->exit_code;
1794 if (signr == 0 || current->signal->flags & SIGNAL_GROUP_EXIT)
1797 current->exit_code = 0;
1799 /* Update the siginfo structure if the signal has
1800 changed. If the debugger wanted something
1801 specific in the siginfo structure then it should
1802 have updated *info via PTRACE_SETSIGINFO. */
1803 if (signr != info->si_signo) {
1804 info->si_signo = signr;
1806 info->si_code = SI_USER;
1807 info->si_pid = current->parent->pid;
1808 info->si_uid = current->parent->uid;
1811 /* If the (new) signal is now blocked, requeue it. */
1812 if (sigismember(¤t->blocked, signr)) {
1813 specific_send_sig_info(signr, info, current);
1818 ka = ¤t->sighand->action[signr-1];
1819 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1821 if (ka->sa.sa_handler != SIG_DFL) {
1822 /* Run the handler. */
1825 if (ka->sa.sa_flags & SA_ONESHOT)
1826 ka->sa.sa_handler = SIG_DFL;
1828 break; /* will return non-zero "signr" value */
1832 * Now we are doing the default action for this signal.
1834 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1837 /* Init gets no signals it doesn't want. */
1838 if (current == child_reaper)
1841 if (sig_kernel_stop(signr)) {
1843 * The default action is to stop all threads in
1844 * the thread group. The job control signals
1845 * do nothing in an orphaned pgrp, but SIGSTOP
1846 * always works. Note that siglock needs to be
1847 * dropped during the call to is_orphaned_pgrp()
1848 * because of lock ordering with tasklist_lock.
1849 * This allows an intervening SIGCONT to be posted.
1850 * We need to check for that and bail out if necessary.
1852 if (signr != SIGSTOP) {
1853 spin_unlock_irq(¤t->sighand->siglock);
1855 /* signals can be posted during this window */
1857 if (is_orphaned_pgrp(process_group(current)))
1860 spin_lock_irq(¤t->sighand->siglock);
1863 if (likely(do_signal_stop(signr))) {
1864 /* It released the siglock. */
1869 * We didn't actually stop, due to a race
1870 * with SIGCONT or something like that.
1875 spin_unlock_irq(¤t->sighand->siglock);
1878 * Anything else is fatal, maybe with a core dump.
1880 current->flags |= PF_SIGNALED;
1881 if (sig_kernel_coredump(signr)) {
1883 * If it was able to dump core, this kills all
1884 * other threads in the group and synchronizes with
1885 * their demise. If we lost the race with another
1886 * thread getting here, it set group_exit_code
1887 * first and our do_group_exit call below will use
1888 * that value and ignore the one we pass it.
1890 do_coredump((long)signr, signr, regs);
1894 * Death signals, no core dump.
1896 do_group_exit(signr);
1899 spin_unlock_irq(¤t->sighand->siglock);
1903 EXPORT_SYMBOL(recalc_sigpending);
1904 EXPORT_SYMBOL_GPL(dequeue_signal);
1905 EXPORT_SYMBOL(flush_signals);
1906 EXPORT_SYMBOL(force_sig);
1907 EXPORT_SYMBOL(kill_pg);
1908 EXPORT_SYMBOL(kill_proc);
1909 EXPORT_SYMBOL(ptrace_notify);
1910 EXPORT_SYMBOL(send_sig);
1911 EXPORT_SYMBOL(send_sig_info);
1912 EXPORT_SYMBOL(sigprocmask);
1913 EXPORT_SYMBOL(block_all_signals);
1914 EXPORT_SYMBOL(unblock_all_signals);
1918 * System call entry points.
1921 asmlinkage long sys_restart_syscall(void)
1923 struct restart_block *restart = ¤t_thread_info()->restart_block;
1924 return restart->fn(restart);
1927 long do_no_restart_syscall(struct restart_block *param)
1933 * We don't need to get the kernel lock - this is all local to this
1934 * particular thread.. (and that's good, because this is _heavily_
1935 * used by various programs)
1939 * This is also useful for kernel threads that want to temporarily
1940 * (or permanently) block certain signals.
1942 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1943 * interface happily blocks "unblockable" signals like SIGKILL
1946 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1950 spin_lock_irq(¤t->sighand->siglock);
1952 *oldset = current->blocked;
1957 sigorsets(¤t->blocked, ¤t->blocked, set);
1960 signandsets(¤t->blocked, ¤t->blocked, set);
1963 current->blocked = *set;
1968 recalc_sigpending();
1969 spin_unlock_irq(¤t->sighand->siglock);
1975 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
1977 int error = -EINVAL;
1978 sigset_t old_set, new_set;
1980 /* XXX: Don't preclude handling different sized sigset_t's. */
1981 if (sigsetsize != sizeof(sigset_t))
1986 if (copy_from_user(&new_set, set, sizeof(*set)))
1988 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
1990 error = sigprocmask(how, &new_set, &old_set);
1996 spin_lock_irq(¤t->sighand->siglock);
1997 old_set = current->blocked;
1998 spin_unlock_irq(¤t->sighand->siglock);
2002 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2010 long do_sigpending(void __user *set, unsigned long sigsetsize)
2012 long error = -EINVAL;
2015 if (sigsetsize > sizeof(sigset_t))
2018 spin_lock_irq(¤t->sighand->siglock);
2019 sigorsets(&pending, ¤t->pending.signal,
2020 ¤t->signal->shared_pending.signal);
2021 spin_unlock_irq(¤t->sighand->siglock);
2023 /* Outside the lock because only this thread touches it. */
2024 sigandsets(&pending, ¤t->blocked, &pending);
2027 if (!copy_to_user(set, &pending, sigsetsize))
2035 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2037 return do_sigpending(set, sigsetsize);
2040 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2042 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2046 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2048 if (from->si_code < 0)
2049 return __copy_to_user(to, from, sizeof(siginfo_t))
2052 * If you change siginfo_t structure, please be sure
2053 * this code is fixed accordingly.
2054 * It should never copy any pad contained in the structure
2055 * to avoid security leaks, but must copy the generic
2056 * 3 ints plus the relevant union member.
2058 err = __put_user(from->si_signo, &to->si_signo);
2059 err |= __put_user(from->si_errno, &to->si_errno);
2060 err |= __put_user((short)from->si_code, &to->si_code);
2061 switch (from->si_code & __SI_MASK) {
2063 err |= __put_user(from->si_pid, &to->si_pid);
2064 err |= __put_user(from->si_uid, &to->si_uid);
2067 err |= __put_user(from->si_tid, &to->si_tid);
2068 err |= __put_user(from->si_overrun, &to->si_overrun);
2069 err |= __put_user(from->si_ptr, &to->si_ptr);
2072 err |= __put_user(from->si_band, &to->si_band);
2073 err |= __put_user(from->si_fd, &to->si_fd);
2076 err |= __put_user(from->si_addr, &to->si_addr);
2077 #ifdef __ARCH_SI_TRAPNO
2078 err |= __put_user(from->si_trapno, &to->si_trapno);
2082 err |= __put_user(from->si_pid, &to->si_pid);
2083 err |= __put_user(from->si_uid, &to->si_uid);
2084 err |= __put_user(from->si_status, &to->si_status);
2085 err |= __put_user(from->si_utime, &to->si_utime);
2086 err |= __put_user(from->si_stime, &to->si_stime);
2088 case __SI_RT: /* This is not generated by the kernel as of now. */
2089 case __SI_MESGQ: /* But this is */
2090 err |= __put_user(from->si_pid, &to->si_pid);
2091 err |= __put_user(from->si_uid, &to->si_uid);
2092 err |= __put_user(from->si_ptr, &to->si_ptr);
2094 default: /* this is just in case for now ... */
2095 err |= __put_user(from->si_pid, &to->si_pid);
2096 err |= __put_user(from->si_uid, &to->si_uid);
2105 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2106 siginfo_t __user *uinfo,
2107 const struct timespec __user *uts,
2116 /* XXX: Don't preclude handling different sized sigset_t's. */
2117 if (sigsetsize != sizeof(sigset_t))
2120 if (copy_from_user(&these, uthese, sizeof(these)))
2124 * Invert the set of allowed signals to get those we
2127 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2131 if (copy_from_user(&ts, uts, sizeof(ts)))
2133 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2138 spin_lock_irq(¤t->sighand->siglock);
2139 sig = dequeue_signal(current, &these, &info);
2141 timeout = MAX_SCHEDULE_TIMEOUT;
2143 timeout = (timespec_to_jiffies(&ts)
2144 + (ts.tv_sec || ts.tv_nsec));
2147 /* None ready -- temporarily unblock those we're
2148 * interested while we are sleeping in so that we'll
2149 * be awakened when they arrive. */
2150 current->real_blocked = current->blocked;
2151 sigandsets(¤t->blocked, ¤t->blocked, &these);
2152 recalc_sigpending();
2153 spin_unlock_irq(¤t->sighand->siglock);
2155 timeout = schedule_timeout_interruptible(timeout);
2157 spin_lock_irq(¤t->sighand->siglock);
2158 sig = dequeue_signal(current, &these, &info);
2159 current->blocked = current->real_blocked;
2160 siginitset(¤t->real_blocked, 0);
2161 recalc_sigpending();
2164 spin_unlock_irq(¤t->sighand->siglock);
2169 if (copy_siginfo_to_user(uinfo, &info))
2182 sys_kill(int pid, int sig)
2184 struct siginfo info;
2186 info.si_signo = sig;
2188 info.si_code = SI_USER;
2189 info.si_pid = current->tgid;
2190 info.si_uid = current->uid;
2192 return kill_something_info(sig, &info, pid);
2195 static int do_tkill(int tgid, int pid, int sig)
2198 struct siginfo info;
2199 struct task_struct *p;
2202 info.si_signo = sig;
2204 info.si_code = SI_TKILL;
2205 info.si_pid = current->tgid;
2206 info.si_uid = current->uid;
2208 read_lock(&tasklist_lock);
2209 p = find_task_by_pid(pid);
2210 if (p && (tgid <= 0 || p->tgid == tgid)) {
2211 error = check_kill_permission(sig, &info, p);
2213 * The null signal is a permissions and process existence
2214 * probe. No signal is actually delivered.
2216 if (!error && sig && p->sighand) {
2217 spin_lock_irq(&p->sighand->siglock);
2218 handle_stop_signal(sig, p);
2219 error = specific_send_sig_info(sig, &info, p);
2220 spin_unlock_irq(&p->sighand->siglock);
2223 read_unlock(&tasklist_lock);
2229 * sys_tgkill - send signal to one specific thread
2230 * @tgid: the thread group ID of the thread
2231 * @pid: the PID of the thread
2232 * @sig: signal to be sent
2234 * This syscall also checks the tgid and returns -ESRCH even if the PID
2235 * exists but it's not belonging to the target process anymore. This
2236 * method solves the problem of threads exiting and PIDs getting reused.
2238 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2240 /* This is only valid for single tasks */
2241 if (pid <= 0 || tgid <= 0)
2244 return do_tkill(tgid, pid, sig);
2248 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2251 sys_tkill(int pid, int sig)
2253 /* This is only valid for single tasks */
2257 return do_tkill(0, pid, sig);
2261 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2265 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2268 /* Not even root can pretend to send signals from the kernel.
2269 Nor can they impersonate a kill(), which adds source info. */
2270 if (info.si_code >= 0)
2272 info.si_signo = sig;
2274 /* POSIX.1b doesn't mention process groups. */
2275 return kill_proc_info(sig, &info, pid);
2278 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2280 struct k_sigaction *k;
2283 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2286 k = ¤t->sighand->action[sig-1];
2288 spin_lock_irq(¤t->sighand->siglock);
2289 if (signal_pending(current)) {
2291 * If there might be a fatal signal pending on multiple
2292 * threads, make sure we take it before changing the action.
2294 spin_unlock_irq(¤t->sighand->siglock);
2295 return -ERESTARTNOINTR;
2302 sigdelsetmask(&act->sa.sa_mask,
2303 sigmask(SIGKILL) | sigmask(SIGSTOP));
2307 * "Setting a signal action to SIG_IGN for a signal that is
2308 * pending shall cause the pending signal to be discarded,
2309 * whether or not it is blocked."
2311 * "Setting a signal action to SIG_DFL for a signal that is
2312 * pending and whose default action is to ignore the signal
2313 * (for example, SIGCHLD), shall cause the pending signal to
2314 * be discarded, whether or not it is blocked"
2316 if (act->sa.sa_handler == SIG_IGN ||
2317 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2318 struct task_struct *t = current;
2320 sigaddset(&mask, sig);
2321 rm_from_queue_full(&mask, &t->signal->shared_pending);
2323 rm_from_queue_full(&mask, &t->pending);
2324 recalc_sigpending_tsk(t);
2326 } while (t != current);
2330 spin_unlock_irq(¤t->sighand->siglock);
2335 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2341 oss.ss_sp = (void __user *) current->sas_ss_sp;
2342 oss.ss_size = current->sas_ss_size;
2343 oss.ss_flags = sas_ss_flags(sp);
2352 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2353 || __get_user(ss_sp, &uss->ss_sp)
2354 || __get_user(ss_flags, &uss->ss_flags)
2355 || __get_user(ss_size, &uss->ss_size))
2359 if (on_sig_stack(sp))
2365 * Note - this code used to test ss_flags incorrectly
2366 * old code may have been written using ss_flags==0
2367 * to mean ss_flags==SS_ONSTACK (as this was the only
2368 * way that worked) - this fix preserves that older
2371 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2374 if (ss_flags == SS_DISABLE) {
2379 if (ss_size < MINSIGSTKSZ)
2383 current->sas_ss_sp = (unsigned long) ss_sp;
2384 current->sas_ss_size = ss_size;
2389 if (copy_to_user(uoss, &oss, sizeof(oss)))
2398 #ifdef __ARCH_WANT_SYS_SIGPENDING
2401 sys_sigpending(old_sigset_t __user *set)
2403 return do_sigpending(set, sizeof(*set));
2408 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2409 /* Some platforms have their own version with special arguments others
2410 support only sys_rt_sigprocmask. */
2413 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2416 old_sigset_t old_set, new_set;
2420 if (copy_from_user(&new_set, set, sizeof(*set)))
2422 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2424 spin_lock_irq(¤t->sighand->siglock);
2425 old_set = current->blocked.sig[0];
2433 sigaddsetmask(¤t->blocked, new_set);
2436 sigdelsetmask(¤t->blocked, new_set);
2439 current->blocked.sig[0] = new_set;
2443 recalc_sigpending();
2444 spin_unlock_irq(¤t->sighand->siglock);
2450 old_set = current->blocked.sig[0];
2453 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2460 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2462 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2464 sys_rt_sigaction(int sig,
2465 const struct sigaction __user *act,
2466 struct sigaction __user *oact,
2469 struct k_sigaction new_sa, old_sa;
2472 /* XXX: Don't preclude handling different sized sigset_t's. */
2473 if (sigsetsize != sizeof(sigset_t))
2477 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2481 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2484 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2490 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2492 #ifdef __ARCH_WANT_SYS_SGETMASK
2495 * For backwards compatibility. Functionality superseded by sigprocmask.
2501 return current->blocked.sig[0];
2505 sys_ssetmask(int newmask)
2509 spin_lock_irq(¤t->sighand->siglock);
2510 old = current->blocked.sig[0];
2512 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2514 recalc_sigpending();
2515 spin_unlock_irq(¤t->sighand->siglock);
2519 #endif /* __ARCH_WANT_SGETMASK */
2521 #ifdef __ARCH_WANT_SYS_SIGNAL
2523 * For backwards compatibility. Functionality superseded by sigaction.
2525 asmlinkage unsigned long
2526 sys_signal(int sig, __sighandler_t handler)
2528 struct k_sigaction new_sa, old_sa;
2531 new_sa.sa.sa_handler = handler;
2532 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2533 sigemptyset(&new_sa.sa.sa_mask);
2535 ret = do_sigaction(sig, &new_sa, &old_sa);
2537 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2539 #endif /* __ARCH_WANT_SYS_SIGNAL */
2541 #ifdef __ARCH_WANT_SYS_PAUSE
2546 current->state = TASK_INTERRUPTIBLE;
2548 return -ERESTARTNOHAND;
2553 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2554 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2558 /* XXX: Don't preclude handling different sized sigset_t's. */
2559 if (sigsetsize != sizeof(sigset_t))
2562 if (copy_from_user(&newset, unewset, sizeof(newset)))
2564 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2566 spin_lock_irq(¤t->sighand->siglock);
2567 current->saved_sigmask = current->blocked;
2568 current->blocked = newset;
2569 recalc_sigpending();
2570 spin_unlock_irq(¤t->sighand->siglock);
2572 current->state = TASK_INTERRUPTIBLE;
2574 set_thread_flag(TIF_RESTORE_SIGMASK);
2575 return -ERESTARTNOHAND;
2577 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2579 void __init signals_init(void)
2582 kmem_cache_create("sigqueue",
2583 sizeof(struct sigqueue),
2584 __alignof__(struct sigqueue),
2585 SLAB_PANIC, NULL, NULL);