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/tracehook.h>
26 #include <linux/capability.h>
27 #include <linux/freezer.h>
28 #include <linux/pid_namespace.h>
29 #include <linux/nsproxy.h>
30 #define CREATE_TRACE_POINTS
31 #include <trace/events/signal.h>
33 #include <asm/param.h>
34 #include <asm/uaccess.h>
35 #include <asm/unistd.h>
36 #include <asm/siginfo.h>
37 #include "audit.h" /* audit_signal_info() */
40 * SLAB caches for signal bits.
43 static struct kmem_cache *sigqueue_cachep;
45 static void __user *sig_handler(struct task_struct *t, int sig)
47 return t->sighand->action[sig - 1].sa.sa_handler;
50 static int sig_handler_ignored(void __user *handler, int sig)
52 /* Is it explicitly or implicitly ignored? */
53 return handler == SIG_IGN ||
54 (handler == SIG_DFL && sig_kernel_ignore(sig));
57 static int sig_task_ignored(struct task_struct *t, int sig,
62 handler = sig_handler(t, sig);
64 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
65 handler == SIG_DFL && !from_ancestor_ns)
68 return sig_handler_ignored(handler, sig);
71 static int sig_ignored(struct task_struct *t, int sig, int from_ancestor_ns)
74 * Blocked signals are never ignored, since the
75 * signal handler may change by the time it is
78 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
81 if (!sig_task_ignored(t, sig, from_ancestor_ns))
85 * Tracers may want to know about even ignored signals.
87 return !tracehook_consider_ignored_signal(t, sig);
91 * Re-calculate pending state from the set of locally pending
92 * signals, globally pending signals, and blocked signals.
94 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
99 switch (_NSIG_WORDS) {
101 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
102 ready |= signal->sig[i] &~ blocked->sig[i];
105 case 4: ready = signal->sig[3] &~ blocked->sig[3];
106 ready |= signal->sig[2] &~ blocked->sig[2];
107 ready |= signal->sig[1] &~ blocked->sig[1];
108 ready |= signal->sig[0] &~ blocked->sig[0];
111 case 2: ready = signal->sig[1] &~ blocked->sig[1];
112 ready |= signal->sig[0] &~ blocked->sig[0];
115 case 1: ready = signal->sig[0] &~ blocked->sig[0];
120 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
122 static int recalc_sigpending_tsk(struct task_struct *t)
124 if (t->signal->group_stop_count > 0 ||
125 PENDING(&t->pending, &t->blocked) ||
126 PENDING(&t->signal->shared_pending, &t->blocked)) {
127 set_tsk_thread_flag(t, TIF_SIGPENDING);
131 * We must never clear the flag in another thread, or in current
132 * when it's possible the current syscall is returning -ERESTART*.
133 * So we don't clear it here, and only callers who know they should do.
139 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
140 * This is superfluous when called on current, the wakeup is a harmless no-op.
142 void recalc_sigpending_and_wake(struct task_struct *t)
144 if (recalc_sigpending_tsk(t))
145 signal_wake_up(t, 0);
148 void recalc_sigpending(void)
150 if (unlikely(tracehook_force_sigpending()))
151 set_thread_flag(TIF_SIGPENDING);
152 else if (!recalc_sigpending_tsk(current) && !freezing(current))
153 clear_thread_flag(TIF_SIGPENDING);
157 /* Given the mask, find the first available signal that should be serviced. */
159 int next_signal(struct sigpending *pending, sigset_t *mask)
161 unsigned long i, *s, *m, x;
164 s = pending->signal.sig;
166 switch (_NSIG_WORDS) {
168 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
169 if ((x = *s &~ *m) != 0) {
170 sig = ffz(~x) + i*_NSIG_BPW + 1;
175 case 2: if ((x = s[0] &~ m[0]) != 0)
177 else if ((x = s[1] &~ m[1]) != 0)
184 case 1: if ((x = *s &~ *m) != 0)
193 * allocate a new signal queue record
194 * - this may be called without locks if and only if t == current, otherwise an
195 * appopriate lock must be held to stop the target task from exiting
197 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
200 struct sigqueue *q = NULL;
201 struct user_struct *user;
204 * We won't get problems with the target's UID changing under us
205 * because changing it requires RCU be used, and if t != current, the
206 * caller must be holding the RCU readlock (by way of a spinlock) and
207 * we use RCU protection here
209 user = get_uid(__task_cred(t)->user);
210 atomic_inc(&user->sigpending);
211 if (override_rlimit ||
212 atomic_read(&user->sigpending) <=
213 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
214 q = kmem_cache_alloc(sigqueue_cachep, flags);
215 if (unlikely(q == NULL)) {
216 atomic_dec(&user->sigpending);
219 INIT_LIST_HEAD(&q->list);
227 static void __sigqueue_free(struct sigqueue *q)
229 if (q->flags & SIGQUEUE_PREALLOC)
231 atomic_dec(&q->user->sigpending);
233 kmem_cache_free(sigqueue_cachep, q);
236 void flush_sigqueue(struct sigpending *queue)
240 sigemptyset(&queue->signal);
241 while (!list_empty(&queue->list)) {
242 q = list_entry(queue->list.next, struct sigqueue , list);
243 list_del_init(&q->list);
249 * Flush all pending signals for a task.
251 void __flush_signals(struct task_struct *t)
253 clear_tsk_thread_flag(t, TIF_SIGPENDING);
254 flush_sigqueue(&t->pending);
255 flush_sigqueue(&t->signal->shared_pending);
258 void flush_signals(struct task_struct *t)
262 spin_lock_irqsave(&t->sighand->siglock, flags);
264 spin_unlock_irqrestore(&t->sighand->siglock, flags);
267 static void __flush_itimer_signals(struct sigpending *pending)
269 sigset_t signal, retain;
270 struct sigqueue *q, *n;
272 signal = pending->signal;
273 sigemptyset(&retain);
275 list_for_each_entry_safe(q, n, &pending->list, list) {
276 int sig = q->info.si_signo;
278 if (likely(q->info.si_code != SI_TIMER)) {
279 sigaddset(&retain, sig);
281 sigdelset(&signal, sig);
282 list_del_init(&q->list);
287 sigorsets(&pending->signal, &signal, &retain);
290 void flush_itimer_signals(void)
292 struct task_struct *tsk = current;
295 spin_lock_irqsave(&tsk->sighand->siglock, flags);
296 __flush_itimer_signals(&tsk->pending);
297 __flush_itimer_signals(&tsk->signal->shared_pending);
298 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
301 void ignore_signals(struct task_struct *t)
305 for (i = 0; i < _NSIG; ++i)
306 t->sighand->action[i].sa.sa_handler = SIG_IGN;
312 * Flush all handlers for a task.
316 flush_signal_handlers(struct task_struct *t, int force_default)
319 struct k_sigaction *ka = &t->sighand->action[0];
320 for (i = _NSIG ; i != 0 ; i--) {
321 if (force_default || ka->sa.sa_handler != SIG_IGN)
322 ka->sa.sa_handler = SIG_DFL;
324 sigemptyset(&ka->sa.sa_mask);
329 int unhandled_signal(struct task_struct *tsk, int sig)
331 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
332 if (is_global_init(tsk))
334 if (handler != SIG_IGN && handler != SIG_DFL)
336 return !tracehook_consider_fatal_signal(tsk, sig);
340 /* Notify the system that a driver wants to block all signals for this
341 * process, and wants to be notified if any signals at all were to be
342 * sent/acted upon. If the notifier routine returns non-zero, then the
343 * signal will be acted upon after all. If the notifier routine returns 0,
344 * then then signal will be blocked. Only one block per process is
345 * allowed. priv is a pointer to private data that the notifier routine
346 * can use to determine if the signal should be blocked or not. */
349 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
353 spin_lock_irqsave(¤t->sighand->siglock, flags);
354 current->notifier_mask = mask;
355 current->notifier_data = priv;
356 current->notifier = notifier;
357 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
360 /* Notify the system that blocking has ended. */
363 unblock_all_signals(void)
367 spin_lock_irqsave(¤t->sighand->siglock, flags);
368 current->notifier = NULL;
369 current->notifier_data = NULL;
371 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
374 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
376 struct sigqueue *q, *first = NULL;
379 * Collect the siginfo appropriate to this signal. Check if
380 * there is another siginfo for the same signal.
382 list_for_each_entry(q, &list->list, list) {
383 if (q->info.si_signo == sig) {
390 sigdelset(&list->signal, sig);
394 list_del_init(&first->list);
395 copy_siginfo(info, &first->info);
396 __sigqueue_free(first);
398 /* Ok, it wasn't in the queue. This must be
399 a fast-pathed signal or we must have been
400 out of queue space. So zero out the info.
402 info->si_signo = sig;
410 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
413 int sig = next_signal(pending, mask);
416 if (current->notifier) {
417 if (sigismember(current->notifier_mask, sig)) {
418 if (!(current->notifier)(current->notifier_data)) {
419 clear_thread_flag(TIF_SIGPENDING);
425 collect_signal(sig, pending, info);
432 * Dequeue a signal and return the element to the caller, which is
433 * expected to free it.
435 * All callers have to hold the siglock.
437 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
441 /* We only dequeue private signals from ourselves, we don't let
442 * signalfd steal them
444 signr = __dequeue_signal(&tsk->pending, mask, info);
446 signr = __dequeue_signal(&tsk->signal->shared_pending,
451 * itimers are process shared and we restart periodic
452 * itimers in the signal delivery path to prevent DoS
453 * attacks in the high resolution timer case. This is
454 * compliant with the old way of self restarting
455 * itimers, as the SIGALRM is a legacy signal and only
456 * queued once. Changing the restart behaviour to
457 * restart the timer in the signal dequeue path is
458 * reducing the timer noise on heavy loaded !highres
461 if (unlikely(signr == SIGALRM)) {
462 struct hrtimer *tmr = &tsk->signal->real_timer;
464 if (!hrtimer_is_queued(tmr) &&
465 tsk->signal->it_real_incr.tv64 != 0) {
466 hrtimer_forward(tmr, tmr->base->get_time(),
467 tsk->signal->it_real_incr);
468 hrtimer_restart(tmr);
477 if (unlikely(sig_kernel_stop(signr))) {
479 * Set a marker that we have dequeued a stop signal. Our
480 * caller might release the siglock and then the pending
481 * stop signal it is about to process is no longer in the
482 * pending bitmasks, but must still be cleared by a SIGCONT
483 * (and overruled by a SIGKILL). So those cases clear this
484 * shared flag after we've set it. Note that this flag may
485 * remain set after the signal we return is ignored or
486 * handled. That doesn't matter because its only purpose
487 * is to alert stop-signal processing code when another
488 * processor has come along and cleared the flag.
490 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
492 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
494 * Release the siglock to ensure proper locking order
495 * of timer locks outside of siglocks. Note, we leave
496 * irqs disabled here, since the posix-timers code is
497 * about to disable them again anyway.
499 spin_unlock(&tsk->sighand->siglock);
500 do_schedule_next_timer(info);
501 spin_lock(&tsk->sighand->siglock);
507 * Tell a process that it has a new active signal..
509 * NOTE! we rely on the previous spin_lock to
510 * lock interrupts for us! We can only be called with
511 * "siglock" held, and the local interrupt must
512 * have been disabled when that got acquired!
514 * No need to set need_resched since signal event passing
515 * goes through ->blocked
517 void signal_wake_up(struct task_struct *t, int resume)
521 set_tsk_thread_flag(t, TIF_SIGPENDING);
524 * For SIGKILL, we want to wake it up in the stopped/traced/killable
525 * case. We don't check t->state here because there is a race with it
526 * executing another processor and just now entering stopped state.
527 * By using wake_up_state, we ensure the process will wake up and
528 * handle its death signal.
530 mask = TASK_INTERRUPTIBLE;
532 mask |= TASK_WAKEKILL;
533 if (!wake_up_state(t, mask))
538 * Remove signals in mask from the pending set and queue.
539 * Returns 1 if any signals were found.
541 * All callers must be holding the siglock.
543 * This version takes a sigset mask and looks at all signals,
544 * not just those in the first mask word.
546 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
548 struct sigqueue *q, *n;
551 sigandsets(&m, mask, &s->signal);
552 if (sigisemptyset(&m))
555 signandsets(&s->signal, &s->signal, mask);
556 list_for_each_entry_safe(q, n, &s->list, list) {
557 if (sigismember(mask, q->info.si_signo)) {
558 list_del_init(&q->list);
565 * Remove signals in mask from the pending set and queue.
566 * Returns 1 if any signals were found.
568 * All callers must be holding the siglock.
570 static int rm_from_queue(unsigned long mask, struct sigpending *s)
572 struct sigqueue *q, *n;
574 if (!sigtestsetmask(&s->signal, mask))
577 sigdelsetmask(&s->signal, mask);
578 list_for_each_entry_safe(q, n, &s->list, list) {
579 if (q->info.si_signo < SIGRTMIN &&
580 (mask & sigmask(q->info.si_signo))) {
581 list_del_init(&q->list);
589 * Bad permissions for sending the signal
590 * - the caller must hold at least the RCU read lock
592 static int check_kill_permission(int sig, struct siginfo *info,
593 struct task_struct *t)
595 const struct cred *cred = current_cred(), *tcred;
599 if (!valid_signal(sig))
602 if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
605 error = audit_signal_info(sig, t); /* Let audit system see the signal */
609 tcred = __task_cred(t);
610 if ((cred->euid ^ tcred->suid) &&
611 (cred->euid ^ tcred->uid) &&
612 (cred->uid ^ tcred->suid) &&
613 (cred->uid ^ tcred->uid) &&
614 !capable(CAP_KILL)) {
617 sid = task_session(t);
619 * We don't return the error if sid == NULL. The
620 * task was unhashed, the caller must notice this.
622 if (!sid || sid == task_session(current))
629 return security_task_kill(t, info, sig, 0);
633 * Handle magic process-wide effects of stop/continue signals. Unlike
634 * the signal actions, these happen immediately at signal-generation
635 * time regardless of blocking, ignoring, or handling. This does the
636 * actual continuing for SIGCONT, but not the actual stopping for stop
637 * signals. The process stop is done as a signal action for SIG_DFL.
639 * Returns true if the signal should be actually delivered, otherwise
640 * it should be dropped.
642 static int prepare_signal(int sig, struct task_struct *p, int from_ancestor_ns)
644 struct signal_struct *signal = p->signal;
645 struct task_struct *t;
647 if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
649 * The process is in the middle of dying, nothing to do.
651 } else if (sig_kernel_stop(sig)) {
653 * This is a stop signal. Remove SIGCONT from all queues.
655 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
658 rm_from_queue(sigmask(SIGCONT), &t->pending);
659 } while_each_thread(p, t);
660 } else if (sig == SIGCONT) {
663 * Remove all stop signals from all queues,
664 * and wake all threads.
666 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
670 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
672 * If there is a handler for SIGCONT, we must make
673 * sure that no thread returns to user mode before
674 * we post the signal, in case it was the only
675 * thread eligible to run the signal handler--then
676 * it must not do anything between resuming and
677 * running the handler. With the TIF_SIGPENDING
678 * flag set, the thread will pause and acquire the
679 * siglock that we hold now and until we've queued
680 * the pending signal.
682 * Wake up the stopped thread _after_ setting
685 state = __TASK_STOPPED;
686 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
687 set_tsk_thread_flag(t, TIF_SIGPENDING);
688 state |= TASK_INTERRUPTIBLE;
690 wake_up_state(t, state);
691 } while_each_thread(p, t);
694 * Notify the parent with CLD_CONTINUED if we were stopped.
696 * If we were in the middle of a group stop, we pretend it
697 * was already finished, and then continued. Since SIGCHLD
698 * doesn't queue we report only CLD_STOPPED, as if the next
699 * CLD_CONTINUED was dropped.
702 if (signal->flags & SIGNAL_STOP_STOPPED)
703 why |= SIGNAL_CLD_CONTINUED;
704 else if (signal->group_stop_count)
705 why |= SIGNAL_CLD_STOPPED;
709 * The first thread which returns from do_signal_stop()
710 * will take ->siglock, notice SIGNAL_CLD_MASK, and
711 * notify its parent. See get_signal_to_deliver().
713 signal->flags = why | SIGNAL_STOP_CONTINUED;
714 signal->group_stop_count = 0;
715 signal->group_exit_code = 0;
718 * We are not stopped, but there could be a stop
719 * signal in the middle of being processed after
720 * being removed from the queue. Clear that too.
722 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
726 return !sig_ignored(p, sig, from_ancestor_ns);
730 * Test if P wants to take SIG. After we've checked all threads with this,
731 * it's equivalent to finding no threads not blocking SIG. Any threads not
732 * blocking SIG were ruled out because they are not running and already
733 * have pending signals. Such threads will dequeue from the shared queue
734 * as soon as they're available, so putting the signal on the shared queue
735 * will be equivalent to sending it to one such thread.
737 static inline int wants_signal(int sig, struct task_struct *p)
739 if (sigismember(&p->blocked, sig))
741 if (p->flags & PF_EXITING)
745 if (task_is_stopped_or_traced(p))
747 return task_curr(p) || !signal_pending(p);
750 static void complete_signal(int sig, struct task_struct *p, int group)
752 struct signal_struct *signal = p->signal;
753 struct task_struct *t;
756 * Now find a thread we can wake up to take the signal off the queue.
758 * If the main thread wants the signal, it gets first crack.
759 * Probably the least surprising to the average bear.
761 if (wants_signal(sig, p))
763 else if (!group || thread_group_empty(p))
765 * There is just one thread and it does not need to be woken.
766 * It will dequeue unblocked signals before it runs again.
771 * Otherwise try to find a suitable thread.
773 t = signal->curr_target;
774 while (!wants_signal(sig, t)) {
776 if (t == signal->curr_target)
778 * No thread needs to be woken.
779 * Any eligible threads will see
780 * the signal in the queue soon.
784 signal->curr_target = t;
788 * Found a killable thread. If the signal will be fatal,
789 * then start taking the whole group down immediately.
791 if (sig_fatal(p, sig) &&
792 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
793 !sigismember(&t->real_blocked, sig) &&
795 !tracehook_consider_fatal_signal(t, sig))) {
797 * This signal will be fatal to the whole group.
799 if (!sig_kernel_coredump(sig)) {
801 * Start a group exit and wake everybody up.
802 * This way we don't have other threads
803 * running and doing things after a slower
804 * thread has the fatal signal pending.
806 signal->flags = SIGNAL_GROUP_EXIT;
807 signal->group_exit_code = sig;
808 signal->group_stop_count = 0;
811 sigaddset(&t->pending.signal, SIGKILL);
812 signal_wake_up(t, 1);
813 } while_each_thread(p, t);
819 * The signal is already in the shared-pending queue.
820 * Tell the chosen thread to wake up and dequeue it.
822 signal_wake_up(t, sig == SIGKILL);
826 static inline int legacy_queue(struct sigpending *signals, int sig)
828 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
831 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
832 int group, int from_ancestor_ns)
834 struct sigpending *pending;
838 trace_signal_generate(sig, info, t);
840 assert_spin_locked(&t->sighand->siglock);
842 if (!prepare_signal(sig, t, from_ancestor_ns))
845 pending = group ? &t->signal->shared_pending : &t->pending;
847 * Short-circuit ignored signals and support queuing
848 * exactly one non-rt signal, so that we can get more
849 * detailed information about the cause of the signal.
851 if (legacy_queue(pending, sig))
854 * fast-pathed signals for kernel-internal things like SIGSTOP
857 if (info == SEND_SIG_FORCED)
860 /* Real-time signals must be queued if sent by sigqueue, or
861 some other real-time mechanism. It is implementation
862 defined whether kill() does so. We attempt to do so, on
863 the principle of least surprise, but since kill is not
864 allowed to fail with EAGAIN when low on memory we just
865 make sure at least one signal gets delivered and don't
866 pass on the info struct. */
869 override_rlimit = (is_si_special(info) || info->si_code >= 0);
873 q = __sigqueue_alloc(t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
876 list_add_tail(&q->list, &pending->list);
877 switch ((unsigned long) info) {
878 case (unsigned long) SEND_SIG_NOINFO:
879 q->info.si_signo = sig;
880 q->info.si_errno = 0;
881 q->info.si_code = SI_USER;
882 q->info.si_pid = task_tgid_nr_ns(current,
883 task_active_pid_ns(t));
884 q->info.si_uid = current_uid();
886 case (unsigned long) SEND_SIG_PRIV:
887 q->info.si_signo = sig;
888 q->info.si_errno = 0;
889 q->info.si_code = SI_KERNEL;
894 copy_siginfo(&q->info, info);
895 if (from_ancestor_ns)
899 } else if (!is_si_special(info)) {
900 if (sig >= SIGRTMIN && info->si_code != SI_USER)
902 * Queue overflow, abort. We may abort if the signal was rt
903 * and sent by user using something other than kill().
909 signalfd_notify(t, sig);
910 sigaddset(&pending->signal, sig);
911 complete_signal(sig, t, group);
915 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
918 int from_ancestor_ns = 0;
921 if (!is_si_special(info) && SI_FROMUSER(info) &&
922 task_pid_nr_ns(current, task_active_pid_ns(t)) <= 0)
923 from_ancestor_ns = 1;
926 return __send_signal(sig, info, t, group, from_ancestor_ns);
929 int print_fatal_signals;
931 static void print_fatal_signal(struct pt_regs *regs, int signr)
933 printk("%s/%d: potentially unexpected fatal signal %d.\n",
934 current->comm, task_pid_nr(current), signr);
936 #if defined(__i386__) && !defined(__arch_um__)
937 printk("code at %08lx: ", regs->ip);
940 for (i = 0; i < 16; i++) {
943 __get_user(insn, (unsigned char *)(regs->ip + i));
944 printk("%02x ", insn);
954 static int __init setup_print_fatal_signals(char *str)
956 get_option (&str, &print_fatal_signals);
961 __setup("print-fatal-signals=", setup_print_fatal_signals);
964 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
966 return send_signal(sig, info, p, 1);
970 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
972 return send_signal(sig, info, t, 0);
975 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
981 if (lock_task_sighand(p, &flags)) {
982 ret = send_signal(sig, info, p, group);
983 unlock_task_sighand(p, &flags);
990 * Force a signal that the process can't ignore: if necessary
991 * we unblock the signal and change any SIG_IGN to SIG_DFL.
993 * Note: If we unblock the signal, we always reset it to SIG_DFL,
994 * since we do not want to have a signal handler that was blocked
995 * be invoked when user space had explicitly blocked it.
997 * We don't want to have recursive SIGSEGV's etc, for example,
998 * that is why we also clear SIGNAL_UNKILLABLE.
1001 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1003 unsigned long int flags;
1004 int ret, blocked, ignored;
1005 struct k_sigaction *action;
1007 spin_lock_irqsave(&t->sighand->siglock, flags);
1008 action = &t->sighand->action[sig-1];
1009 ignored = action->sa.sa_handler == SIG_IGN;
1010 blocked = sigismember(&t->blocked, sig);
1011 if (blocked || ignored) {
1012 action->sa.sa_handler = SIG_DFL;
1014 sigdelset(&t->blocked, sig);
1015 recalc_sigpending_and_wake(t);
1018 if (action->sa.sa_handler == SIG_DFL)
1019 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1020 ret = specific_send_sig_info(sig, info, t);
1021 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1027 force_sig_specific(int sig, struct task_struct *t)
1029 force_sig_info(sig, SEND_SIG_FORCED, t);
1033 * Nuke all other threads in the group.
1035 void zap_other_threads(struct task_struct *p)
1037 struct task_struct *t;
1039 p->signal->group_stop_count = 0;
1041 for (t = next_thread(p); t != p; t = next_thread(t)) {
1043 * Don't bother with already dead threads
1048 /* SIGKILL will be handled before any pending SIGSTOP */
1049 sigaddset(&t->pending.signal, SIGKILL);
1050 signal_wake_up(t, 1);
1054 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1056 struct sighand_struct *sighand;
1060 sighand = rcu_dereference(tsk->sighand);
1061 if (unlikely(sighand == NULL))
1064 spin_lock_irqsave(&sighand->siglock, *flags);
1065 if (likely(sighand == tsk->sighand))
1067 spin_unlock_irqrestore(&sighand->siglock, *flags);
1075 * send signal info to all the members of a group
1076 * - the caller must hold the RCU read lock at least
1078 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1080 int ret = check_kill_permission(sig, info, p);
1083 ret = do_send_sig_info(sig, info, p, true);
1089 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1090 * control characters do (^C, ^Z etc)
1091 * - the caller must hold at least a readlock on tasklist_lock
1093 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1095 struct task_struct *p = NULL;
1096 int retval, success;
1100 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1101 int err = group_send_sig_info(sig, info, p);
1104 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1105 return success ? 0 : retval;
1108 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1111 struct task_struct *p;
1115 p = pid_task(pid, PIDTYPE_PID);
1117 error = group_send_sig_info(sig, info, p);
1118 if (unlikely(error == -ESRCH))
1120 * The task was unhashed in between, try again.
1121 * If it is dead, pid_task() will return NULL,
1122 * if we race with de_thread() it will find the
1133 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1137 error = kill_pid_info(sig, info, find_vpid(pid));
1142 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1143 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1144 uid_t uid, uid_t euid, u32 secid)
1147 struct task_struct *p;
1148 const struct cred *pcred;
1150 if (!valid_signal(sig))
1153 read_lock(&tasklist_lock);
1154 p = pid_task(pid, PIDTYPE_PID);
1159 pcred = __task_cred(p);
1160 if ((info == SEND_SIG_NOINFO ||
1161 (!is_si_special(info) && SI_FROMUSER(info))) &&
1162 euid != pcred->suid && euid != pcred->uid &&
1163 uid != pcred->suid && uid != pcred->uid) {
1167 ret = security_task_kill(p, info, sig, secid);
1170 if (sig && p->sighand) {
1171 unsigned long flags;
1172 spin_lock_irqsave(&p->sighand->siglock, flags);
1173 ret = __send_signal(sig, info, p, 1, 0);
1174 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1177 read_unlock(&tasklist_lock);
1180 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1183 * kill_something_info() interprets pid in interesting ways just like kill(2).
1185 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1186 * is probably wrong. Should make it like BSD or SYSV.
1189 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1195 ret = kill_pid_info(sig, info, find_vpid(pid));
1200 read_lock(&tasklist_lock);
1202 ret = __kill_pgrp_info(sig, info,
1203 pid ? find_vpid(-pid) : task_pgrp(current));
1205 int retval = 0, count = 0;
1206 struct task_struct * p;
1208 for_each_process(p) {
1209 if (task_pid_vnr(p) > 1 &&
1210 !same_thread_group(p, current)) {
1211 int err = group_send_sig_info(sig, info, p);
1217 ret = count ? retval : -ESRCH;
1219 read_unlock(&tasklist_lock);
1225 * These are for backward compatibility with the rest of the kernel source.
1229 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1232 * Make sure legacy kernel users don't send in bad values
1233 * (normal paths check this in check_kill_permission).
1235 if (!valid_signal(sig))
1238 return do_send_sig_info(sig, info, p, false);
1241 #define __si_special(priv) \
1242 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1245 send_sig(int sig, struct task_struct *p, int priv)
1247 return send_sig_info(sig, __si_special(priv), p);
1251 force_sig(int sig, struct task_struct *p)
1253 force_sig_info(sig, SEND_SIG_PRIV, p);
1257 * When things go south during signal handling, we
1258 * will force a SIGSEGV. And if the signal that caused
1259 * the problem was already a SIGSEGV, we'll want to
1260 * make sure we don't even try to deliver the signal..
1263 force_sigsegv(int sig, struct task_struct *p)
1265 if (sig == SIGSEGV) {
1266 unsigned long flags;
1267 spin_lock_irqsave(&p->sighand->siglock, flags);
1268 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1269 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1271 force_sig(SIGSEGV, p);
1275 int kill_pgrp(struct pid *pid, int sig, int priv)
1279 read_lock(&tasklist_lock);
1280 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1281 read_unlock(&tasklist_lock);
1285 EXPORT_SYMBOL(kill_pgrp);
1287 int kill_pid(struct pid *pid, int sig, int priv)
1289 return kill_pid_info(sig, __si_special(priv), pid);
1291 EXPORT_SYMBOL(kill_pid);
1294 * These functions support sending signals using preallocated sigqueue
1295 * structures. This is needed "because realtime applications cannot
1296 * afford to lose notifications of asynchronous events, like timer
1297 * expirations or I/O completions". In the case of Posix Timers
1298 * we allocate the sigqueue structure from the timer_create. If this
1299 * allocation fails we are able to report the failure to the application
1300 * with an EAGAIN error.
1303 struct sigqueue *sigqueue_alloc(void)
1307 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1308 q->flags |= SIGQUEUE_PREALLOC;
1312 void sigqueue_free(struct sigqueue *q)
1314 unsigned long flags;
1315 spinlock_t *lock = ¤t->sighand->siglock;
1317 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1319 * We must hold ->siglock while testing q->list
1320 * to serialize with collect_signal() or with
1321 * __exit_signal()->flush_sigqueue().
1323 spin_lock_irqsave(lock, flags);
1324 q->flags &= ~SIGQUEUE_PREALLOC;
1326 * If it is queued it will be freed when dequeued,
1327 * like the "regular" sigqueue.
1329 if (!list_empty(&q->list))
1331 spin_unlock_irqrestore(lock, flags);
1337 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1339 int sig = q->info.si_signo;
1340 struct sigpending *pending;
1341 unsigned long flags;
1344 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1347 if (!likely(lock_task_sighand(t, &flags)))
1350 ret = 1; /* the signal is ignored */
1351 if (!prepare_signal(sig, t, 0))
1355 if (unlikely(!list_empty(&q->list))) {
1357 * If an SI_TIMER entry is already queue just increment
1358 * the overrun count.
1360 BUG_ON(q->info.si_code != SI_TIMER);
1361 q->info.si_overrun++;
1364 q->info.si_overrun = 0;
1366 signalfd_notify(t, sig);
1367 pending = group ? &t->signal->shared_pending : &t->pending;
1368 list_add_tail(&q->list, &pending->list);
1369 sigaddset(&pending->signal, sig);
1370 complete_signal(sig, t, group);
1372 unlock_task_sighand(t, &flags);
1378 * Let a parent know about the death of a child.
1379 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1381 * Returns -1 if our parent ignored us and so we've switched to
1382 * self-reaping, or else @sig.
1384 int do_notify_parent(struct task_struct *tsk, int sig)
1386 struct siginfo info;
1387 unsigned long flags;
1388 struct sighand_struct *psig;
1393 /* do_notify_parent_cldstop should have been called instead. */
1394 BUG_ON(task_is_stopped_or_traced(tsk));
1396 BUG_ON(!task_ptrace(tsk) &&
1397 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1399 info.si_signo = sig;
1402 * we are under tasklist_lock here so our parent is tied to
1403 * us and cannot exit and release its namespace.
1405 * the only it can is to switch its nsproxy with sys_unshare,
1406 * bu uncharing pid namespaces is not allowed, so we'll always
1407 * see relevant namespace
1409 * write_lock() currently calls preempt_disable() which is the
1410 * same as rcu_read_lock(), but according to Oleg, this is not
1411 * correct to rely on this
1414 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1415 info.si_uid = __task_cred(tsk)->uid;
1418 info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
1419 tsk->signal->utime));
1420 info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
1421 tsk->signal->stime));
1423 info.si_status = tsk->exit_code & 0x7f;
1424 if (tsk->exit_code & 0x80)
1425 info.si_code = CLD_DUMPED;
1426 else if (tsk->exit_code & 0x7f)
1427 info.si_code = CLD_KILLED;
1429 info.si_code = CLD_EXITED;
1430 info.si_status = tsk->exit_code >> 8;
1433 psig = tsk->parent->sighand;
1434 spin_lock_irqsave(&psig->siglock, flags);
1435 if (!task_ptrace(tsk) && sig == SIGCHLD &&
1436 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1437 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1439 * We are exiting and our parent doesn't care. POSIX.1
1440 * defines special semantics for setting SIGCHLD to SIG_IGN
1441 * or setting the SA_NOCLDWAIT flag: we should be reaped
1442 * automatically and not left for our parent's wait4 call.
1443 * Rather than having the parent do it as a magic kind of
1444 * signal handler, we just set this to tell do_exit that we
1445 * can be cleaned up without becoming a zombie. Note that
1446 * we still call __wake_up_parent in this case, because a
1447 * blocked sys_wait4 might now return -ECHILD.
1449 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1450 * is implementation-defined: we do (if you don't want
1451 * it, just use SIG_IGN instead).
1453 ret = tsk->exit_signal = -1;
1454 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1457 if (valid_signal(sig) && sig > 0)
1458 __group_send_sig_info(sig, &info, tsk->parent);
1459 __wake_up_parent(tsk, tsk->parent);
1460 spin_unlock_irqrestore(&psig->siglock, flags);
1465 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1467 struct siginfo info;
1468 unsigned long flags;
1469 struct task_struct *parent;
1470 struct sighand_struct *sighand;
1472 if (task_ptrace(tsk))
1473 parent = tsk->parent;
1475 tsk = tsk->group_leader;
1476 parent = tsk->real_parent;
1479 info.si_signo = SIGCHLD;
1482 * see comment in do_notify_parent() abot the following 3 lines
1485 info.si_pid = task_pid_nr_ns(tsk, parent->nsproxy->pid_ns);
1486 info.si_uid = __task_cred(tsk)->uid;
1489 info.si_utime = cputime_to_clock_t(tsk->utime);
1490 info.si_stime = cputime_to_clock_t(tsk->stime);
1495 info.si_status = SIGCONT;
1498 info.si_status = tsk->signal->group_exit_code & 0x7f;
1501 info.si_status = tsk->exit_code & 0x7f;
1507 sighand = parent->sighand;
1508 spin_lock_irqsave(&sighand->siglock, flags);
1509 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1510 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1511 __group_send_sig_info(SIGCHLD, &info, parent);
1513 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1515 __wake_up_parent(tsk, parent);
1516 spin_unlock_irqrestore(&sighand->siglock, flags);
1519 static inline int may_ptrace_stop(void)
1521 if (!likely(task_ptrace(current)))
1524 * Are we in the middle of do_coredump?
1525 * If so and our tracer is also part of the coredump stopping
1526 * is a deadlock situation, and pointless because our tracer
1527 * is dead so don't allow us to stop.
1528 * If SIGKILL was already sent before the caller unlocked
1529 * ->siglock we must see ->core_state != NULL. Otherwise it
1530 * is safe to enter schedule().
1532 if (unlikely(current->mm->core_state) &&
1533 unlikely(current->mm == current->parent->mm))
1540 * Return nonzero if there is a SIGKILL that should be waking us up.
1541 * Called with the siglock held.
1543 static int sigkill_pending(struct task_struct *tsk)
1545 return sigismember(&tsk->pending.signal, SIGKILL) ||
1546 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1550 * This must be called with current->sighand->siglock held.
1552 * This should be the path for all ptrace stops.
1553 * We always set current->last_siginfo while stopped here.
1554 * That makes it a way to test a stopped process for
1555 * being ptrace-stopped vs being job-control-stopped.
1557 * If we actually decide not to stop at all because the tracer
1558 * is gone, we keep current->exit_code unless clear_code.
1560 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1562 if (arch_ptrace_stop_needed(exit_code, info)) {
1564 * The arch code has something special to do before a
1565 * ptrace stop. This is allowed to block, e.g. for faults
1566 * on user stack pages. We can't keep the siglock while
1567 * calling arch_ptrace_stop, so we must release it now.
1568 * To preserve proper semantics, we must do this before
1569 * any signal bookkeeping like checking group_stop_count.
1570 * Meanwhile, a SIGKILL could come in before we retake the
1571 * siglock. That must prevent us from sleeping in TASK_TRACED.
1572 * So after regaining the lock, we must check for SIGKILL.
1574 spin_unlock_irq(¤t->sighand->siglock);
1575 arch_ptrace_stop(exit_code, info);
1576 spin_lock_irq(¤t->sighand->siglock);
1577 if (sigkill_pending(current))
1582 * If there is a group stop in progress,
1583 * we must participate in the bookkeeping.
1585 if (current->signal->group_stop_count > 0)
1586 --current->signal->group_stop_count;
1588 current->last_siginfo = info;
1589 current->exit_code = exit_code;
1591 /* Let the debugger run. */
1592 __set_current_state(TASK_TRACED);
1593 spin_unlock_irq(¤t->sighand->siglock);
1594 read_lock(&tasklist_lock);
1595 if (may_ptrace_stop()) {
1596 do_notify_parent_cldstop(current, CLD_TRAPPED);
1598 * Don't want to allow preemption here, because
1599 * sys_ptrace() needs this task to be inactive.
1601 * XXX: implement read_unlock_no_resched().
1604 read_unlock(&tasklist_lock);
1605 preempt_enable_no_resched();
1609 * By the time we got the lock, our tracer went away.
1610 * Don't drop the lock yet, another tracer may come.
1612 __set_current_state(TASK_RUNNING);
1614 current->exit_code = 0;
1615 read_unlock(&tasklist_lock);
1619 * While in TASK_TRACED, we were considered "frozen enough".
1620 * Now that we woke up, it's crucial if we're supposed to be
1621 * frozen that we freeze now before running anything substantial.
1626 * We are back. Now reacquire the siglock before touching
1627 * last_siginfo, so that we are sure to have synchronized with
1628 * any signal-sending on another CPU that wants to examine it.
1630 spin_lock_irq(¤t->sighand->siglock);
1631 current->last_siginfo = NULL;
1634 * Queued signals ignored us while we were stopped for tracing.
1635 * So check for any that we should take before resuming user mode.
1636 * This sets TIF_SIGPENDING, but never clears it.
1638 recalc_sigpending_tsk(current);
1641 void ptrace_notify(int exit_code)
1645 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1647 memset(&info, 0, sizeof info);
1648 info.si_signo = SIGTRAP;
1649 info.si_code = exit_code;
1650 info.si_pid = task_pid_vnr(current);
1651 info.si_uid = current_uid();
1653 /* Let the debugger run. */
1654 spin_lock_irq(¤t->sighand->siglock);
1655 ptrace_stop(exit_code, 1, &info);
1656 spin_unlock_irq(¤t->sighand->siglock);
1660 * This performs the stopping for SIGSTOP and other stop signals.
1661 * We have to stop all threads in the thread group.
1662 * Returns nonzero if we've actually stopped and released the siglock.
1663 * Returns zero if we didn't stop and still hold the siglock.
1665 static int do_signal_stop(int signr)
1667 struct signal_struct *sig = current->signal;
1670 if (!sig->group_stop_count) {
1671 struct task_struct *t;
1673 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1674 unlikely(signal_group_exit(sig)))
1677 * There is no group stop already in progress.
1678 * We must initiate one now.
1680 sig->group_exit_code = signr;
1682 sig->group_stop_count = 1;
1683 for (t = next_thread(current); t != current; t = next_thread(t))
1685 * Setting state to TASK_STOPPED for a group
1686 * stop is always done with the siglock held,
1687 * so this check has no races.
1689 if (!(t->flags & PF_EXITING) &&
1690 !task_is_stopped_or_traced(t)) {
1691 sig->group_stop_count++;
1692 signal_wake_up(t, 0);
1696 * If there are no other threads in the group, or if there is
1697 * a group stop in progress and we are the last to stop, report
1698 * to the parent. When ptraced, every thread reports itself.
1700 notify = sig->group_stop_count == 1 ? CLD_STOPPED : 0;
1701 notify = tracehook_notify_jctl(notify, CLD_STOPPED);
1703 * tracehook_notify_jctl() can drop and reacquire siglock, so
1704 * we keep ->group_stop_count != 0 before the call. If SIGCONT
1705 * or SIGKILL comes in between ->group_stop_count == 0.
1707 if (sig->group_stop_count) {
1708 if (!--sig->group_stop_count)
1709 sig->flags = SIGNAL_STOP_STOPPED;
1710 current->exit_code = sig->group_exit_code;
1711 __set_current_state(TASK_STOPPED);
1713 spin_unlock_irq(¤t->sighand->siglock);
1716 read_lock(&tasklist_lock);
1717 do_notify_parent_cldstop(current, notify);
1718 read_unlock(&tasklist_lock);
1721 /* Now we don't run again until woken by SIGCONT or SIGKILL */
1724 } while (try_to_freeze());
1726 tracehook_finish_jctl();
1727 current->exit_code = 0;
1732 static int ptrace_signal(int signr, siginfo_t *info,
1733 struct pt_regs *regs, void *cookie)
1735 if (!task_ptrace(current))
1738 ptrace_signal_deliver(regs, cookie);
1740 /* Let the debugger run. */
1741 ptrace_stop(signr, 0, info);
1743 /* We're back. Did the debugger cancel the sig? */
1744 signr = current->exit_code;
1748 current->exit_code = 0;
1750 /* Update the siginfo structure if the signal has
1751 changed. If the debugger wanted something
1752 specific in the siginfo structure then it should
1753 have updated *info via PTRACE_SETSIGINFO. */
1754 if (signr != info->si_signo) {
1755 info->si_signo = signr;
1757 info->si_code = SI_USER;
1758 info->si_pid = task_pid_vnr(current->parent);
1759 info->si_uid = task_uid(current->parent);
1762 /* If the (new) signal is now blocked, requeue it. */
1763 if (sigismember(¤t->blocked, signr)) {
1764 specific_send_sig_info(signr, info, current);
1771 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1772 struct pt_regs *regs, void *cookie)
1774 struct sighand_struct *sighand = current->sighand;
1775 struct signal_struct *signal = current->signal;
1780 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1781 * While in TASK_STOPPED, we were considered "frozen enough".
1782 * Now that we woke up, it's crucial if we're supposed to be
1783 * frozen that we freeze now before running anything substantial.
1787 spin_lock_irq(&sighand->siglock);
1789 * Every stopped thread goes here after wakeup. Check to see if
1790 * we should notify the parent, prepare_signal(SIGCONT) encodes
1791 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1793 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1794 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1795 ? CLD_CONTINUED : CLD_STOPPED;
1796 signal->flags &= ~SIGNAL_CLD_MASK;
1798 why = tracehook_notify_jctl(why, CLD_CONTINUED);
1799 spin_unlock_irq(&sighand->siglock);
1802 read_lock(&tasklist_lock);
1803 do_notify_parent_cldstop(current->group_leader, why);
1804 read_unlock(&tasklist_lock);
1810 struct k_sigaction *ka;
1812 if (unlikely(signal->group_stop_count > 0) &&
1817 * Tracing can induce an artifical signal and choose sigaction.
1818 * The return value in @signr determines the default action,
1819 * but @info->si_signo is the signal number we will report.
1821 signr = tracehook_get_signal(current, regs, info, return_ka);
1822 if (unlikely(signr < 0))
1824 if (unlikely(signr != 0))
1827 signr = dequeue_signal(current, ¤t->blocked,
1831 break; /* will return 0 */
1833 if (signr != SIGKILL) {
1834 signr = ptrace_signal(signr, info,
1840 ka = &sighand->action[signr-1];
1843 /* Trace actually delivered signals. */
1844 trace_signal_deliver(signr, info, ka);
1846 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1848 if (ka->sa.sa_handler != SIG_DFL) {
1849 /* Run the handler. */
1852 if (ka->sa.sa_flags & SA_ONESHOT)
1853 ka->sa.sa_handler = SIG_DFL;
1855 break; /* will return non-zero "signr" value */
1859 * Now we are doing the default action for this signal.
1861 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1865 * Global init gets no signals it doesn't want.
1866 * Container-init gets no signals it doesn't want from same
1869 * Note that if global/container-init sees a sig_kernel_only()
1870 * signal here, the signal must have been generated internally
1871 * or must have come from an ancestor namespace. In either
1872 * case, the signal cannot be dropped.
1874 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1875 !sig_kernel_only(signr))
1878 if (sig_kernel_stop(signr)) {
1880 * The default action is to stop all threads in
1881 * the thread group. The job control signals
1882 * do nothing in an orphaned pgrp, but SIGSTOP
1883 * always works. Note that siglock needs to be
1884 * dropped during the call to is_orphaned_pgrp()
1885 * because of lock ordering with tasklist_lock.
1886 * This allows an intervening SIGCONT to be posted.
1887 * We need to check for that and bail out if necessary.
1889 if (signr != SIGSTOP) {
1890 spin_unlock_irq(&sighand->siglock);
1892 /* signals can be posted during this window */
1894 if (is_current_pgrp_orphaned())
1897 spin_lock_irq(&sighand->siglock);
1900 if (likely(do_signal_stop(info->si_signo))) {
1901 /* It released the siglock. */
1906 * We didn't actually stop, due to a race
1907 * with SIGCONT or something like that.
1912 spin_unlock_irq(&sighand->siglock);
1915 * Anything else is fatal, maybe with a core dump.
1917 current->flags |= PF_SIGNALED;
1919 if (sig_kernel_coredump(signr)) {
1920 if (print_fatal_signals)
1921 print_fatal_signal(regs, info->si_signo);
1923 * If it was able to dump core, this kills all
1924 * other threads in the group and synchronizes with
1925 * their demise. If we lost the race with another
1926 * thread getting here, it set group_exit_code
1927 * first and our do_group_exit call below will use
1928 * that value and ignore the one we pass it.
1930 do_coredump(info->si_signo, info->si_signo, regs);
1934 * Death signals, no core dump.
1936 do_group_exit(info->si_signo);
1939 spin_unlock_irq(&sighand->siglock);
1943 void exit_signals(struct task_struct *tsk)
1946 struct task_struct *t;
1948 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1949 tsk->flags |= PF_EXITING;
1953 spin_lock_irq(&tsk->sighand->siglock);
1955 * From now this task is not visible for group-wide signals,
1956 * see wants_signal(), do_signal_stop().
1958 tsk->flags |= PF_EXITING;
1959 if (!signal_pending(tsk))
1962 /* It could be that __group_complete_signal() choose us to
1963 * notify about group-wide signal. Another thread should be
1964 * woken now to take the signal since we will not.
1966 for (t = tsk; (t = next_thread(t)) != tsk; )
1967 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1968 recalc_sigpending_and_wake(t);
1970 if (unlikely(tsk->signal->group_stop_count) &&
1971 !--tsk->signal->group_stop_count) {
1972 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1973 group_stop = tracehook_notify_jctl(CLD_STOPPED, CLD_STOPPED);
1976 spin_unlock_irq(&tsk->sighand->siglock);
1978 if (unlikely(group_stop)) {
1979 read_lock(&tasklist_lock);
1980 do_notify_parent_cldstop(tsk, group_stop);
1981 read_unlock(&tasklist_lock);
1985 EXPORT_SYMBOL(recalc_sigpending);
1986 EXPORT_SYMBOL_GPL(dequeue_signal);
1987 EXPORT_SYMBOL(flush_signals);
1988 EXPORT_SYMBOL(force_sig);
1989 EXPORT_SYMBOL(send_sig);
1990 EXPORT_SYMBOL(send_sig_info);
1991 EXPORT_SYMBOL(sigprocmask);
1992 EXPORT_SYMBOL(block_all_signals);
1993 EXPORT_SYMBOL(unblock_all_signals);
1997 * System call entry points.
2000 SYSCALL_DEFINE0(restart_syscall)
2002 struct restart_block *restart = ¤t_thread_info()->restart_block;
2003 return restart->fn(restart);
2006 long do_no_restart_syscall(struct restart_block *param)
2012 * We don't need to get the kernel lock - this is all local to this
2013 * particular thread.. (and that's good, because this is _heavily_
2014 * used by various programs)
2018 * This is also useful for kernel threads that want to temporarily
2019 * (or permanently) block certain signals.
2021 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2022 * interface happily blocks "unblockable" signals like SIGKILL
2025 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2029 spin_lock_irq(¤t->sighand->siglock);
2031 *oldset = current->blocked;
2036 sigorsets(¤t->blocked, ¤t->blocked, set);
2039 signandsets(¤t->blocked, ¤t->blocked, set);
2042 current->blocked = *set;
2047 recalc_sigpending();
2048 spin_unlock_irq(¤t->sighand->siglock);
2053 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
2054 sigset_t __user *, oset, size_t, sigsetsize)
2056 int error = -EINVAL;
2057 sigset_t old_set, new_set;
2059 /* XXX: Don't preclude handling different sized sigset_t's. */
2060 if (sigsetsize != sizeof(sigset_t))
2065 if (copy_from_user(&new_set, set, sizeof(*set)))
2067 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2069 error = sigprocmask(how, &new_set, &old_set);
2075 spin_lock_irq(¤t->sighand->siglock);
2076 old_set = current->blocked;
2077 spin_unlock_irq(¤t->sighand->siglock);
2081 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2089 long do_sigpending(void __user *set, unsigned long sigsetsize)
2091 long error = -EINVAL;
2094 if (sigsetsize > sizeof(sigset_t))
2097 spin_lock_irq(¤t->sighand->siglock);
2098 sigorsets(&pending, ¤t->pending.signal,
2099 ¤t->signal->shared_pending.signal);
2100 spin_unlock_irq(¤t->sighand->siglock);
2102 /* Outside the lock because only this thread touches it. */
2103 sigandsets(&pending, ¤t->blocked, &pending);
2106 if (!copy_to_user(set, &pending, sigsetsize))
2113 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
2115 return do_sigpending(set, sigsetsize);
2118 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2120 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2124 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2126 if (from->si_code < 0)
2127 return __copy_to_user(to, from, sizeof(siginfo_t))
2130 * If you change siginfo_t structure, please be sure
2131 * this code is fixed accordingly.
2132 * Please remember to update the signalfd_copyinfo() function
2133 * inside fs/signalfd.c too, in case siginfo_t changes.
2134 * It should never copy any pad contained in the structure
2135 * to avoid security leaks, but must copy the generic
2136 * 3 ints plus the relevant union member.
2138 err = __put_user(from->si_signo, &to->si_signo);
2139 err |= __put_user(from->si_errno, &to->si_errno);
2140 err |= __put_user((short)from->si_code, &to->si_code);
2141 switch (from->si_code & __SI_MASK) {
2143 err |= __put_user(from->si_pid, &to->si_pid);
2144 err |= __put_user(from->si_uid, &to->si_uid);
2147 err |= __put_user(from->si_tid, &to->si_tid);
2148 err |= __put_user(from->si_overrun, &to->si_overrun);
2149 err |= __put_user(from->si_ptr, &to->si_ptr);
2152 err |= __put_user(from->si_band, &to->si_band);
2153 err |= __put_user(from->si_fd, &to->si_fd);
2156 err |= __put_user(from->si_addr, &to->si_addr);
2157 #ifdef __ARCH_SI_TRAPNO
2158 err |= __put_user(from->si_trapno, &to->si_trapno);
2162 err |= __put_user(from->si_pid, &to->si_pid);
2163 err |= __put_user(from->si_uid, &to->si_uid);
2164 err |= __put_user(from->si_status, &to->si_status);
2165 err |= __put_user(from->si_utime, &to->si_utime);
2166 err |= __put_user(from->si_stime, &to->si_stime);
2168 case __SI_RT: /* This is not generated by the kernel as of now. */
2169 case __SI_MESGQ: /* But this is */
2170 err |= __put_user(from->si_pid, &to->si_pid);
2171 err |= __put_user(from->si_uid, &to->si_uid);
2172 err |= __put_user(from->si_ptr, &to->si_ptr);
2174 default: /* this is just in case for now ... */
2175 err |= __put_user(from->si_pid, &to->si_pid);
2176 err |= __put_user(from->si_uid, &to->si_uid);
2184 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2185 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2194 /* XXX: Don't preclude handling different sized sigset_t's. */
2195 if (sigsetsize != sizeof(sigset_t))
2198 if (copy_from_user(&these, uthese, sizeof(these)))
2202 * Invert the set of allowed signals to get those we
2205 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2209 if (copy_from_user(&ts, uts, sizeof(ts)))
2211 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2216 spin_lock_irq(¤t->sighand->siglock);
2217 sig = dequeue_signal(current, &these, &info);
2219 timeout = MAX_SCHEDULE_TIMEOUT;
2221 timeout = (timespec_to_jiffies(&ts)
2222 + (ts.tv_sec || ts.tv_nsec));
2225 /* None ready -- temporarily unblock those we're
2226 * interested while we are sleeping in so that we'll
2227 * be awakened when they arrive. */
2228 current->real_blocked = current->blocked;
2229 sigandsets(¤t->blocked, ¤t->blocked, &these);
2230 recalc_sigpending();
2231 spin_unlock_irq(¤t->sighand->siglock);
2233 timeout = schedule_timeout_interruptible(timeout);
2235 spin_lock_irq(¤t->sighand->siglock);
2236 sig = dequeue_signal(current, &these, &info);
2237 current->blocked = current->real_blocked;
2238 siginitset(¤t->real_blocked, 0);
2239 recalc_sigpending();
2242 spin_unlock_irq(¤t->sighand->siglock);
2247 if (copy_siginfo_to_user(uinfo, &info))
2259 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2261 struct siginfo info;
2263 info.si_signo = sig;
2265 info.si_code = SI_USER;
2266 info.si_pid = task_tgid_vnr(current);
2267 info.si_uid = current_uid();
2269 return kill_something_info(sig, &info, pid);
2273 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2275 struct task_struct *p;
2279 p = find_task_by_vpid(pid);
2280 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2281 error = check_kill_permission(sig, info, p);
2283 * The null signal is a permissions and process existence
2284 * probe. No signal is actually delivered.
2286 if (!error && sig) {
2287 error = do_send_sig_info(sig, info, p, false);
2289 * If lock_task_sighand() failed we pretend the task
2290 * dies after receiving the signal. The window is tiny,
2291 * and the signal is private anyway.
2293 if (unlikely(error == -ESRCH))
2302 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2304 struct siginfo info;
2306 info.si_signo = sig;
2308 info.si_code = SI_TKILL;
2309 info.si_pid = task_tgid_vnr(current);
2310 info.si_uid = current_uid();
2312 return do_send_specific(tgid, pid, sig, &info);
2316 * sys_tgkill - send signal to one specific thread
2317 * @tgid: the thread group ID of the thread
2318 * @pid: the PID of the thread
2319 * @sig: signal to be sent
2321 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2322 * exists but it's not belonging to the target process anymore. This
2323 * method solves the problem of threads exiting and PIDs getting reused.
2325 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2327 /* This is only valid for single tasks */
2328 if (pid <= 0 || tgid <= 0)
2331 return do_tkill(tgid, pid, sig);
2335 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2337 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2339 /* This is only valid for single tasks */
2343 return do_tkill(0, pid, sig);
2346 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2347 siginfo_t __user *, uinfo)
2351 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2354 /* Not even root can pretend to send signals from the kernel.
2355 Nor can they impersonate a kill(), which adds source info. */
2356 if (info.si_code >= 0)
2358 info.si_signo = sig;
2360 /* POSIX.1b doesn't mention process groups. */
2361 return kill_proc_info(sig, &info, pid);
2364 long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2366 /* This is only valid for single tasks */
2367 if (pid <= 0 || tgid <= 0)
2370 /* Not even root can pretend to send signals from the kernel.
2371 Nor can they impersonate a kill(), which adds source info. */
2372 if (info->si_code >= 0)
2374 info->si_signo = sig;
2376 return do_send_specific(tgid, pid, sig, info);
2379 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
2380 siginfo_t __user *, uinfo)
2384 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2387 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
2390 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2392 struct task_struct *t = current;
2393 struct k_sigaction *k;
2396 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2399 k = &t->sighand->action[sig-1];
2401 spin_lock_irq(¤t->sighand->siglock);
2406 sigdelsetmask(&act->sa.sa_mask,
2407 sigmask(SIGKILL) | sigmask(SIGSTOP));
2411 * "Setting a signal action to SIG_IGN for a signal that is
2412 * pending shall cause the pending signal to be discarded,
2413 * whether or not it is blocked."
2415 * "Setting a signal action to SIG_DFL for a signal that is
2416 * pending and whose default action is to ignore the signal
2417 * (for example, SIGCHLD), shall cause the pending signal to
2418 * be discarded, whether or not it is blocked"
2420 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2422 sigaddset(&mask, sig);
2423 rm_from_queue_full(&mask, &t->signal->shared_pending);
2425 rm_from_queue_full(&mask, &t->pending);
2427 } while (t != current);
2431 spin_unlock_irq(¤t->sighand->siglock);
2436 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2441 oss.ss_sp = (void __user *) current->sas_ss_sp;
2442 oss.ss_size = current->sas_ss_size;
2443 oss.ss_flags = sas_ss_flags(sp);
2451 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
2453 error = __get_user(ss_sp, &uss->ss_sp) |
2454 __get_user(ss_flags, &uss->ss_flags) |
2455 __get_user(ss_size, &uss->ss_size);
2460 if (on_sig_stack(sp))
2466 * Note - this code used to test ss_flags incorrectly
2467 * old code may have been written using ss_flags==0
2468 * to mean ss_flags==SS_ONSTACK (as this was the only
2469 * way that worked) - this fix preserves that older
2472 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2475 if (ss_flags == SS_DISABLE) {
2480 if (ss_size < MINSIGSTKSZ)
2484 current->sas_ss_sp = (unsigned long) ss_sp;
2485 current->sas_ss_size = ss_size;
2491 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
2493 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
2494 __put_user(oss.ss_size, &uoss->ss_size) |
2495 __put_user(oss.ss_flags, &uoss->ss_flags);
2502 #ifdef __ARCH_WANT_SYS_SIGPENDING
2504 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
2506 return do_sigpending(set, sizeof(*set));
2511 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2512 /* Some platforms have their own version with special arguments others
2513 support only sys_rt_sigprocmask. */
2515 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
2516 old_sigset_t __user *, oset)
2519 old_sigset_t old_set, new_set;
2523 if (copy_from_user(&new_set, set, sizeof(*set)))
2525 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2527 spin_lock_irq(¤t->sighand->siglock);
2528 old_set = current->blocked.sig[0];
2536 sigaddsetmask(¤t->blocked, new_set);
2539 sigdelsetmask(¤t->blocked, new_set);
2542 current->blocked.sig[0] = new_set;
2546 recalc_sigpending();
2547 spin_unlock_irq(¤t->sighand->siglock);
2553 old_set = current->blocked.sig[0];
2556 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2563 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2565 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2566 SYSCALL_DEFINE4(rt_sigaction, int, sig,
2567 const struct sigaction __user *, act,
2568 struct sigaction __user *, oact,
2571 struct k_sigaction new_sa, old_sa;
2574 /* XXX: Don't preclude handling different sized sigset_t's. */
2575 if (sigsetsize != sizeof(sigset_t))
2579 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2583 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2586 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2592 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2594 #ifdef __ARCH_WANT_SYS_SGETMASK
2597 * For backwards compatibility. Functionality superseded by sigprocmask.
2599 SYSCALL_DEFINE0(sgetmask)
2602 return current->blocked.sig[0];
2605 SYSCALL_DEFINE1(ssetmask, int, newmask)
2609 spin_lock_irq(¤t->sighand->siglock);
2610 old = current->blocked.sig[0];
2612 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2614 recalc_sigpending();
2615 spin_unlock_irq(¤t->sighand->siglock);
2619 #endif /* __ARCH_WANT_SGETMASK */
2621 #ifdef __ARCH_WANT_SYS_SIGNAL
2623 * For backwards compatibility. Functionality superseded by sigaction.
2625 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
2627 struct k_sigaction new_sa, old_sa;
2630 new_sa.sa.sa_handler = handler;
2631 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2632 sigemptyset(&new_sa.sa.sa_mask);
2634 ret = do_sigaction(sig, &new_sa, &old_sa);
2636 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2638 #endif /* __ARCH_WANT_SYS_SIGNAL */
2640 #ifdef __ARCH_WANT_SYS_PAUSE
2642 SYSCALL_DEFINE0(pause)
2644 current->state = TASK_INTERRUPTIBLE;
2646 return -ERESTARTNOHAND;
2651 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2652 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
2656 /* XXX: Don't preclude handling different sized sigset_t's. */
2657 if (sigsetsize != sizeof(sigset_t))
2660 if (copy_from_user(&newset, unewset, sizeof(newset)))
2662 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2664 spin_lock_irq(¤t->sighand->siglock);
2665 current->saved_sigmask = current->blocked;
2666 current->blocked = newset;
2667 recalc_sigpending();
2668 spin_unlock_irq(¤t->sighand->siglock);
2670 current->state = TASK_INTERRUPTIBLE;
2672 set_restore_sigmask();
2673 return -ERESTARTNOHAND;
2675 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2677 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2682 void __init signals_init(void)
2684 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);