2 * linux/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/sched.h>
18 #include <linux/tty.h>
19 #include <linux/binfmts.h>
20 #include <linux/security.h>
21 #include <linux/syscalls.h>
22 #include <linux/ptrace.h>
23 #include <linux/signal.h>
24 #include <linux/signalfd.h>
25 #include <linux/capability.h>
26 #include <linux/freezer.h>
27 #include <linux/pid_namespace.h>
28 #include <linux/nsproxy.h>
30 #include <asm/param.h>
31 #include <asm/uaccess.h>
32 #include <asm/unistd.h>
33 #include <asm/siginfo.h>
34 #include "audit.h" /* audit_signal_info() */
37 * SLAB caches for signal bits.
40 static struct kmem_cache *sigqueue_cachep;
43 static int sig_ignored(struct task_struct *t, int sig)
45 void __user * handler;
48 * Tracers always want to know about signals..
50 if (t->ptrace & PT_PTRACED)
54 * Blocked signals are never ignored, since the
55 * signal handler may change by the time it is
58 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
61 /* Is it explicitly or implicitly ignored? */
62 handler = t->sighand->action[sig-1].sa.sa_handler;
63 return handler == SIG_IGN ||
64 (handler == SIG_DFL && sig_kernel_ignore(sig));
68 * Re-calculate pending state from the set of locally pending
69 * signals, globally pending signals, and blocked signals.
71 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
76 switch (_NSIG_WORDS) {
78 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
79 ready |= signal->sig[i] &~ blocked->sig[i];
82 case 4: ready = signal->sig[3] &~ blocked->sig[3];
83 ready |= signal->sig[2] &~ blocked->sig[2];
84 ready |= signal->sig[1] &~ blocked->sig[1];
85 ready |= signal->sig[0] &~ blocked->sig[0];
88 case 2: ready = signal->sig[1] &~ blocked->sig[1];
89 ready |= signal->sig[0] &~ blocked->sig[0];
92 case 1: ready = signal->sig[0] &~ blocked->sig[0];
97 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
99 static int recalc_sigpending_tsk(struct task_struct *t)
101 if (t->signal->group_stop_count > 0 ||
102 PENDING(&t->pending, &t->blocked) ||
103 PENDING(&t->signal->shared_pending, &t->blocked)) {
104 set_tsk_thread_flag(t, TIF_SIGPENDING);
108 * We must never clear the flag in another thread, or in current
109 * when it's possible the current syscall is returning -ERESTART*.
110 * So we don't clear it here, and only callers who know they should do.
116 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
117 * This is superfluous when called on current, the wakeup is a harmless no-op.
119 void recalc_sigpending_and_wake(struct task_struct *t)
121 if (recalc_sigpending_tsk(t))
122 signal_wake_up(t, 0);
125 void recalc_sigpending(void)
127 if (!recalc_sigpending_tsk(current) && !freezing(current))
128 clear_thread_flag(TIF_SIGPENDING);
132 /* Given the mask, find the first available signal that should be serviced. */
134 int next_signal(struct sigpending *pending, sigset_t *mask)
136 unsigned long i, *s, *m, x;
139 s = pending->signal.sig;
141 switch (_NSIG_WORDS) {
143 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
144 if ((x = *s &~ *m) != 0) {
145 sig = ffz(~x) + i*_NSIG_BPW + 1;
150 case 2: if ((x = s[0] &~ m[0]) != 0)
152 else if ((x = s[1] &~ m[1]) != 0)
159 case 1: if ((x = *s &~ *m) != 0)
167 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
170 struct sigqueue *q = NULL;
171 struct user_struct *user;
174 * In order to avoid problems with "switch_user()", we want to make
175 * sure that the compiler doesn't re-load "t->user"
179 atomic_inc(&user->sigpending);
180 if (override_rlimit ||
181 atomic_read(&user->sigpending) <=
182 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
183 q = kmem_cache_alloc(sigqueue_cachep, flags);
184 if (unlikely(q == NULL)) {
185 atomic_dec(&user->sigpending);
187 INIT_LIST_HEAD(&q->list);
189 q->user = get_uid(user);
194 static void __sigqueue_free(struct sigqueue *q)
196 if (q->flags & SIGQUEUE_PREALLOC)
198 atomic_dec(&q->user->sigpending);
200 kmem_cache_free(sigqueue_cachep, q);
203 void flush_sigqueue(struct sigpending *queue)
207 sigemptyset(&queue->signal);
208 while (!list_empty(&queue->list)) {
209 q = list_entry(queue->list.next, struct sigqueue , list);
210 list_del_init(&q->list);
216 * Flush all pending signals for a task.
218 void flush_signals(struct task_struct *t)
222 spin_lock_irqsave(&t->sighand->siglock, flags);
223 clear_tsk_thread_flag(t,TIF_SIGPENDING);
224 flush_sigqueue(&t->pending);
225 flush_sigqueue(&t->signal->shared_pending);
226 spin_unlock_irqrestore(&t->sighand->siglock, flags);
229 void ignore_signals(struct task_struct *t)
233 for (i = 0; i < _NSIG; ++i)
234 t->sighand->action[i].sa.sa_handler = SIG_IGN;
240 * Flush all handlers for a task.
244 flush_signal_handlers(struct task_struct *t, int force_default)
247 struct k_sigaction *ka = &t->sighand->action[0];
248 for (i = _NSIG ; i != 0 ; i--) {
249 if (force_default || ka->sa.sa_handler != SIG_IGN)
250 ka->sa.sa_handler = SIG_DFL;
252 sigemptyset(&ka->sa.sa_mask);
257 int unhandled_signal(struct task_struct *tsk, int sig)
259 if (is_global_init(tsk))
261 if (tsk->ptrace & PT_PTRACED)
263 return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
264 (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
268 /* Notify the system that a driver wants to block all signals for this
269 * process, and wants to be notified if any signals at all were to be
270 * sent/acted upon. If the notifier routine returns non-zero, then the
271 * signal will be acted upon after all. If the notifier routine returns 0,
272 * then then signal will be blocked. Only one block per process is
273 * allowed. priv is a pointer to private data that the notifier routine
274 * can use to determine if the signal should be blocked or not. */
277 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
281 spin_lock_irqsave(¤t->sighand->siglock, flags);
282 current->notifier_mask = mask;
283 current->notifier_data = priv;
284 current->notifier = notifier;
285 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
288 /* Notify the system that blocking has ended. */
291 unblock_all_signals(void)
295 spin_lock_irqsave(¤t->sighand->siglock, flags);
296 current->notifier = NULL;
297 current->notifier_data = NULL;
299 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
302 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
304 struct sigqueue *q, *first = NULL;
305 int still_pending = 0;
307 if (unlikely(!sigismember(&list->signal, sig)))
311 * Collect the siginfo appropriate to this signal. Check if
312 * there is another siginfo for the same signal.
314 list_for_each_entry(q, &list->list, list) {
315 if (q->info.si_signo == sig) {
324 list_del_init(&first->list);
325 copy_siginfo(info, &first->info);
326 __sigqueue_free(first);
328 sigdelset(&list->signal, sig);
331 /* Ok, it wasn't in the queue. This must be
332 a fast-pathed signal or we must have been
333 out of queue space. So zero out the info.
335 sigdelset(&list->signal, sig);
336 info->si_signo = sig;
345 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
348 int sig = next_signal(pending, mask);
351 if (current->notifier) {
352 if (sigismember(current->notifier_mask, sig)) {
353 if (!(current->notifier)(current->notifier_data)) {
354 clear_thread_flag(TIF_SIGPENDING);
360 if (!collect_signal(sig, pending, info))
368 * Dequeue a signal and return the element to the caller, which is
369 * expected to free it.
371 * All callers have to hold the siglock.
373 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
377 /* We only dequeue private signals from ourselves, we don't let
378 * signalfd steal them
380 signr = __dequeue_signal(&tsk->pending, mask, info);
382 signr = __dequeue_signal(&tsk->signal->shared_pending,
387 * itimers are process shared and we restart periodic
388 * itimers in the signal delivery path to prevent DoS
389 * attacks in the high resolution timer case. This is
390 * compliant with the old way of self restarting
391 * itimers, as the SIGALRM is a legacy signal and only
392 * queued once. Changing the restart behaviour to
393 * restart the timer in the signal dequeue path is
394 * reducing the timer noise on heavy loaded !highres
397 if (unlikely(signr == SIGALRM)) {
398 struct hrtimer *tmr = &tsk->signal->real_timer;
400 if (!hrtimer_is_queued(tmr) &&
401 tsk->signal->it_real_incr.tv64 != 0) {
402 hrtimer_forward(tmr, tmr->base->get_time(),
403 tsk->signal->it_real_incr);
404 hrtimer_restart(tmr);
409 if (signr && unlikely(sig_kernel_stop(signr))) {
411 * Set a marker that we have dequeued a stop signal. Our
412 * caller might release the siglock and then the pending
413 * stop signal it is about to process is no longer in the
414 * pending bitmasks, but must still be cleared by a SIGCONT
415 * (and overruled by a SIGKILL). So those cases clear this
416 * shared flag after we've set it. Note that this flag may
417 * remain set after the signal we return is ignored or
418 * handled. That doesn't matter because its only purpose
419 * is to alert stop-signal processing code when another
420 * processor has come along and cleared the flag.
422 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
423 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
426 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
427 info->si_sys_private){
429 * Release the siglock to ensure proper locking order
430 * of timer locks outside of siglocks. Note, we leave
431 * irqs disabled here, since the posix-timers code is
432 * about to disable them again anyway.
434 spin_unlock(&tsk->sighand->siglock);
435 do_schedule_next_timer(info);
436 spin_lock(&tsk->sighand->siglock);
442 * Tell a process that it has a new active signal..
444 * NOTE! we rely on the previous spin_lock to
445 * lock interrupts for us! We can only be called with
446 * "siglock" held, and the local interrupt must
447 * have been disabled when that got acquired!
449 * No need to set need_resched since signal event passing
450 * goes through ->blocked
452 void signal_wake_up(struct task_struct *t, int resume)
456 set_tsk_thread_flag(t, TIF_SIGPENDING);
459 * For SIGKILL, we want to wake it up in the stopped/traced/killable
460 * case. We don't check t->state here because there is a race with it
461 * executing another processor and just now entering stopped state.
462 * By using wake_up_state, we ensure the process will wake up and
463 * handle its death signal.
465 mask = TASK_INTERRUPTIBLE;
467 mask |= TASK_WAKEKILL;
468 if (!wake_up_state(t, mask))
473 * Remove signals in mask from the pending set and queue.
474 * Returns 1 if any signals were found.
476 * All callers must be holding the siglock.
478 * This version takes a sigset mask and looks at all signals,
479 * not just those in the first mask word.
481 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
483 struct sigqueue *q, *n;
486 sigandsets(&m, mask, &s->signal);
487 if (sigisemptyset(&m))
490 signandsets(&s->signal, &s->signal, mask);
491 list_for_each_entry_safe(q, n, &s->list, list) {
492 if (sigismember(mask, q->info.si_signo)) {
493 list_del_init(&q->list);
500 * Remove signals in mask from the pending set and queue.
501 * Returns 1 if any signals were found.
503 * All callers must be holding the siglock.
505 static int rm_from_queue(unsigned long mask, struct sigpending *s)
507 struct sigqueue *q, *n;
509 if (!sigtestsetmask(&s->signal, mask))
512 sigdelsetmask(&s->signal, mask);
513 list_for_each_entry_safe(q, n, &s->list, list) {
514 if (q->info.si_signo < SIGRTMIN &&
515 (mask & sigmask(q->info.si_signo))) {
516 list_del_init(&q->list);
524 * Bad permissions for sending the signal
526 static int check_kill_permission(int sig, struct siginfo *info,
527 struct task_struct *t)
530 if (!valid_signal(sig))
533 if (info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info))) {
534 error = audit_signal_info(sig, t); /* Let audit system see the signal */
538 if (((sig != SIGCONT) ||
539 (task_session_nr(current) != task_session_nr(t)))
540 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
541 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
542 && !capable(CAP_KILL))
546 return security_task_kill(t, info, sig, 0);
550 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
553 * Handle magic process-wide effects of stop/continue signals.
554 * Unlike the signal actions, these happen immediately at signal-generation
555 * time regardless of blocking, ignoring, or handling. This does the
556 * actual continuing for SIGCONT, but not the actual stopping for stop
557 * signals. The process stop is done as a signal action for SIG_DFL.
559 static void handle_stop_signal(int sig, struct task_struct *p)
561 struct task_struct *t;
563 if (p->signal->flags & SIGNAL_GROUP_EXIT)
565 * The process is in the middle of dying already.
569 if (sig_kernel_stop(sig)) {
571 * This is a stop signal. Remove SIGCONT from all queues.
573 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
576 rm_from_queue(sigmask(SIGCONT), &t->pending);
579 } else if (sig == SIGCONT) {
581 * Remove all stop signals from all queues,
582 * and wake all threads.
584 if (unlikely(p->signal->group_stop_count > 0)) {
586 * There was a group stop in progress. We'll
587 * pretend it finished before we got here. We are
588 * obliged to report it to the parent: if the
589 * SIGSTOP happened "after" this SIGCONT, then it
590 * would have cleared this pending SIGCONT. If it
591 * happened "before" this SIGCONT, then the parent
592 * got the SIGCHLD about the stop finishing before
593 * the continue happened. We do the notification
594 * now, and it's as if the stop had finished and
595 * the SIGCHLD was pending on entry to this kill.
597 p->signal->group_stop_count = 0;
598 p->signal->flags = SIGNAL_STOP_CONTINUED;
599 spin_unlock(&p->sighand->siglock);
600 do_notify_parent_cldstop(p, CLD_STOPPED);
601 spin_lock(&p->sighand->siglock);
603 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
607 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
610 * If there is a handler for SIGCONT, we must make
611 * sure that no thread returns to user mode before
612 * we post the signal, in case it was the only
613 * thread eligible to run the signal handler--then
614 * it must not do anything between resuming and
615 * running the handler. With the TIF_SIGPENDING
616 * flag set, the thread will pause and acquire the
617 * siglock that we hold now and until we've queued
618 * the pending signal.
620 * Wake up the stopped thread _after_ setting
623 state = __TASK_STOPPED;
624 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
625 set_tsk_thread_flag(t, TIF_SIGPENDING);
626 state |= TASK_INTERRUPTIBLE;
628 wake_up_state(t, state);
633 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
635 * We were in fact stopped, and are now continued.
636 * Notify the parent with CLD_CONTINUED.
638 p->signal->flags = SIGNAL_STOP_CONTINUED;
639 p->signal->group_exit_code = 0;
640 spin_unlock(&p->sighand->siglock);
641 do_notify_parent_cldstop(p, CLD_CONTINUED);
642 spin_lock(&p->sighand->siglock);
645 * We are not stopped, but there could be a stop
646 * signal in the middle of being processed after
647 * being removed from the queue. Clear that too.
649 p->signal->flags = 0;
651 } else if (sig == SIGKILL) {
653 * Make sure that any pending stop signal already dequeued
654 * is undone by the wakeup for SIGKILL.
656 p->signal->flags = 0;
660 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
661 struct sigpending *signals)
663 struct sigqueue * q = NULL;
667 * Deliver the signal to listening signalfds. This must be called
668 * with the sighand lock held.
670 signalfd_notify(t, sig);
673 * fast-pathed signals for kernel-internal things like SIGSTOP
676 if (info == SEND_SIG_FORCED)
679 /* Real-time signals must be queued if sent by sigqueue, or
680 some other real-time mechanism. It is implementation
681 defined whether kill() does so. We attempt to do so, on
682 the principle of least surprise, but since kill is not
683 allowed to fail with EAGAIN when low on memory we just
684 make sure at least one signal gets delivered and don't
685 pass on the info struct. */
687 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
688 (is_si_special(info) ||
689 info->si_code >= 0)));
691 list_add_tail(&q->list, &signals->list);
692 switch ((unsigned long) info) {
693 case (unsigned long) SEND_SIG_NOINFO:
694 q->info.si_signo = sig;
695 q->info.si_errno = 0;
696 q->info.si_code = SI_USER;
697 q->info.si_pid = task_pid_vnr(current);
698 q->info.si_uid = current->uid;
700 case (unsigned long) SEND_SIG_PRIV:
701 q->info.si_signo = sig;
702 q->info.si_errno = 0;
703 q->info.si_code = SI_KERNEL;
708 copy_siginfo(&q->info, info);
711 } else if (!is_si_special(info)) {
712 if (sig >= SIGRTMIN && info->si_code != SI_USER)
714 * Queue overflow, abort. We may abort if the signal was rt
715 * and sent by user using something other than kill().
721 sigaddset(&signals->signal, sig);
725 #define LEGACY_QUEUE(sigptr, sig) \
726 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
728 int print_fatal_signals;
730 static void print_fatal_signal(struct pt_regs *regs, int signr)
732 printk("%s/%d: potentially unexpected fatal signal %d.\n",
733 current->comm, task_pid_nr(current), signr);
735 #if defined(__i386__) && !defined(__arch_um__)
736 printk("code at %08lx: ", regs->ip);
739 for (i = 0; i < 16; i++) {
742 __get_user(insn, (unsigned char *)(regs->ip + i));
743 printk("%02x ", insn);
751 static int __init setup_print_fatal_signals(char *str)
753 get_option (&str, &print_fatal_signals);
758 __setup("print-fatal-signals=", setup_print_fatal_signals);
761 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
765 BUG_ON(!irqs_disabled());
766 assert_spin_locked(&t->sighand->siglock);
768 /* Short-circuit ignored signals. */
769 if (sig_ignored(t, sig))
772 /* Support queueing exactly one non-rt signal, so that we
773 can get more detailed information about the cause of
775 if (LEGACY_QUEUE(&t->pending, sig))
778 ret = send_signal(sig, info, t, &t->pending);
779 if (!ret && !sigismember(&t->blocked, sig))
780 signal_wake_up(t, sig == SIGKILL);
786 * Force a signal that the process can't ignore: if necessary
787 * we unblock the signal and change any SIG_IGN to SIG_DFL.
789 * Note: If we unblock the signal, we always reset it to SIG_DFL,
790 * since we do not want to have a signal handler that was blocked
791 * be invoked when user space had explicitly blocked it.
793 * We don't want to have recursive SIGSEGV's etc, for example.
796 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
798 unsigned long int flags;
799 int ret, blocked, ignored;
800 struct k_sigaction *action;
802 spin_lock_irqsave(&t->sighand->siglock, flags);
803 action = &t->sighand->action[sig-1];
804 ignored = action->sa.sa_handler == SIG_IGN;
805 blocked = sigismember(&t->blocked, sig);
806 if (blocked || ignored) {
807 action->sa.sa_handler = SIG_DFL;
809 sigdelset(&t->blocked, sig);
810 recalc_sigpending_and_wake(t);
813 ret = specific_send_sig_info(sig, info, t);
814 spin_unlock_irqrestore(&t->sighand->siglock, flags);
820 force_sig_specific(int sig, struct task_struct *t)
822 force_sig_info(sig, SEND_SIG_FORCED, t);
826 * Test if P wants to take SIG. After we've checked all threads with this,
827 * it's equivalent to finding no threads not blocking SIG. Any threads not
828 * blocking SIG were ruled out because they are not running and already
829 * have pending signals. Such threads will dequeue from the shared queue
830 * as soon as they're available, so putting the signal on the shared queue
831 * will be equivalent to sending it to one such thread.
833 static inline int wants_signal(int sig, struct task_struct *p)
835 if (sigismember(&p->blocked, sig))
837 if (p->flags & PF_EXITING)
841 if (task_is_stopped_or_traced(p))
843 return task_curr(p) || !signal_pending(p);
847 __group_complete_signal(int sig, struct task_struct *p)
849 struct task_struct *t;
852 * Now find a thread we can wake up to take the signal off the queue.
854 * If the main thread wants the signal, it gets first crack.
855 * Probably the least surprising to the average bear.
857 if (wants_signal(sig, p))
859 else if (thread_group_empty(p))
861 * There is just one thread and it does not need to be woken.
862 * It will dequeue unblocked signals before it runs again.
867 * Otherwise try to find a suitable thread.
869 t = p->signal->curr_target;
871 /* restart balancing at this thread */
872 t = p->signal->curr_target = p;
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);
911 } while_each_thread(p, t);
916 * There will be a core dump. We make all threads other
917 * than the chosen one go into a group stop so that nothing
918 * happens until it gets scheduled, takes the signal off
919 * the shared queue, and does the core dump. This is a
920 * little more complicated than strictly necessary, but it
921 * keeps the signal state that winds up in the core dump
922 * unchanged from the death state, e.g. which thread had
923 * the core-dump signal unblocked.
925 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
926 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
927 p->signal->group_stop_count = 0;
928 p->signal->group_exit_task = t;
931 p->signal->group_stop_count++;
932 signal_wake_up(t, t == p);
933 } while_each_thread(p, t);
938 * The signal is already in the shared-pending queue.
939 * Tell the chosen thread to wake up and dequeue it.
941 signal_wake_up(t, sig == SIGKILL);
946 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
950 assert_spin_locked(&p->sighand->siglock);
951 handle_stop_signal(sig, p);
953 /* Short-circuit ignored signals. */
954 if (sig_ignored(p, sig))
957 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
958 /* This is a non-RT signal and we already have one queued. */
962 * Put this signal on the shared-pending queue, or fail with EAGAIN.
963 * We always use the shared queue for process-wide signals,
964 * to avoid several races.
966 ret = send_signal(sig, info, p, &p->signal->shared_pending);
970 __group_complete_signal(sig, p);
975 * Nuke all other threads in the group.
977 void zap_other_threads(struct task_struct *p)
979 struct task_struct *t;
981 p->signal->flags = SIGNAL_GROUP_EXIT;
982 p->signal->group_stop_count = 0;
984 for (t = next_thread(p); t != p; t = next_thread(t)) {
986 * Don't bother with already dead threads
991 /* SIGKILL will be handled before any pending SIGSTOP */
992 sigaddset(&t->pending.signal, SIGKILL);
993 signal_wake_up(t, 1);
997 int fastcall __fatal_signal_pending(struct task_struct *tsk)
999 return sigismember(&tsk->pending.signal, SIGKILL);
1003 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1005 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1007 struct sighand_struct *sighand;
1010 sighand = rcu_dereference(tsk->sighand);
1011 if (unlikely(sighand == NULL))
1014 spin_lock_irqsave(&sighand->siglock, *flags);
1015 if (likely(sighand == tsk->sighand))
1017 spin_unlock_irqrestore(&sighand->siglock, *flags);
1023 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1025 unsigned long flags;
1028 ret = check_kill_permission(sig, info, p);
1032 if (lock_task_sighand(p, &flags)) {
1033 ret = __group_send_sig_info(sig, info, p);
1034 unlock_task_sighand(p, &flags);
1042 * kill_pgrp_info() sends a signal to a process group: this is what the tty
1043 * control characters do (^C, ^Z etc)
1046 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1048 struct task_struct *p = NULL;
1049 int retval, success;
1053 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1054 int err = group_send_sig_info(sig, info, p);
1057 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1058 return success ? 0 : retval;
1061 int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1065 read_lock(&tasklist_lock);
1066 retval = __kill_pgrp_info(sig, info, pgrp);
1067 read_unlock(&tasklist_lock);
1072 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1075 struct task_struct *p;
1078 if (unlikely(sig_needs_tasklist(sig)))
1079 read_lock(&tasklist_lock);
1081 p = pid_task(pid, PIDTYPE_PID);
1084 error = group_send_sig_info(sig, info, p);
1086 if (unlikely(sig_needs_tasklist(sig)))
1087 read_unlock(&tasklist_lock);
1093 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1097 error = kill_pid_info(sig, info, find_vpid(pid));
1102 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1103 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1104 uid_t uid, uid_t euid, u32 secid)
1107 struct task_struct *p;
1109 if (!valid_signal(sig))
1112 read_lock(&tasklist_lock);
1113 p = pid_task(pid, PIDTYPE_PID);
1118 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1119 && (euid != p->suid) && (euid != p->uid)
1120 && (uid != p->suid) && (uid != p->uid)) {
1124 ret = security_task_kill(p, info, sig, secid);
1127 if (sig && p->sighand) {
1128 unsigned long flags;
1129 spin_lock_irqsave(&p->sighand->siglock, flags);
1130 ret = __group_send_sig_info(sig, info, p);
1131 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1134 read_unlock(&tasklist_lock);
1137 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1140 * kill_something_info() interprets pid in interesting ways just like kill(2).
1142 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1143 * is probably wrong. Should make it like BSD or SYSV.
1146 static int kill_something_info(int sig, struct siginfo *info, int pid)
1151 ret = kill_pgrp_info(sig, info, task_pgrp(current));
1152 } else if (pid == -1) {
1153 int retval = 0, count = 0;
1154 struct task_struct * p;
1156 read_lock(&tasklist_lock);
1157 for_each_process(p) {
1158 if (p->pid > 1 && !same_thread_group(p, current)) {
1159 int err = group_send_sig_info(sig, info, p);
1165 read_unlock(&tasklist_lock);
1166 ret = count ? retval : -ESRCH;
1167 } else if (pid < 0) {
1168 ret = kill_pgrp_info(sig, info, find_vpid(-pid));
1170 ret = kill_pid_info(sig, info, find_vpid(pid));
1177 * These are for backward compatibility with the rest of the kernel source.
1181 * These two are the most common entry points. They send a signal
1182 * just to the specific thread.
1185 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1188 unsigned long flags;
1191 * Make sure legacy kernel users don't send in bad values
1192 * (normal paths check this in check_kill_permission).
1194 if (!valid_signal(sig))
1198 * We need the tasklist lock even for the specific
1199 * thread case (when we don't need to follow the group
1200 * lists) in order to avoid races with "p->sighand"
1201 * going away or changing from under us.
1203 read_lock(&tasklist_lock);
1204 spin_lock_irqsave(&p->sighand->siglock, flags);
1205 ret = specific_send_sig_info(sig, info, p);
1206 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1207 read_unlock(&tasklist_lock);
1211 #define __si_special(priv) \
1212 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1215 send_sig(int sig, struct task_struct *p, int priv)
1217 return send_sig_info(sig, __si_special(priv), p);
1221 * This is the entry point for "process-wide" signals.
1222 * They will go to an appropriate thread in the thread group.
1225 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1228 read_lock(&tasklist_lock);
1229 ret = group_send_sig_info(sig, info, p);
1230 read_unlock(&tasklist_lock);
1235 force_sig(int sig, struct task_struct *p)
1237 force_sig_info(sig, SEND_SIG_PRIV, p);
1241 * When things go south during signal handling, we
1242 * will force a SIGSEGV. And if the signal that caused
1243 * the problem was already a SIGSEGV, we'll want to
1244 * make sure we don't even try to deliver the signal..
1247 force_sigsegv(int sig, struct task_struct *p)
1249 if (sig == SIGSEGV) {
1250 unsigned long flags;
1251 spin_lock_irqsave(&p->sighand->siglock, flags);
1252 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1253 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1255 force_sig(SIGSEGV, p);
1259 int kill_pgrp(struct pid *pid, int sig, int priv)
1261 return kill_pgrp_info(sig, __si_special(priv), pid);
1263 EXPORT_SYMBOL(kill_pgrp);
1265 int kill_pid(struct pid *pid, int sig, int priv)
1267 return kill_pid_info(sig, __si_special(priv), pid);
1269 EXPORT_SYMBOL(kill_pid);
1272 kill_proc(pid_t pid, int sig, int priv)
1277 ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
1283 * These functions support sending signals using preallocated sigqueue
1284 * structures. This is needed "because realtime applications cannot
1285 * afford to lose notifications of asynchronous events, like timer
1286 * expirations or I/O completions". In the case of Posix Timers
1287 * we allocate the sigqueue structure from the timer_create. If this
1288 * allocation fails we are able to report the failure to the application
1289 * with an EAGAIN error.
1292 struct sigqueue *sigqueue_alloc(void)
1296 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1297 q->flags |= SIGQUEUE_PREALLOC;
1301 void sigqueue_free(struct sigqueue *q)
1303 unsigned long flags;
1304 spinlock_t *lock = ¤t->sighand->siglock;
1306 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1308 * If the signal is still pending remove it from the
1309 * pending queue. We must hold ->siglock while testing
1310 * q->list to serialize with collect_signal().
1312 spin_lock_irqsave(lock, flags);
1313 if (!list_empty(&q->list))
1314 list_del_init(&q->list);
1315 spin_unlock_irqrestore(lock, flags);
1317 q->flags &= ~SIGQUEUE_PREALLOC;
1321 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1323 unsigned long flags;
1326 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1329 * The rcu based delayed sighand destroy makes it possible to
1330 * run this without tasklist lock held. The task struct itself
1331 * cannot go away as create_timer did get_task_struct().
1333 * We return -1, when the task is marked exiting, so
1334 * posix_timer_event can redirect it to the group leader
1338 if (!likely(lock_task_sighand(p, &flags))) {
1343 if (unlikely(!list_empty(&q->list))) {
1345 * If an SI_TIMER entry is already queue just increment
1346 * the overrun count.
1348 BUG_ON(q->info.si_code != SI_TIMER);
1349 q->info.si_overrun++;
1352 /* Short-circuit ignored signals. */
1353 if (sig_ignored(p, sig)) {
1358 * Deliver the signal to listening signalfds. This must be called
1359 * with the sighand lock held.
1361 signalfd_notify(p, sig);
1363 list_add_tail(&q->list, &p->pending.list);
1364 sigaddset(&p->pending.signal, sig);
1365 if (!sigismember(&p->blocked, sig))
1366 signal_wake_up(p, sig == SIGKILL);
1369 unlock_task_sighand(p, &flags);
1377 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1379 unsigned long flags;
1382 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1384 read_lock(&tasklist_lock);
1385 /* Since it_lock is held, p->sighand cannot be NULL. */
1386 spin_lock_irqsave(&p->sighand->siglock, flags);
1387 handle_stop_signal(sig, p);
1389 /* Short-circuit ignored signals. */
1390 if (sig_ignored(p, sig)) {
1395 if (unlikely(!list_empty(&q->list))) {
1397 * If an SI_TIMER entry is already queue just increment
1398 * the overrun count. Other uses should not try to
1399 * send the signal multiple times.
1401 BUG_ON(q->info.si_code != SI_TIMER);
1402 q->info.si_overrun++;
1406 * Deliver the signal to listening signalfds. This must be called
1407 * with the sighand lock held.
1409 signalfd_notify(p, sig);
1412 * Put this signal on the shared-pending queue.
1413 * We always use the shared queue for process-wide signals,
1414 * to avoid several races.
1416 list_add_tail(&q->list, &p->signal->shared_pending.list);
1417 sigaddset(&p->signal->shared_pending.signal, sig);
1419 __group_complete_signal(sig, p);
1421 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1422 read_unlock(&tasklist_lock);
1427 * Wake up any threads in the parent blocked in wait* syscalls.
1429 static inline void __wake_up_parent(struct task_struct *p,
1430 struct task_struct *parent)
1432 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1436 * Let a parent know about the death of a child.
1437 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1440 void do_notify_parent(struct task_struct *tsk, int sig)
1442 struct siginfo info;
1443 unsigned long flags;
1444 struct sighand_struct *psig;
1448 /* do_notify_parent_cldstop should have been called instead. */
1449 BUG_ON(task_is_stopped_or_traced(tsk));
1451 BUG_ON(!tsk->ptrace &&
1452 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1454 info.si_signo = sig;
1457 * we are under tasklist_lock here so our parent is tied to
1458 * us and cannot exit and release its namespace.
1460 * the only it can is to switch its nsproxy with sys_unshare,
1461 * bu uncharing pid namespaces is not allowed, so we'll always
1462 * see relevant namespace
1464 * write_lock() currently calls preempt_disable() which is the
1465 * same as rcu_read_lock(), but according to Oleg, this is not
1466 * correct to rely on this
1469 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
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;
1537 * see comment in do_notify_parent() abot the following 3 lines
1540 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1543 info.si_uid = tsk->uid;
1545 /* FIXME: find out whether or not this is supposed to be c*time. */
1546 info.si_utime = cputime_to_jiffies(tsk->utime);
1547 info.si_stime = cputime_to_jiffies(tsk->stime);
1552 info.si_status = SIGCONT;
1555 info.si_status = tsk->signal->group_exit_code & 0x7f;
1558 info.si_status = tsk->exit_code & 0x7f;
1564 sighand = parent->sighand;
1565 spin_lock_irqsave(&sighand->siglock, flags);
1566 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1567 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1568 __group_send_sig_info(SIGCHLD, &info, parent);
1570 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1572 __wake_up_parent(tsk, parent);
1573 spin_unlock_irqrestore(&sighand->siglock, flags);
1576 static inline int may_ptrace_stop(void)
1578 if (!likely(current->ptrace & PT_PTRACED))
1581 if (unlikely(current->parent == current->real_parent &&
1582 (current->ptrace & PT_ATTACHED)))
1586 * Are we in the middle of do_coredump?
1587 * If so and our tracer is also part of the coredump stopping
1588 * is a deadlock situation, and pointless because our tracer
1589 * is dead so don't allow us to stop.
1590 * If SIGKILL was already sent before the caller unlocked
1591 * ->siglock we must see ->core_waiters != 0. Otherwise it
1592 * is safe to enter schedule().
1594 if (unlikely(current->mm->core_waiters) &&
1595 unlikely(current->mm == current->parent->mm))
1602 * This must be called with current->sighand->siglock held.
1604 * This should be the path for all ptrace stops.
1605 * We always set current->last_siginfo while stopped here.
1606 * That makes it a way to test a stopped process for
1607 * being ptrace-stopped vs being job-control-stopped.
1609 * If we actually decide not to stop at all because the tracer is gone,
1610 * we leave nostop_code in current->exit_code.
1612 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1615 * If there is a group stop in progress,
1616 * we must participate in the bookkeeping.
1618 if (current->signal->group_stop_count > 0)
1619 --current->signal->group_stop_count;
1621 current->last_siginfo = info;
1622 current->exit_code = exit_code;
1624 /* Let the debugger run. */
1625 set_current_state(TASK_TRACED);
1626 spin_unlock_irq(¤t->sighand->siglock);
1628 read_lock(&tasklist_lock);
1629 if (may_ptrace_stop()) {
1630 do_notify_parent_cldstop(current, CLD_TRAPPED);
1631 read_unlock(&tasklist_lock);
1635 * By the time we got the lock, our tracer went away.
1638 read_unlock(&tasklist_lock);
1639 set_current_state(TASK_RUNNING);
1640 current->exit_code = nostop_code;
1644 * We are back. Now reacquire the siglock before touching
1645 * last_siginfo, so that we are sure to have synchronized with
1646 * any signal-sending on another CPU that wants to examine it.
1648 spin_lock_irq(¤t->sighand->siglock);
1649 current->last_siginfo = NULL;
1652 * Queued signals ignored us while we were stopped for tracing.
1653 * So check for any that we should take before resuming user mode.
1654 * This sets TIF_SIGPENDING, but never clears it.
1656 recalc_sigpending_tsk(current);
1659 void ptrace_notify(int exit_code)
1663 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1665 memset(&info, 0, sizeof info);
1666 info.si_signo = SIGTRAP;
1667 info.si_code = exit_code;
1668 info.si_pid = task_pid_vnr(current);
1669 info.si_uid = current->uid;
1671 /* Let the debugger run. */
1672 spin_lock_irq(¤t->sighand->siglock);
1673 ptrace_stop(exit_code, 0, &info);
1674 spin_unlock_irq(¤t->sighand->siglock);
1678 finish_stop(int stop_count)
1681 * If there are no other threads in the group, or if there is
1682 * a group stop in progress and we are the last to stop,
1683 * report to the parent. When ptraced, every thread reports itself.
1685 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1686 read_lock(&tasklist_lock);
1687 do_notify_parent_cldstop(current, CLD_STOPPED);
1688 read_unlock(&tasklist_lock);
1693 } while (try_to_freeze());
1695 * Now we don't run again until continued.
1697 current->exit_code = 0;
1701 * This performs the stopping for SIGSTOP and other stop signals.
1702 * We have to stop all threads in the thread group.
1703 * Returns nonzero if we've actually stopped and released the siglock.
1704 * Returns zero if we didn't stop and still hold the siglock.
1706 static int do_signal_stop(int signr)
1708 struct signal_struct *sig = current->signal;
1711 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1714 if (sig->group_stop_count > 0) {
1716 * There is a group stop in progress. We don't need to
1717 * start another one.
1719 stop_count = --sig->group_stop_count;
1722 * There is no group stop already in progress.
1723 * We must initiate one now.
1725 struct task_struct *t;
1727 sig->group_exit_code = signr;
1730 for (t = next_thread(current); t != current; t = next_thread(t))
1732 * Setting state to TASK_STOPPED for a group
1733 * stop is always done with the siglock held,
1734 * so this check has no races.
1736 if (!t->exit_state &&
1737 !task_is_stopped_or_traced(t)) {
1739 signal_wake_up(t, 0);
1741 sig->group_stop_count = stop_count;
1744 if (stop_count == 0)
1745 sig->flags = SIGNAL_STOP_STOPPED;
1746 current->exit_code = sig->group_exit_code;
1747 __set_current_state(TASK_STOPPED);
1749 spin_unlock_irq(¤t->sighand->siglock);
1750 finish_stop(stop_count);
1755 * Do appropriate magic when group_stop_count > 0.
1756 * We return nonzero if we stopped, after releasing the siglock.
1757 * We return zero if we still hold the siglock and should look
1758 * for another signal without checking group_stop_count again.
1760 static int handle_group_stop(void)
1764 if (current->signal->group_exit_task == current) {
1766 * Group stop is so we can do a core dump,
1767 * We are the initiating thread, so get on with it.
1769 current->signal->group_exit_task = NULL;
1773 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1775 * Group stop is so another thread can do a core dump,
1776 * or else we are racing against a death signal.
1777 * Just punt the stop so we can get the next signal.
1782 * There is a group stop in progress. We stop
1783 * without any associated signal being in our queue.
1785 stop_count = --current->signal->group_stop_count;
1786 if (stop_count == 0)
1787 current->signal->flags = SIGNAL_STOP_STOPPED;
1788 current->exit_code = current->signal->group_exit_code;
1789 set_current_state(TASK_STOPPED);
1790 spin_unlock_irq(¤t->sighand->siglock);
1791 finish_stop(stop_count);
1795 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1796 struct pt_regs *regs, void *cookie)
1798 sigset_t *mask = ¤t->blocked;
1804 spin_lock_irq(¤t->sighand->siglock);
1806 struct k_sigaction *ka;
1808 if (unlikely(current->signal->group_stop_count > 0) &&
1809 handle_group_stop())
1812 signr = dequeue_signal(current, mask, info);
1815 break; /* will return 0 */
1817 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1818 ptrace_signal_deliver(regs, cookie);
1820 /* Let the debugger run. */
1821 ptrace_stop(signr, signr, info);
1823 /* We're back. Did the debugger cancel the sig? */
1824 signr = current->exit_code;
1828 current->exit_code = 0;
1830 /* Update the siginfo structure if the signal has
1831 changed. If the debugger wanted something
1832 specific in the siginfo structure then it should
1833 have updated *info via PTRACE_SETSIGINFO. */
1834 if (signr != info->si_signo) {
1835 info->si_signo = signr;
1837 info->si_code = SI_USER;
1838 info->si_pid = task_pid_vnr(current->parent);
1839 info->si_uid = current->parent->uid;
1842 /* If the (new) signal is now blocked, requeue it. */
1843 if (sigismember(¤t->blocked, signr)) {
1844 specific_send_sig_info(signr, info, current);
1849 ka = ¤t->sighand->action[signr-1];
1850 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1852 if (ka->sa.sa_handler != SIG_DFL) {
1853 /* Run the handler. */
1856 if (ka->sa.sa_flags & SA_ONESHOT)
1857 ka->sa.sa_handler = SIG_DFL;
1859 break; /* will return non-zero "signr" value */
1863 * Now we are doing the default action for this signal.
1865 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1869 * Global init gets no signals it doesn't want.
1871 if (is_global_init(current))
1874 if (sig_kernel_stop(signr)) {
1876 * The default action is to stop all threads in
1877 * the thread group. The job control signals
1878 * do nothing in an orphaned pgrp, but SIGSTOP
1879 * always works. Note that siglock needs to be
1880 * dropped during the call to is_orphaned_pgrp()
1881 * because of lock ordering with tasklist_lock.
1882 * This allows an intervening SIGCONT to be posted.
1883 * We need to check for that and bail out if necessary.
1885 if (signr != SIGSTOP) {
1886 spin_unlock_irq(¤t->sighand->siglock);
1888 /* signals can be posted during this window */
1890 if (is_current_pgrp_orphaned())
1893 spin_lock_irq(¤t->sighand->siglock);
1896 if (likely(do_signal_stop(signr))) {
1897 /* It released the siglock. */
1902 * We didn't actually stop, due to a race
1903 * with SIGCONT or something like that.
1908 spin_unlock_irq(¤t->sighand->siglock);
1911 * Anything else is fatal, maybe with a core dump.
1913 current->flags |= PF_SIGNALED;
1914 if ((signr != SIGKILL) && print_fatal_signals)
1915 print_fatal_signal(regs, signr);
1916 if (sig_kernel_coredump(signr)) {
1918 * If it was able to dump core, this kills all
1919 * other threads in the group and synchronizes with
1920 * their demise. If we lost the race with another
1921 * thread getting here, it set group_exit_code
1922 * first and our do_group_exit call below will use
1923 * that value and ignore the one we pass it.
1925 do_coredump((long)signr, signr, regs);
1929 * Death signals, no core dump.
1931 do_group_exit(signr);
1934 spin_unlock_irq(¤t->sighand->siglock);
1938 EXPORT_SYMBOL(recalc_sigpending);
1939 EXPORT_SYMBOL_GPL(dequeue_signal);
1940 EXPORT_SYMBOL(flush_signals);
1941 EXPORT_SYMBOL(force_sig);
1942 EXPORT_SYMBOL(kill_proc);
1943 EXPORT_SYMBOL(ptrace_notify);
1944 EXPORT_SYMBOL(send_sig);
1945 EXPORT_SYMBOL(send_sig_info);
1946 EXPORT_SYMBOL(sigprocmask);
1947 EXPORT_SYMBOL(block_all_signals);
1948 EXPORT_SYMBOL(unblock_all_signals);
1952 * System call entry points.
1955 asmlinkage long sys_restart_syscall(void)
1957 struct restart_block *restart = ¤t_thread_info()->restart_block;
1958 return restart->fn(restart);
1961 long do_no_restart_syscall(struct restart_block *param)
1967 * We don't need to get the kernel lock - this is all local to this
1968 * particular thread.. (and that's good, because this is _heavily_
1969 * used by various programs)
1973 * This is also useful for kernel threads that want to temporarily
1974 * (or permanently) block certain signals.
1976 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1977 * interface happily blocks "unblockable" signals like SIGKILL
1980 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1984 spin_lock_irq(¤t->sighand->siglock);
1986 *oldset = current->blocked;
1991 sigorsets(¤t->blocked, ¤t->blocked, set);
1994 signandsets(¤t->blocked, ¤t->blocked, set);
1997 current->blocked = *set;
2002 recalc_sigpending();
2003 spin_unlock_irq(¤t->sighand->siglock);
2009 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2011 int error = -EINVAL;
2012 sigset_t old_set, new_set;
2014 /* XXX: Don't preclude handling different sized sigset_t's. */
2015 if (sigsetsize != sizeof(sigset_t))
2020 if (copy_from_user(&new_set, set, sizeof(*set)))
2022 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2024 error = sigprocmask(how, &new_set, &old_set);
2030 spin_lock_irq(¤t->sighand->siglock);
2031 old_set = current->blocked;
2032 spin_unlock_irq(¤t->sighand->siglock);
2036 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2044 long do_sigpending(void __user *set, unsigned long sigsetsize)
2046 long error = -EINVAL;
2049 if (sigsetsize > sizeof(sigset_t))
2052 spin_lock_irq(¤t->sighand->siglock);
2053 sigorsets(&pending, ¤t->pending.signal,
2054 ¤t->signal->shared_pending.signal);
2055 spin_unlock_irq(¤t->sighand->siglock);
2057 /* Outside the lock because only this thread touches it. */
2058 sigandsets(&pending, ¤t->blocked, &pending);
2061 if (!copy_to_user(set, &pending, sigsetsize))
2069 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2071 return do_sigpending(set, sigsetsize);
2074 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2076 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2080 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2082 if (from->si_code < 0)
2083 return __copy_to_user(to, from, sizeof(siginfo_t))
2086 * If you change siginfo_t structure, please be sure
2087 * this code is fixed accordingly.
2088 * Please remember to update the signalfd_copyinfo() function
2089 * inside fs/signalfd.c too, in case siginfo_t changes.
2090 * It should never copy any pad contained in the structure
2091 * to avoid security leaks, but must copy the generic
2092 * 3 ints plus the relevant union member.
2094 err = __put_user(from->si_signo, &to->si_signo);
2095 err |= __put_user(from->si_errno, &to->si_errno);
2096 err |= __put_user((short)from->si_code, &to->si_code);
2097 switch (from->si_code & __SI_MASK) {
2099 err |= __put_user(from->si_pid, &to->si_pid);
2100 err |= __put_user(from->si_uid, &to->si_uid);
2103 err |= __put_user(from->si_tid, &to->si_tid);
2104 err |= __put_user(from->si_overrun, &to->si_overrun);
2105 err |= __put_user(from->si_ptr, &to->si_ptr);
2108 err |= __put_user(from->si_band, &to->si_band);
2109 err |= __put_user(from->si_fd, &to->si_fd);
2112 err |= __put_user(from->si_addr, &to->si_addr);
2113 #ifdef __ARCH_SI_TRAPNO
2114 err |= __put_user(from->si_trapno, &to->si_trapno);
2118 err |= __put_user(from->si_pid, &to->si_pid);
2119 err |= __put_user(from->si_uid, &to->si_uid);
2120 err |= __put_user(from->si_status, &to->si_status);
2121 err |= __put_user(from->si_utime, &to->si_utime);
2122 err |= __put_user(from->si_stime, &to->si_stime);
2124 case __SI_RT: /* This is not generated by the kernel as of now. */
2125 case __SI_MESGQ: /* But this is */
2126 err |= __put_user(from->si_pid, &to->si_pid);
2127 err |= __put_user(from->si_uid, &to->si_uid);
2128 err |= __put_user(from->si_ptr, &to->si_ptr);
2130 default: /* this is just in case for now ... */
2131 err |= __put_user(from->si_pid, &to->si_pid);
2132 err |= __put_user(from->si_uid, &to->si_uid);
2141 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2142 siginfo_t __user *uinfo,
2143 const struct timespec __user *uts,
2152 /* XXX: Don't preclude handling different sized sigset_t's. */
2153 if (sigsetsize != sizeof(sigset_t))
2156 if (copy_from_user(&these, uthese, sizeof(these)))
2160 * Invert the set of allowed signals to get those we
2163 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2167 if (copy_from_user(&ts, uts, sizeof(ts)))
2169 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2174 spin_lock_irq(¤t->sighand->siglock);
2175 sig = dequeue_signal(current, &these, &info);
2177 timeout = MAX_SCHEDULE_TIMEOUT;
2179 timeout = (timespec_to_jiffies(&ts)
2180 + (ts.tv_sec || ts.tv_nsec));
2183 /* None ready -- temporarily unblock those we're
2184 * interested while we are sleeping in so that we'll
2185 * be awakened when they arrive. */
2186 current->real_blocked = current->blocked;
2187 sigandsets(¤t->blocked, ¤t->blocked, &these);
2188 recalc_sigpending();
2189 spin_unlock_irq(¤t->sighand->siglock);
2191 timeout = schedule_timeout_interruptible(timeout);
2193 spin_lock_irq(¤t->sighand->siglock);
2194 sig = dequeue_signal(current, &these, &info);
2195 current->blocked = current->real_blocked;
2196 siginitset(¤t->real_blocked, 0);
2197 recalc_sigpending();
2200 spin_unlock_irq(¤t->sighand->siglock);
2205 if (copy_siginfo_to_user(uinfo, &info))
2218 sys_kill(int pid, int sig)
2220 struct siginfo info;
2222 info.si_signo = sig;
2224 info.si_code = SI_USER;
2225 info.si_pid = task_tgid_vnr(current);
2226 info.si_uid = current->uid;
2228 return kill_something_info(sig, &info, pid);
2231 static int do_tkill(int tgid, int pid, int sig)
2234 struct siginfo info;
2235 struct task_struct *p;
2238 info.si_signo = sig;
2240 info.si_code = SI_TKILL;
2241 info.si_pid = task_tgid_vnr(current);
2242 info.si_uid = current->uid;
2244 read_lock(&tasklist_lock);
2245 p = find_task_by_vpid(pid);
2246 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2247 error = check_kill_permission(sig, &info, p);
2249 * The null signal is a permissions and process existence
2250 * probe. No signal is actually delivered.
2252 if (!error && sig && p->sighand) {
2253 spin_lock_irq(&p->sighand->siglock);
2254 handle_stop_signal(sig, p);
2255 error = specific_send_sig_info(sig, &info, p);
2256 spin_unlock_irq(&p->sighand->siglock);
2259 read_unlock(&tasklist_lock);
2265 * sys_tgkill - send signal to one specific thread
2266 * @tgid: the thread group ID of the thread
2267 * @pid: the PID of the thread
2268 * @sig: signal to be sent
2270 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2271 * exists but it's not belonging to the target process anymore. This
2272 * method solves the problem of threads exiting and PIDs getting reused.
2274 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2276 /* This is only valid for single tasks */
2277 if (pid <= 0 || tgid <= 0)
2280 return do_tkill(tgid, pid, sig);
2284 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2287 sys_tkill(int pid, int sig)
2289 /* This is only valid for single tasks */
2293 return do_tkill(0, pid, sig);
2297 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2301 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2304 /* Not even root can pretend to send signals from the kernel.
2305 Nor can they impersonate a kill(), which adds source info. */
2306 if (info.si_code >= 0)
2308 info.si_signo = sig;
2310 /* POSIX.1b doesn't mention process groups. */
2311 return kill_proc_info(sig, &info, pid);
2314 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2316 struct k_sigaction *k;
2319 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2322 k = ¤t->sighand->action[sig-1];
2324 spin_lock_irq(¤t->sighand->siglock);
2329 sigdelsetmask(&act->sa.sa_mask,
2330 sigmask(SIGKILL) | sigmask(SIGSTOP));
2334 * "Setting a signal action to SIG_IGN for a signal that is
2335 * pending shall cause the pending signal to be discarded,
2336 * whether or not it is blocked."
2338 * "Setting a signal action to SIG_DFL for a signal that is
2339 * pending and whose default action is to ignore the signal
2340 * (for example, SIGCHLD), shall cause the pending signal to
2341 * be discarded, whether or not it is blocked"
2343 if (act->sa.sa_handler == SIG_IGN ||
2344 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2345 struct task_struct *t = current;
2347 sigaddset(&mask, sig);
2348 rm_from_queue_full(&mask, &t->signal->shared_pending);
2350 rm_from_queue_full(&mask, &t->pending);
2352 } while (t != current);
2356 spin_unlock_irq(¤t->sighand->siglock);
2361 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2367 oss.ss_sp = (void __user *) current->sas_ss_sp;
2368 oss.ss_size = current->sas_ss_size;
2369 oss.ss_flags = sas_ss_flags(sp);
2378 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2379 || __get_user(ss_sp, &uss->ss_sp)
2380 || __get_user(ss_flags, &uss->ss_flags)
2381 || __get_user(ss_size, &uss->ss_size))
2385 if (on_sig_stack(sp))
2391 * Note - this code used to test ss_flags incorrectly
2392 * old code may have been written using ss_flags==0
2393 * to mean ss_flags==SS_ONSTACK (as this was the only
2394 * way that worked) - this fix preserves that older
2397 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2400 if (ss_flags == SS_DISABLE) {
2405 if (ss_size < MINSIGSTKSZ)
2409 current->sas_ss_sp = (unsigned long) ss_sp;
2410 current->sas_ss_size = ss_size;
2415 if (copy_to_user(uoss, &oss, sizeof(oss)))
2424 #ifdef __ARCH_WANT_SYS_SIGPENDING
2427 sys_sigpending(old_sigset_t __user *set)
2429 return do_sigpending(set, sizeof(*set));
2434 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2435 /* Some platforms have their own version with special arguments others
2436 support only sys_rt_sigprocmask. */
2439 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2442 old_sigset_t old_set, new_set;
2446 if (copy_from_user(&new_set, set, sizeof(*set)))
2448 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2450 spin_lock_irq(¤t->sighand->siglock);
2451 old_set = current->blocked.sig[0];
2459 sigaddsetmask(¤t->blocked, new_set);
2462 sigdelsetmask(¤t->blocked, new_set);
2465 current->blocked.sig[0] = new_set;
2469 recalc_sigpending();
2470 spin_unlock_irq(¤t->sighand->siglock);
2476 old_set = current->blocked.sig[0];
2479 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2486 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2488 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2490 sys_rt_sigaction(int sig,
2491 const struct sigaction __user *act,
2492 struct sigaction __user *oact,
2495 struct k_sigaction new_sa, old_sa;
2498 /* XXX: Don't preclude handling different sized sigset_t's. */
2499 if (sigsetsize != sizeof(sigset_t))
2503 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2507 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2510 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2516 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2518 #ifdef __ARCH_WANT_SYS_SGETMASK
2521 * For backwards compatibility. Functionality superseded by sigprocmask.
2527 return current->blocked.sig[0];
2531 sys_ssetmask(int newmask)
2535 spin_lock_irq(¤t->sighand->siglock);
2536 old = current->blocked.sig[0];
2538 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2540 recalc_sigpending();
2541 spin_unlock_irq(¤t->sighand->siglock);
2545 #endif /* __ARCH_WANT_SGETMASK */
2547 #ifdef __ARCH_WANT_SYS_SIGNAL
2549 * For backwards compatibility. Functionality superseded by sigaction.
2551 asmlinkage unsigned long
2552 sys_signal(int sig, __sighandler_t handler)
2554 struct k_sigaction new_sa, old_sa;
2557 new_sa.sa.sa_handler = handler;
2558 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2559 sigemptyset(&new_sa.sa.sa_mask);
2561 ret = do_sigaction(sig, &new_sa, &old_sa);
2563 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2565 #endif /* __ARCH_WANT_SYS_SIGNAL */
2567 #ifdef __ARCH_WANT_SYS_PAUSE
2572 current->state = TASK_INTERRUPTIBLE;
2574 return -ERESTARTNOHAND;
2579 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2580 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2584 /* XXX: Don't preclude handling different sized sigset_t's. */
2585 if (sigsetsize != sizeof(sigset_t))
2588 if (copy_from_user(&newset, unewset, sizeof(newset)))
2590 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2592 spin_lock_irq(¤t->sighand->siglock);
2593 current->saved_sigmask = current->blocked;
2594 current->blocked = newset;
2595 recalc_sigpending();
2596 spin_unlock_irq(¤t->sighand->siglock);
2598 current->state = TASK_INTERRUPTIBLE;
2600 set_thread_flag(TIF_RESTORE_SIGMASK);
2601 return -ERESTARTNOHAND;
2603 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2605 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2610 void __init signals_init(void)
2612 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);