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;
42 static int __sig_ignored(struct task_struct *t, int sig)
46 /* Is it explicitly or implicitly ignored? */
48 handler = t->sighand->action[sig - 1].sa.sa_handler;
49 return handler == SIG_IGN ||
50 (handler == SIG_DFL && sig_kernel_ignore(sig));
53 static int sig_ignored(struct task_struct *t, int sig)
56 * Tracers always want to know about signals..
58 if (t->ptrace & PT_PTRACED)
62 * Blocked signals are never ignored, since the
63 * signal handler may change by the time it is
66 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
69 return __sig_ignored(t, sig);
73 * Re-calculate pending state from the set of locally pending
74 * signals, globally pending signals, and blocked signals.
76 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
81 switch (_NSIG_WORDS) {
83 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
84 ready |= signal->sig[i] &~ blocked->sig[i];
87 case 4: ready = signal->sig[3] &~ blocked->sig[3];
88 ready |= signal->sig[2] &~ blocked->sig[2];
89 ready |= signal->sig[1] &~ blocked->sig[1];
90 ready |= signal->sig[0] &~ blocked->sig[0];
93 case 2: ready = signal->sig[1] &~ blocked->sig[1];
94 ready |= signal->sig[0] &~ blocked->sig[0];
97 case 1: ready = signal->sig[0] &~ blocked->sig[0];
102 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
104 static int recalc_sigpending_tsk(struct task_struct *t)
106 if (t->signal->group_stop_count > 0 ||
107 PENDING(&t->pending, &t->blocked) ||
108 PENDING(&t->signal->shared_pending, &t->blocked)) {
109 set_tsk_thread_flag(t, TIF_SIGPENDING);
113 * We must never clear the flag in another thread, or in current
114 * when it's possible the current syscall is returning -ERESTART*.
115 * So we don't clear it here, and only callers who know they should do.
121 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
122 * This is superfluous when called on current, the wakeup is a harmless no-op.
124 void recalc_sigpending_and_wake(struct task_struct *t)
126 if (recalc_sigpending_tsk(t))
127 signal_wake_up(t, 0);
130 void recalc_sigpending(void)
132 if (!recalc_sigpending_tsk(current) && !freezing(current))
133 clear_thread_flag(TIF_SIGPENDING);
137 /* Given the mask, find the first available signal that should be serviced. */
139 int next_signal(struct sigpending *pending, sigset_t *mask)
141 unsigned long i, *s, *m, x;
144 s = pending->signal.sig;
146 switch (_NSIG_WORDS) {
148 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
149 if ((x = *s &~ *m) != 0) {
150 sig = ffz(~x) + i*_NSIG_BPW + 1;
155 case 2: if ((x = s[0] &~ m[0]) != 0)
157 else if ((x = s[1] &~ m[1]) != 0)
164 case 1: if ((x = *s &~ *m) != 0)
172 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
175 struct sigqueue *q = NULL;
176 struct user_struct *user;
179 * In order to avoid problems with "switch_user()", we want to make
180 * sure that the compiler doesn't re-load "t->user"
184 atomic_inc(&user->sigpending);
185 if (override_rlimit ||
186 atomic_read(&user->sigpending) <=
187 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
188 q = kmem_cache_alloc(sigqueue_cachep, flags);
189 if (unlikely(q == NULL)) {
190 atomic_dec(&user->sigpending);
192 INIT_LIST_HEAD(&q->list);
194 q->user = get_uid(user);
199 static void __sigqueue_free(struct sigqueue *q)
201 if (q->flags & SIGQUEUE_PREALLOC)
203 atomic_dec(&q->user->sigpending);
205 kmem_cache_free(sigqueue_cachep, q);
208 void flush_sigqueue(struct sigpending *queue)
212 sigemptyset(&queue->signal);
213 while (!list_empty(&queue->list)) {
214 q = list_entry(queue->list.next, struct sigqueue , list);
215 list_del_init(&q->list);
221 * Flush all pending signals for a task.
223 void flush_signals(struct task_struct *t)
227 spin_lock_irqsave(&t->sighand->siglock, flags);
228 clear_tsk_thread_flag(t, TIF_SIGPENDING);
229 flush_sigqueue(&t->pending);
230 flush_sigqueue(&t->signal->shared_pending);
231 spin_unlock_irqrestore(&t->sighand->siglock, flags);
234 void ignore_signals(struct task_struct *t)
238 for (i = 0; i < _NSIG; ++i)
239 t->sighand->action[i].sa.sa_handler = SIG_IGN;
245 * Flush all handlers for a task.
249 flush_signal_handlers(struct task_struct *t, int force_default)
252 struct k_sigaction *ka = &t->sighand->action[0];
253 for (i = _NSIG ; i != 0 ; i--) {
254 if (force_default || ka->sa.sa_handler != SIG_IGN)
255 ka->sa.sa_handler = SIG_DFL;
257 sigemptyset(&ka->sa.sa_mask);
262 int unhandled_signal(struct task_struct *tsk, int sig)
264 if (is_global_init(tsk))
266 if (tsk->ptrace & PT_PTRACED)
268 return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
269 (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
273 /* Notify the system that a driver wants to block all signals for this
274 * process, and wants to be notified if any signals at all were to be
275 * sent/acted upon. If the notifier routine returns non-zero, then the
276 * signal will be acted upon after all. If the notifier routine returns 0,
277 * then then signal will be blocked. Only one block per process is
278 * allowed. priv is a pointer to private data that the notifier routine
279 * can use to determine if the signal should be blocked or not. */
282 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
286 spin_lock_irqsave(¤t->sighand->siglock, flags);
287 current->notifier_mask = mask;
288 current->notifier_data = priv;
289 current->notifier = notifier;
290 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
293 /* Notify the system that blocking has ended. */
296 unblock_all_signals(void)
300 spin_lock_irqsave(¤t->sighand->siglock, flags);
301 current->notifier = NULL;
302 current->notifier_data = NULL;
304 spin_unlock_irqrestore(¤t->sighand->siglock, flags);
307 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
309 struct sigqueue *q, *first = NULL;
310 int still_pending = 0;
312 if (unlikely(!sigismember(&list->signal, sig)))
316 * Collect the siginfo appropriate to this signal. Check if
317 * there is another siginfo for the same signal.
319 list_for_each_entry(q, &list->list, list) {
320 if (q->info.si_signo == sig) {
329 list_del_init(&first->list);
330 copy_siginfo(info, &first->info);
331 __sigqueue_free(first);
333 sigdelset(&list->signal, sig);
336 /* Ok, it wasn't in the queue. This must be
337 a fast-pathed signal or we must have been
338 out of queue space. So zero out the info.
340 sigdelset(&list->signal, sig);
341 info->si_signo = sig;
350 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
353 int sig = next_signal(pending, mask);
356 if (current->notifier) {
357 if (sigismember(current->notifier_mask, sig)) {
358 if (!(current->notifier)(current->notifier_data)) {
359 clear_thread_flag(TIF_SIGPENDING);
365 if (!collect_signal(sig, pending, info))
373 * Dequeue a signal and return the element to the caller, which is
374 * expected to free it.
376 * All callers have to hold the siglock.
378 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
382 /* We only dequeue private signals from ourselves, we don't let
383 * signalfd steal them
385 signr = __dequeue_signal(&tsk->pending, mask, info);
387 signr = __dequeue_signal(&tsk->signal->shared_pending,
392 * itimers are process shared and we restart periodic
393 * itimers in the signal delivery path to prevent DoS
394 * attacks in the high resolution timer case. This is
395 * compliant with the old way of self restarting
396 * itimers, as the SIGALRM is a legacy signal and only
397 * queued once. Changing the restart behaviour to
398 * restart the timer in the signal dequeue path is
399 * reducing the timer noise on heavy loaded !highres
402 if (unlikely(signr == SIGALRM)) {
403 struct hrtimer *tmr = &tsk->signal->real_timer;
405 if (!hrtimer_is_queued(tmr) &&
406 tsk->signal->it_real_incr.tv64 != 0) {
407 hrtimer_forward(tmr, tmr->base->get_time(),
408 tsk->signal->it_real_incr);
409 hrtimer_restart(tmr);
418 if (unlikely(sig_kernel_stop(signr))) {
420 * Set a marker that we have dequeued a stop signal. Our
421 * caller might release the siglock and then the pending
422 * stop signal it is about to process is no longer in the
423 * pending bitmasks, but must still be cleared by a SIGCONT
424 * (and overruled by a SIGKILL). So those cases clear this
425 * shared flag after we've set it. Note that this flag may
426 * remain set after the signal we return is ignored or
427 * handled. That doesn't matter because its only purpose
428 * is to alert stop-signal processing code when another
429 * processor has come along and cleared the flag.
431 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
432 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
434 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
436 * Release the siglock to ensure proper locking order
437 * of timer locks outside of siglocks. Note, we leave
438 * irqs disabled here, since the posix-timers code is
439 * about to disable them again anyway.
441 spin_unlock(&tsk->sighand->siglock);
442 do_schedule_next_timer(info);
443 spin_lock(&tsk->sighand->siglock);
449 * Tell a process that it has a new active signal..
451 * NOTE! we rely on the previous spin_lock to
452 * lock interrupts for us! We can only be called with
453 * "siglock" held, and the local interrupt must
454 * have been disabled when that got acquired!
456 * No need to set need_resched since signal event passing
457 * goes through ->blocked
459 void signal_wake_up(struct task_struct *t, int resume)
463 set_tsk_thread_flag(t, TIF_SIGPENDING);
466 * For SIGKILL, we want to wake it up in the stopped/traced/killable
467 * case. We don't check t->state here because there is a race with it
468 * executing another processor and just now entering stopped state.
469 * By using wake_up_state, we ensure the process will wake up and
470 * handle its death signal.
472 mask = TASK_INTERRUPTIBLE;
474 mask |= TASK_WAKEKILL;
475 if (!wake_up_state(t, mask))
480 * Remove signals in mask from the pending set and queue.
481 * Returns 1 if any signals were found.
483 * All callers must be holding the siglock.
485 * This version takes a sigset mask and looks at all signals,
486 * not just those in the first mask word.
488 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
490 struct sigqueue *q, *n;
493 sigandsets(&m, mask, &s->signal);
494 if (sigisemptyset(&m))
497 signandsets(&s->signal, &s->signal, mask);
498 list_for_each_entry_safe(q, n, &s->list, list) {
499 if (sigismember(mask, q->info.si_signo)) {
500 list_del_init(&q->list);
507 * Remove signals in mask from the pending set and queue.
508 * Returns 1 if any signals were found.
510 * All callers must be holding the siglock.
512 static int rm_from_queue(unsigned long mask, struct sigpending *s)
514 struct sigqueue *q, *n;
516 if (!sigtestsetmask(&s->signal, mask))
519 sigdelsetmask(&s->signal, mask);
520 list_for_each_entry_safe(q, n, &s->list, list) {
521 if (q->info.si_signo < SIGRTMIN &&
522 (mask & sigmask(q->info.si_signo))) {
523 list_del_init(&q->list);
531 * Bad permissions for sending the signal
533 static int check_kill_permission(int sig, struct siginfo *info,
534 struct task_struct *t)
538 if (!valid_signal(sig))
541 if (info != SEND_SIG_NOINFO && (is_si_special(info) || SI_FROMKERNEL(info)))
544 error = audit_signal_info(sig, t); /* Let audit system see the signal */
548 if (((sig != SIGCONT) || (task_session_nr(current) != task_session_nr(t)))
549 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
550 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
551 && !capable(CAP_KILL))
554 return security_task_kill(t, info, sig, 0);
558 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
561 * Handle magic process-wide effects of stop/continue signals.
562 * Unlike the signal actions, these happen immediately at signal-generation
563 * time regardless of blocking, ignoring, or handling. This does the
564 * actual continuing for SIGCONT, but not the actual stopping for stop
565 * signals. The process stop is done as a signal action for SIG_DFL.
567 static void handle_stop_signal(int sig, struct task_struct *p)
569 struct signal_struct *signal = p->signal;
570 struct task_struct *t;
572 if (signal->flags & SIGNAL_GROUP_EXIT)
574 * The process is in the middle of dying already.
578 if (sig_kernel_stop(sig)) {
580 * This is a stop signal. Remove SIGCONT from all queues.
582 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
585 rm_from_queue(sigmask(SIGCONT), &t->pending);
586 } while_each_thread(p, t);
587 } else if (sig == SIGCONT) {
590 * Remove all stop signals from all queues,
591 * and wake all threads.
593 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
597 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
599 * If there is a handler for SIGCONT, we must make
600 * sure that no thread returns to user mode before
601 * we post the signal, in case it was the only
602 * thread eligible to run the signal handler--then
603 * it must not do anything between resuming and
604 * running the handler. With the TIF_SIGPENDING
605 * flag set, the thread will pause and acquire the
606 * siglock that we hold now and until we've queued
607 * the pending signal.
609 * Wake up the stopped thread _after_ setting
612 state = __TASK_STOPPED;
613 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
614 set_tsk_thread_flag(t, TIF_SIGPENDING);
615 state |= TASK_INTERRUPTIBLE;
617 wake_up_state(t, state);
618 } while_each_thread(p, t);
621 * Notify the parent with CLD_CONTINUED if we were stopped.
623 * If we were in the middle of a group stop, we pretend it
624 * was already finished, and then continued. Since SIGCHLD
625 * doesn't queue we report only CLD_STOPPED, as if the next
626 * CLD_CONTINUED was dropped.
629 if (signal->flags & SIGNAL_STOP_STOPPED)
630 why |= SIGNAL_CLD_CONTINUED;
631 else if (signal->group_stop_count)
632 why |= SIGNAL_CLD_STOPPED;
635 signal->flags = why | SIGNAL_STOP_CONTINUED;
636 signal->group_stop_count = 0;
637 signal->group_exit_code = 0;
640 * We are not stopped, but there could be a stop
641 * signal in the middle of being processed after
642 * being removed from the queue. Clear that too.
644 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
646 } else if (sig == SIGKILL) {
648 * Make sure that any pending stop signal already dequeued
649 * is undone by the wakeup for SIGKILL.
651 signal->flags &= ~SIGNAL_STOP_DEQUEUED;
655 static inline int legacy_queue(struct sigpending *signals, int sig)
657 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
660 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
661 struct sigpending *signals)
663 struct sigqueue * q = NULL;
666 * Short-circuit ignored signals and support queuing
667 * exactly one non-rt signal, so that we can get more
668 * detailed information about the cause of the signal.
670 if (sig_ignored(t, sig) || legacy_queue(signals, sig))
674 * Deliver the signal to listening signalfds. This must be called
675 * with the sighand lock held.
677 signalfd_notify(t, sig);
680 * fast-pathed signals for kernel-internal things like SIGSTOP
683 if (info == SEND_SIG_FORCED)
686 /* Real-time signals must be queued if sent by sigqueue, or
687 some other real-time mechanism. It is implementation
688 defined whether kill() does so. We attempt to do so, on
689 the principle of least surprise, but since kill is not
690 allowed to fail with EAGAIN when low on memory we just
691 make sure at least one signal gets delivered and don't
692 pass on the info struct. */
694 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
695 (is_si_special(info) ||
696 info->si_code >= 0)));
698 list_add_tail(&q->list, &signals->list);
699 switch ((unsigned long) info) {
700 case (unsigned long) SEND_SIG_NOINFO:
701 q->info.si_signo = sig;
702 q->info.si_errno = 0;
703 q->info.si_code = SI_USER;
704 q->info.si_pid = task_pid_vnr(current);
705 q->info.si_uid = current->uid;
707 case (unsigned long) SEND_SIG_PRIV:
708 q->info.si_signo = sig;
709 q->info.si_errno = 0;
710 q->info.si_code = SI_KERNEL;
715 copy_siginfo(&q->info, info);
718 } else if (!is_si_special(info)) {
719 if (sig >= SIGRTMIN && info->si_code != SI_USER)
721 * Queue overflow, abort. We may abort if the signal was rt
722 * and sent by user using something other than kill().
728 sigaddset(&signals->signal, sig);
732 int print_fatal_signals;
734 static void print_fatal_signal(struct pt_regs *regs, int signr)
736 printk("%s/%d: potentially unexpected fatal signal %d.\n",
737 current->comm, task_pid_nr(current), signr);
739 #if defined(__i386__) && !defined(__arch_um__)
740 printk("code at %08lx: ", regs->ip);
743 for (i = 0; i < 16; i++) {
746 __get_user(insn, (unsigned char *)(regs->ip + i));
747 printk("%02x ", insn);
755 static int __init setup_print_fatal_signals(char *str)
757 get_option (&str, &print_fatal_signals);
762 __setup("print-fatal-signals=", setup_print_fatal_signals);
765 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
769 BUG_ON(!irqs_disabled());
770 assert_spin_locked(&t->sighand->siglock);
772 ret = send_signal(sig, info, t, &t->pending);
776 if (!sigismember(&t->blocked, sig))
777 signal_wake_up(t, sig == SIGKILL);
782 * Force a signal that the process can't ignore: if necessary
783 * we unblock the signal and change any SIG_IGN to SIG_DFL.
785 * Note: If we unblock the signal, we always reset it to SIG_DFL,
786 * since we do not want to have a signal handler that was blocked
787 * be invoked when user space had explicitly blocked it.
789 * We don't want to have recursive SIGSEGV's etc, for example.
792 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
794 unsigned long int flags;
795 int ret, blocked, ignored;
796 struct k_sigaction *action;
798 spin_lock_irqsave(&t->sighand->siglock, flags);
799 action = &t->sighand->action[sig-1];
800 ignored = action->sa.sa_handler == SIG_IGN;
801 blocked = sigismember(&t->blocked, sig);
802 if (blocked || ignored) {
803 action->sa.sa_handler = SIG_DFL;
805 sigdelset(&t->blocked, sig);
806 recalc_sigpending_and_wake(t);
809 ret = specific_send_sig_info(sig, info, t);
810 spin_unlock_irqrestore(&t->sighand->siglock, flags);
816 force_sig_specific(int sig, struct task_struct *t)
818 force_sig_info(sig, SEND_SIG_FORCED, t);
822 * Test if P wants to take SIG. After we've checked all threads with this,
823 * it's equivalent to finding no threads not blocking SIG. Any threads not
824 * blocking SIG were ruled out because they are not running and already
825 * have pending signals. Such threads will dequeue from the shared queue
826 * as soon as they're available, so putting the signal on the shared queue
827 * will be equivalent to sending it to one such thread.
829 static inline int wants_signal(int sig, struct task_struct *p)
831 if (sigismember(&p->blocked, sig))
833 if (p->flags & PF_EXITING)
837 if (task_is_stopped_or_traced(p))
839 return task_curr(p) || !signal_pending(p);
843 __group_complete_signal(int sig, struct task_struct *p)
845 struct task_struct *t;
848 * Now find a thread we can wake up to take the signal off the queue.
850 * If the main thread wants the signal, it gets first crack.
851 * Probably the least surprising to the average bear.
853 if (wants_signal(sig, p))
855 else if (thread_group_empty(p))
857 * There is just one thread and it does not need to be woken.
858 * It will dequeue unblocked signals before it runs again.
863 * Otherwise try to find a suitable thread.
865 t = p->signal->curr_target;
867 /* restart balancing at this thread */
868 t = p->signal->curr_target = p;
870 while (!wants_signal(sig, t)) {
872 if (t == p->signal->curr_target)
874 * No thread needs to be woken.
875 * Any eligible threads will see
876 * the signal in the queue soon.
880 p->signal->curr_target = t;
884 * Found a killable thread. If the signal will be fatal,
885 * then start taking the whole group down immediately.
887 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
888 !sigismember(&t->real_blocked, sig) &&
889 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
891 * This signal will be fatal to the whole group.
893 if (!sig_kernel_coredump(sig)) {
895 * Start a group exit and wake everybody up.
896 * This way we don't have other threads
897 * running and doing things after a slower
898 * thread has the fatal signal pending.
900 p->signal->flags = SIGNAL_GROUP_EXIT;
901 p->signal->group_exit_code = sig;
902 p->signal->group_stop_count = 0;
905 sigaddset(&t->pending.signal, SIGKILL);
906 signal_wake_up(t, 1);
907 } while_each_thread(p, t);
913 * The signal is already in the shared-pending queue.
914 * Tell the chosen thread to wake up and dequeue it.
916 signal_wake_up(t, sig == SIGKILL);
921 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
925 assert_spin_locked(&p->sighand->siglock);
926 handle_stop_signal(sig, p);
929 * Put this signal on the shared-pending queue, or fail with EAGAIN.
930 * We always use the shared queue for process-wide signals,
931 * to avoid several races.
933 ret = send_signal(sig, info, p, &p->signal->shared_pending);
937 __group_complete_signal(sig, p);
942 * Nuke all other threads in the group.
944 void zap_other_threads(struct task_struct *p)
946 struct task_struct *t;
948 p->signal->group_stop_count = 0;
950 for (t = next_thread(p); t != p; t = next_thread(t)) {
952 * Don't bother with already dead threads
957 /* SIGKILL will be handled before any pending SIGSTOP */
958 sigaddset(&t->pending.signal, SIGKILL);
959 signal_wake_up(t, 1);
963 int __fatal_signal_pending(struct task_struct *tsk)
965 return sigismember(&tsk->pending.signal, SIGKILL);
967 EXPORT_SYMBOL(__fatal_signal_pending);
969 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
971 struct sighand_struct *sighand;
975 sighand = rcu_dereference(tsk->sighand);
976 if (unlikely(sighand == NULL))
979 spin_lock_irqsave(&sighand->siglock, *flags);
980 if (likely(sighand == tsk->sighand))
982 spin_unlock_irqrestore(&sighand->siglock, *flags);
989 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
994 ret = check_kill_permission(sig, info, p);
998 if (lock_task_sighand(p, &flags)) {
999 ret = __group_send_sig_info(sig, info, p);
1000 unlock_task_sighand(p, &flags);
1008 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1009 * control characters do (^C, ^Z etc)
1012 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1014 struct task_struct *p = NULL;
1015 int retval, success;
1019 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1020 int err = group_send_sig_info(sig, info, p);
1023 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1024 return success ? 0 : retval;
1027 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1030 struct task_struct *p;
1034 p = pid_task(pid, PIDTYPE_PID);
1036 error = group_send_sig_info(sig, info, p);
1037 if (unlikely(error == -ESRCH))
1039 * The task was unhashed in between, try again.
1040 * If it is dead, pid_task() will return NULL,
1041 * if we race with de_thread() it will find the
1052 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1056 error = kill_pid_info(sig, info, find_vpid(pid));
1061 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1062 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1063 uid_t uid, uid_t euid, u32 secid)
1066 struct task_struct *p;
1068 if (!valid_signal(sig))
1071 read_lock(&tasklist_lock);
1072 p = pid_task(pid, PIDTYPE_PID);
1077 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1078 && (euid != p->suid) && (euid != p->uid)
1079 && (uid != p->suid) && (uid != p->uid)) {
1083 ret = security_task_kill(p, info, sig, secid);
1086 if (sig && p->sighand) {
1087 unsigned long flags;
1088 spin_lock_irqsave(&p->sighand->siglock, flags);
1089 ret = __group_send_sig_info(sig, info, p);
1090 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1093 read_unlock(&tasklist_lock);
1096 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1099 * kill_something_info() interprets pid in interesting ways just like kill(2).
1101 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1102 * is probably wrong. Should make it like BSD or SYSV.
1105 static int kill_something_info(int sig, struct siginfo *info, int pid)
1111 ret = kill_pid_info(sig, info, find_vpid(pid));
1116 read_lock(&tasklist_lock);
1118 ret = __kill_pgrp_info(sig, info,
1119 pid ? find_vpid(-pid) : task_pgrp(current));
1121 int retval = 0, count = 0;
1122 struct task_struct * p;
1124 for_each_process(p) {
1125 if (p->pid > 1 && !same_thread_group(p, current)) {
1126 int err = group_send_sig_info(sig, info, p);
1132 ret = count ? retval : -ESRCH;
1134 read_unlock(&tasklist_lock);
1140 * These are for backward compatibility with the rest of the kernel source.
1144 * These two are the most common entry points. They send a signal
1145 * just to the specific thread.
1148 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1151 unsigned long flags;
1154 * Make sure legacy kernel users don't send in bad values
1155 * (normal paths check this in check_kill_permission).
1157 if (!valid_signal(sig))
1161 * We need the tasklist lock even for the specific
1162 * thread case (when we don't need to follow the group
1163 * lists) in order to avoid races with "p->sighand"
1164 * going away or changing from under us.
1166 read_lock(&tasklist_lock);
1167 spin_lock_irqsave(&p->sighand->siglock, flags);
1168 ret = specific_send_sig_info(sig, info, p);
1169 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1170 read_unlock(&tasklist_lock);
1174 #define __si_special(priv) \
1175 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1178 send_sig(int sig, struct task_struct *p, int priv)
1180 return send_sig_info(sig, __si_special(priv), p);
1184 force_sig(int sig, struct task_struct *p)
1186 force_sig_info(sig, SEND_SIG_PRIV, p);
1190 * When things go south during signal handling, we
1191 * will force a SIGSEGV. And if the signal that caused
1192 * the problem was already a SIGSEGV, we'll want to
1193 * make sure we don't even try to deliver the signal..
1196 force_sigsegv(int sig, struct task_struct *p)
1198 if (sig == SIGSEGV) {
1199 unsigned long flags;
1200 spin_lock_irqsave(&p->sighand->siglock, flags);
1201 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1202 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1204 force_sig(SIGSEGV, p);
1208 int kill_pgrp(struct pid *pid, int sig, int priv)
1212 read_lock(&tasklist_lock);
1213 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1214 read_unlock(&tasklist_lock);
1218 EXPORT_SYMBOL(kill_pgrp);
1220 int kill_pid(struct pid *pid, int sig, int priv)
1222 return kill_pid_info(sig, __si_special(priv), pid);
1224 EXPORT_SYMBOL(kill_pid);
1227 kill_proc(pid_t pid, int sig, int priv)
1232 ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
1238 * These functions support sending signals using preallocated sigqueue
1239 * structures. This is needed "because realtime applications cannot
1240 * afford to lose notifications of asynchronous events, like timer
1241 * expirations or I/O completions". In the case of Posix Timers
1242 * we allocate the sigqueue structure from the timer_create. If this
1243 * allocation fails we are able to report the failure to the application
1244 * with an EAGAIN error.
1247 struct sigqueue *sigqueue_alloc(void)
1251 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1252 q->flags |= SIGQUEUE_PREALLOC;
1256 void sigqueue_free(struct sigqueue *q)
1258 unsigned long flags;
1259 spinlock_t *lock = ¤t->sighand->siglock;
1261 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1263 * If the signal is still pending remove it from the
1264 * pending queue. We must hold ->siglock while testing
1265 * q->list to serialize with collect_signal().
1267 spin_lock_irqsave(lock, flags);
1268 if (!list_empty(&q->list))
1269 list_del_init(&q->list);
1270 spin_unlock_irqrestore(lock, flags);
1272 q->flags &= ~SIGQUEUE_PREALLOC;
1276 static int do_send_sigqueue(int sig, struct sigqueue *q, struct task_struct *t,
1277 struct sigpending *pending)
1279 if (unlikely(!list_empty(&q->list))) {
1281 * If an SI_TIMER entry is already queue just increment
1282 * the overrun count.
1285 BUG_ON(q->info.si_code != SI_TIMER);
1286 q->info.si_overrun++;
1290 if (sig_ignored(t, sig))
1293 signalfd_notify(t, sig);
1294 list_add_tail(&q->list, &pending->list);
1295 sigaddset(&pending->signal, sig);
1299 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1301 unsigned long flags;
1304 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1307 * The rcu based delayed sighand destroy makes it possible to
1308 * run this without tasklist lock held. The task struct itself
1309 * cannot go away as create_timer did get_task_struct().
1311 * We return -1, when the task is marked exiting, so
1312 * posix_timer_event can redirect it to the group leader
1314 if (!likely(lock_task_sighand(p, &flags)))
1317 ret = do_send_sigqueue(sig, q, p, &p->pending);
1319 if (!sigismember(&p->blocked, sig))
1320 signal_wake_up(p, sig == SIGKILL);
1322 unlock_task_sighand(p, &flags);
1328 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1330 unsigned long flags;
1333 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1335 read_lock(&tasklist_lock);
1336 /* Since it_lock is held, p->sighand cannot be NULL. */
1337 spin_lock_irqsave(&p->sighand->siglock, flags);
1338 handle_stop_signal(sig, p);
1340 ret = do_send_sigqueue(sig, q, p, &p->signal->shared_pending);
1342 __group_complete_signal(sig, p);
1344 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1345 read_unlock(&tasklist_lock);
1350 * Wake up any threads in the parent blocked in wait* syscalls.
1352 static inline void __wake_up_parent(struct task_struct *p,
1353 struct task_struct *parent)
1355 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1359 * Let a parent know about the death of a child.
1360 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1363 void do_notify_parent(struct task_struct *tsk, int sig)
1365 struct siginfo info;
1366 unsigned long flags;
1367 struct sighand_struct *psig;
1371 /* do_notify_parent_cldstop should have been called instead. */
1372 BUG_ON(task_is_stopped_or_traced(tsk));
1374 BUG_ON(!tsk->ptrace &&
1375 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1377 info.si_signo = sig;
1380 * we are under tasklist_lock here so our parent is tied to
1381 * us and cannot exit and release its namespace.
1383 * the only it can is to switch its nsproxy with sys_unshare,
1384 * bu uncharing pid namespaces is not allowed, so we'll always
1385 * see relevant namespace
1387 * write_lock() currently calls preempt_disable() which is the
1388 * same as rcu_read_lock(), but according to Oleg, this is not
1389 * correct to rely on this
1392 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1395 info.si_uid = tsk->uid;
1397 /* FIXME: find out whether or not this is supposed to be c*time. */
1398 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1399 tsk->signal->utime));
1400 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1401 tsk->signal->stime));
1403 info.si_status = tsk->exit_code & 0x7f;
1404 if (tsk->exit_code & 0x80)
1405 info.si_code = CLD_DUMPED;
1406 else if (tsk->exit_code & 0x7f)
1407 info.si_code = CLD_KILLED;
1409 info.si_code = CLD_EXITED;
1410 info.si_status = tsk->exit_code >> 8;
1413 psig = tsk->parent->sighand;
1414 spin_lock_irqsave(&psig->siglock, flags);
1415 if (!tsk->ptrace && sig == SIGCHLD &&
1416 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1417 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1419 * We are exiting and our parent doesn't care. POSIX.1
1420 * defines special semantics for setting SIGCHLD to SIG_IGN
1421 * or setting the SA_NOCLDWAIT flag: we should be reaped
1422 * automatically and not left for our parent's wait4 call.
1423 * Rather than having the parent do it as a magic kind of
1424 * signal handler, we just set this to tell do_exit that we
1425 * can be cleaned up without becoming a zombie. Note that
1426 * we still call __wake_up_parent in this case, because a
1427 * blocked sys_wait4 might now return -ECHILD.
1429 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1430 * is implementation-defined: we do (if you don't want
1431 * it, just use SIG_IGN instead).
1433 tsk->exit_signal = -1;
1434 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1437 if (valid_signal(sig) && sig > 0)
1438 __group_send_sig_info(sig, &info, tsk->parent);
1439 __wake_up_parent(tsk, tsk->parent);
1440 spin_unlock_irqrestore(&psig->siglock, flags);
1443 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1445 struct siginfo info;
1446 unsigned long flags;
1447 struct task_struct *parent;
1448 struct sighand_struct *sighand;
1450 if (tsk->ptrace & PT_PTRACED)
1451 parent = tsk->parent;
1453 tsk = tsk->group_leader;
1454 parent = tsk->real_parent;
1457 info.si_signo = SIGCHLD;
1460 * see comment in do_notify_parent() abot the following 3 lines
1463 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1466 info.si_uid = tsk->uid;
1468 /* FIXME: find out whether or not this is supposed to be c*time. */
1469 info.si_utime = cputime_to_jiffies(tsk->utime);
1470 info.si_stime = cputime_to_jiffies(tsk->stime);
1475 info.si_status = SIGCONT;
1478 info.si_status = tsk->signal->group_exit_code & 0x7f;
1481 info.si_status = tsk->exit_code & 0x7f;
1487 sighand = parent->sighand;
1488 spin_lock_irqsave(&sighand->siglock, flags);
1489 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1490 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1491 __group_send_sig_info(SIGCHLD, &info, parent);
1493 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1495 __wake_up_parent(tsk, parent);
1496 spin_unlock_irqrestore(&sighand->siglock, flags);
1499 static inline int may_ptrace_stop(void)
1501 if (!likely(current->ptrace & PT_PTRACED))
1504 * Are we in the middle of do_coredump?
1505 * If so and our tracer is also part of the coredump stopping
1506 * is a deadlock situation, and pointless because our tracer
1507 * is dead so don't allow us to stop.
1508 * If SIGKILL was already sent before the caller unlocked
1509 * ->siglock we must see ->core_waiters != 0. Otherwise it
1510 * is safe to enter schedule().
1512 if (unlikely(current->mm->core_waiters) &&
1513 unlikely(current->mm == current->parent->mm))
1520 * Return nonzero if there is a SIGKILL that should be waking us up.
1521 * Called with the siglock held.
1523 static int sigkill_pending(struct task_struct *tsk)
1525 return ((sigismember(&tsk->pending.signal, SIGKILL) ||
1526 sigismember(&tsk->signal->shared_pending.signal, SIGKILL)) &&
1527 !unlikely(sigismember(&tsk->blocked, SIGKILL)));
1531 * This must be called with current->sighand->siglock held.
1533 * This should be the path for all ptrace stops.
1534 * We always set current->last_siginfo while stopped here.
1535 * That makes it a way to test a stopped process for
1536 * being ptrace-stopped vs being job-control-stopped.
1538 * If we actually decide not to stop at all because the tracer
1539 * is gone, we keep current->exit_code unless clear_code.
1541 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1545 if (arch_ptrace_stop_needed(exit_code, info)) {
1547 * The arch code has something special to do before a
1548 * ptrace stop. This is allowed to block, e.g. for faults
1549 * on user stack pages. We can't keep the siglock while
1550 * calling arch_ptrace_stop, so we must release it now.
1551 * To preserve proper semantics, we must do this before
1552 * any signal bookkeeping like checking group_stop_count.
1553 * Meanwhile, a SIGKILL could come in before we retake the
1554 * siglock. That must prevent us from sleeping in TASK_TRACED.
1555 * So after regaining the lock, we must check for SIGKILL.
1557 spin_unlock_irq(¤t->sighand->siglock);
1558 arch_ptrace_stop(exit_code, info);
1559 spin_lock_irq(¤t->sighand->siglock);
1560 killed = sigkill_pending(current);
1564 * If there is a group stop in progress,
1565 * we must participate in the bookkeeping.
1567 if (current->signal->group_stop_count > 0)
1568 --current->signal->group_stop_count;
1570 current->last_siginfo = info;
1571 current->exit_code = exit_code;
1573 /* Let the debugger run. */
1574 __set_current_state(TASK_TRACED);
1575 spin_unlock_irq(¤t->sighand->siglock);
1576 read_lock(&tasklist_lock);
1577 if (!unlikely(killed) && may_ptrace_stop()) {
1578 do_notify_parent_cldstop(current, CLD_TRAPPED);
1579 read_unlock(&tasklist_lock);
1583 * By the time we got the lock, our tracer went away.
1584 * Don't drop the lock yet, another tracer may come.
1586 __set_current_state(TASK_RUNNING);
1588 current->exit_code = 0;
1589 read_unlock(&tasklist_lock);
1593 * While in TASK_TRACED, we were considered "frozen enough".
1594 * Now that we woke up, it's crucial if we're supposed to be
1595 * frozen that we freeze now before running anything substantial.
1600 * We are back. Now reacquire the siglock before touching
1601 * last_siginfo, so that we are sure to have synchronized with
1602 * any signal-sending on another CPU that wants to examine it.
1604 spin_lock_irq(¤t->sighand->siglock);
1605 current->last_siginfo = NULL;
1608 * Queued signals ignored us while we were stopped for tracing.
1609 * So check for any that we should take before resuming user mode.
1610 * This sets TIF_SIGPENDING, but never clears it.
1612 recalc_sigpending_tsk(current);
1615 void ptrace_notify(int exit_code)
1619 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1621 memset(&info, 0, sizeof info);
1622 info.si_signo = SIGTRAP;
1623 info.si_code = exit_code;
1624 info.si_pid = task_pid_vnr(current);
1625 info.si_uid = current->uid;
1627 /* Let the debugger run. */
1628 spin_lock_irq(¤t->sighand->siglock);
1629 ptrace_stop(exit_code, 1, &info);
1630 spin_unlock_irq(¤t->sighand->siglock);
1634 finish_stop(int stop_count)
1637 * If there are no other threads in the group, or if there is
1638 * a group stop in progress and we are the last to stop,
1639 * report to the parent. When ptraced, every thread reports itself.
1641 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1642 read_lock(&tasklist_lock);
1643 do_notify_parent_cldstop(current, CLD_STOPPED);
1644 read_unlock(&tasklist_lock);
1649 } while (try_to_freeze());
1651 * Now we don't run again until continued.
1653 current->exit_code = 0;
1657 * This performs the stopping for SIGSTOP and other stop signals.
1658 * We have to stop all threads in the thread group.
1659 * Returns nonzero if we've actually stopped and released the siglock.
1660 * Returns zero if we didn't stop and still hold the siglock.
1662 static int do_signal_stop(int signr)
1664 struct signal_struct *sig = current->signal;
1667 if (sig->group_stop_count > 0) {
1669 * There is a group stop in progress. We don't need to
1670 * start another one.
1672 stop_count = --sig->group_stop_count;
1674 struct task_struct *t;
1676 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1677 unlikely(signal_group_exit(sig)))
1680 * There is no group stop already in progress.
1681 * We must initiate one now.
1683 sig->group_exit_code = signr;
1686 for (t = next_thread(current); t != current; t = next_thread(t))
1688 * Setting state to TASK_STOPPED for a group
1689 * stop is always done with the siglock held,
1690 * so this check has no races.
1692 if (!(t->flags & PF_EXITING) &&
1693 !task_is_stopped_or_traced(t)) {
1695 signal_wake_up(t, 0);
1697 sig->group_stop_count = stop_count;
1700 if (stop_count == 0)
1701 sig->flags = SIGNAL_STOP_STOPPED;
1702 current->exit_code = sig->group_exit_code;
1703 __set_current_state(TASK_STOPPED);
1705 spin_unlock_irq(¤t->sighand->siglock);
1706 finish_stop(stop_count);
1710 static int ptrace_signal(int signr, siginfo_t *info,
1711 struct pt_regs *regs, void *cookie)
1713 if (!(current->ptrace & PT_PTRACED))
1716 ptrace_signal_deliver(regs, cookie);
1718 /* Let the debugger run. */
1719 ptrace_stop(signr, 0, info);
1721 /* We're back. Did the debugger cancel the sig? */
1722 signr = current->exit_code;
1726 current->exit_code = 0;
1728 /* Update the siginfo structure if the signal has
1729 changed. If the debugger wanted something
1730 specific in the siginfo structure then it should
1731 have updated *info via PTRACE_SETSIGINFO. */
1732 if (signr != info->si_signo) {
1733 info->si_signo = signr;
1735 info->si_code = SI_USER;
1736 info->si_pid = task_pid_vnr(current->parent);
1737 info->si_uid = current->parent->uid;
1740 /* If the (new) signal is now blocked, requeue it. */
1741 if (sigismember(¤t->blocked, signr)) {
1742 specific_send_sig_info(signr, info, current);
1749 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1750 struct pt_regs *regs, void *cookie)
1752 struct sighand_struct *sighand = current->sighand;
1753 struct signal_struct *signal = current->signal;
1758 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1759 * While in TASK_STOPPED, we were considered "frozen enough".
1760 * Now that we woke up, it's crucial if we're supposed to be
1761 * frozen that we freeze now before running anything substantial.
1765 spin_lock_irq(&sighand->siglock);
1767 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1768 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1769 ? CLD_CONTINUED : CLD_STOPPED;
1770 signal->flags &= ~SIGNAL_CLD_MASK;
1771 spin_unlock_irq(&sighand->siglock);
1773 read_lock(&tasklist_lock);
1774 do_notify_parent_cldstop(current->group_leader, why);
1775 read_unlock(&tasklist_lock);
1780 struct k_sigaction *ka;
1782 if (unlikely(signal->group_stop_count > 0) &&
1786 signr = dequeue_signal(current, ¤t->blocked, info);
1788 break; /* will return 0 */
1790 if (signr != SIGKILL) {
1791 signr = ptrace_signal(signr, info, regs, cookie);
1796 ka = &sighand->action[signr-1];
1797 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1799 if (ka->sa.sa_handler != SIG_DFL) {
1800 /* Run the handler. */
1803 if (ka->sa.sa_flags & SA_ONESHOT)
1804 ka->sa.sa_handler = SIG_DFL;
1806 break; /* will return non-zero "signr" value */
1810 * Now we are doing the default action for this signal.
1812 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1816 * Global init gets no signals it doesn't want.
1818 if (is_global_init(current))
1821 if (sig_kernel_stop(signr)) {
1823 * The default action is to stop all threads in
1824 * the thread group. The job control signals
1825 * do nothing in an orphaned pgrp, but SIGSTOP
1826 * always works. Note that siglock needs to be
1827 * dropped during the call to is_orphaned_pgrp()
1828 * because of lock ordering with tasklist_lock.
1829 * This allows an intervening SIGCONT to be posted.
1830 * We need to check for that and bail out if necessary.
1832 if (signr != SIGSTOP) {
1833 spin_unlock_irq(&sighand->siglock);
1835 /* signals can be posted during this window */
1837 if (is_current_pgrp_orphaned())
1840 spin_lock_irq(&sighand->siglock);
1843 if (likely(do_signal_stop(signr))) {
1844 /* It released the siglock. */
1849 * We didn't actually stop, due to a race
1850 * with SIGCONT or something like that.
1855 spin_unlock_irq(&sighand->siglock);
1858 * Anything else is fatal, maybe with a core dump.
1860 current->flags |= PF_SIGNALED;
1861 if ((signr != SIGKILL) && print_fatal_signals)
1862 print_fatal_signal(regs, signr);
1863 if (sig_kernel_coredump(signr)) {
1865 * If it was able to dump core, this kills all
1866 * other threads in the group and synchronizes with
1867 * their demise. If we lost the race with another
1868 * thread getting here, it set group_exit_code
1869 * first and our do_group_exit call below will use
1870 * that value and ignore the one we pass it.
1872 do_coredump((long)signr, signr, regs);
1876 * Death signals, no core dump.
1878 do_group_exit(signr);
1881 spin_unlock_irq(&sighand->siglock);
1885 void exit_signals(struct task_struct *tsk)
1888 struct task_struct *t;
1890 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1891 tsk->flags |= PF_EXITING;
1895 spin_lock_irq(&tsk->sighand->siglock);
1897 * From now this task is not visible for group-wide signals,
1898 * see wants_signal(), do_signal_stop().
1900 tsk->flags |= PF_EXITING;
1901 if (!signal_pending(tsk))
1904 /* It could be that __group_complete_signal() choose us to
1905 * notify about group-wide signal. Another thread should be
1906 * woken now to take the signal since we will not.
1908 for (t = tsk; (t = next_thread(t)) != tsk; )
1909 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1910 recalc_sigpending_and_wake(t);
1912 if (unlikely(tsk->signal->group_stop_count) &&
1913 !--tsk->signal->group_stop_count) {
1914 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1918 spin_unlock_irq(&tsk->sighand->siglock);
1920 if (unlikely(group_stop)) {
1921 read_lock(&tasklist_lock);
1922 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1923 read_unlock(&tasklist_lock);
1927 EXPORT_SYMBOL(recalc_sigpending);
1928 EXPORT_SYMBOL_GPL(dequeue_signal);
1929 EXPORT_SYMBOL(flush_signals);
1930 EXPORT_SYMBOL(force_sig);
1931 EXPORT_SYMBOL(kill_proc);
1932 EXPORT_SYMBOL(ptrace_notify);
1933 EXPORT_SYMBOL(send_sig);
1934 EXPORT_SYMBOL(send_sig_info);
1935 EXPORT_SYMBOL(sigprocmask);
1936 EXPORT_SYMBOL(block_all_signals);
1937 EXPORT_SYMBOL(unblock_all_signals);
1941 * System call entry points.
1944 asmlinkage long sys_restart_syscall(void)
1946 struct restart_block *restart = ¤t_thread_info()->restart_block;
1947 return restart->fn(restart);
1950 long do_no_restart_syscall(struct restart_block *param)
1956 * We don't need to get the kernel lock - this is all local to this
1957 * particular thread.. (and that's good, because this is _heavily_
1958 * used by various programs)
1962 * This is also useful for kernel threads that want to temporarily
1963 * (or permanently) block certain signals.
1965 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1966 * interface happily blocks "unblockable" signals like SIGKILL
1969 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1973 spin_lock_irq(¤t->sighand->siglock);
1975 *oldset = current->blocked;
1980 sigorsets(¤t->blocked, ¤t->blocked, set);
1983 signandsets(¤t->blocked, ¤t->blocked, set);
1986 current->blocked = *set;
1991 recalc_sigpending();
1992 spin_unlock_irq(¤t->sighand->siglock);
1998 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2000 int error = -EINVAL;
2001 sigset_t old_set, new_set;
2003 /* XXX: Don't preclude handling different sized sigset_t's. */
2004 if (sigsetsize != sizeof(sigset_t))
2009 if (copy_from_user(&new_set, set, sizeof(*set)))
2011 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2013 error = sigprocmask(how, &new_set, &old_set);
2019 spin_lock_irq(¤t->sighand->siglock);
2020 old_set = current->blocked;
2021 spin_unlock_irq(¤t->sighand->siglock);
2025 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2033 long do_sigpending(void __user *set, unsigned long sigsetsize)
2035 long error = -EINVAL;
2038 if (sigsetsize > sizeof(sigset_t))
2041 spin_lock_irq(¤t->sighand->siglock);
2042 sigorsets(&pending, ¤t->pending.signal,
2043 ¤t->signal->shared_pending.signal);
2044 spin_unlock_irq(¤t->sighand->siglock);
2046 /* Outside the lock because only this thread touches it. */
2047 sigandsets(&pending, ¤t->blocked, &pending);
2050 if (!copy_to_user(set, &pending, sigsetsize))
2058 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2060 return do_sigpending(set, sigsetsize);
2063 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2065 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2069 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2071 if (from->si_code < 0)
2072 return __copy_to_user(to, from, sizeof(siginfo_t))
2075 * If you change siginfo_t structure, please be sure
2076 * this code is fixed accordingly.
2077 * Please remember to update the signalfd_copyinfo() function
2078 * inside fs/signalfd.c too, in case siginfo_t changes.
2079 * It should never copy any pad contained in the structure
2080 * to avoid security leaks, but must copy the generic
2081 * 3 ints plus the relevant union member.
2083 err = __put_user(from->si_signo, &to->si_signo);
2084 err |= __put_user(from->si_errno, &to->si_errno);
2085 err |= __put_user((short)from->si_code, &to->si_code);
2086 switch (from->si_code & __SI_MASK) {
2088 err |= __put_user(from->si_pid, &to->si_pid);
2089 err |= __put_user(from->si_uid, &to->si_uid);
2092 err |= __put_user(from->si_tid, &to->si_tid);
2093 err |= __put_user(from->si_overrun, &to->si_overrun);
2094 err |= __put_user(from->si_ptr, &to->si_ptr);
2097 err |= __put_user(from->si_band, &to->si_band);
2098 err |= __put_user(from->si_fd, &to->si_fd);
2101 err |= __put_user(from->si_addr, &to->si_addr);
2102 #ifdef __ARCH_SI_TRAPNO
2103 err |= __put_user(from->si_trapno, &to->si_trapno);
2107 err |= __put_user(from->si_pid, &to->si_pid);
2108 err |= __put_user(from->si_uid, &to->si_uid);
2109 err |= __put_user(from->si_status, &to->si_status);
2110 err |= __put_user(from->si_utime, &to->si_utime);
2111 err |= __put_user(from->si_stime, &to->si_stime);
2113 case __SI_RT: /* This is not generated by the kernel as of now. */
2114 case __SI_MESGQ: /* But this is */
2115 err |= __put_user(from->si_pid, &to->si_pid);
2116 err |= __put_user(from->si_uid, &to->si_uid);
2117 err |= __put_user(from->si_ptr, &to->si_ptr);
2119 default: /* this is just in case for now ... */
2120 err |= __put_user(from->si_pid, &to->si_pid);
2121 err |= __put_user(from->si_uid, &to->si_uid);
2130 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2131 siginfo_t __user *uinfo,
2132 const struct timespec __user *uts,
2141 /* XXX: Don't preclude handling different sized sigset_t's. */
2142 if (sigsetsize != sizeof(sigset_t))
2145 if (copy_from_user(&these, uthese, sizeof(these)))
2149 * Invert the set of allowed signals to get those we
2152 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2156 if (copy_from_user(&ts, uts, sizeof(ts)))
2158 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2163 spin_lock_irq(¤t->sighand->siglock);
2164 sig = dequeue_signal(current, &these, &info);
2166 timeout = MAX_SCHEDULE_TIMEOUT;
2168 timeout = (timespec_to_jiffies(&ts)
2169 + (ts.tv_sec || ts.tv_nsec));
2172 /* None ready -- temporarily unblock those we're
2173 * interested while we are sleeping in so that we'll
2174 * be awakened when they arrive. */
2175 current->real_blocked = current->blocked;
2176 sigandsets(¤t->blocked, ¤t->blocked, &these);
2177 recalc_sigpending();
2178 spin_unlock_irq(¤t->sighand->siglock);
2180 timeout = schedule_timeout_interruptible(timeout);
2182 spin_lock_irq(¤t->sighand->siglock);
2183 sig = dequeue_signal(current, &these, &info);
2184 current->blocked = current->real_blocked;
2185 siginitset(¤t->real_blocked, 0);
2186 recalc_sigpending();
2189 spin_unlock_irq(¤t->sighand->siglock);
2194 if (copy_siginfo_to_user(uinfo, &info))
2207 sys_kill(int pid, int sig)
2209 struct siginfo info;
2211 info.si_signo = sig;
2213 info.si_code = SI_USER;
2214 info.si_pid = task_tgid_vnr(current);
2215 info.si_uid = current->uid;
2217 return kill_something_info(sig, &info, pid);
2220 static int do_tkill(int tgid, int pid, int sig)
2223 struct siginfo info;
2224 struct task_struct *p;
2227 info.si_signo = sig;
2229 info.si_code = SI_TKILL;
2230 info.si_pid = task_tgid_vnr(current);
2231 info.si_uid = current->uid;
2233 read_lock(&tasklist_lock);
2234 p = find_task_by_vpid(pid);
2235 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2236 error = check_kill_permission(sig, &info, p);
2238 * The null signal is a permissions and process existence
2239 * probe. No signal is actually delivered.
2241 if (!error && sig && p->sighand) {
2242 spin_lock_irq(&p->sighand->siglock);
2243 handle_stop_signal(sig, p);
2244 error = specific_send_sig_info(sig, &info, p);
2245 spin_unlock_irq(&p->sighand->siglock);
2248 read_unlock(&tasklist_lock);
2254 * sys_tgkill - send signal to one specific thread
2255 * @tgid: the thread group ID of the thread
2256 * @pid: the PID of the thread
2257 * @sig: signal to be sent
2259 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2260 * exists but it's not belonging to the target process anymore. This
2261 * method solves the problem of threads exiting and PIDs getting reused.
2263 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2265 /* This is only valid for single tasks */
2266 if (pid <= 0 || tgid <= 0)
2269 return do_tkill(tgid, pid, sig);
2273 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2276 sys_tkill(int pid, int sig)
2278 /* This is only valid for single tasks */
2282 return do_tkill(0, pid, sig);
2286 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2290 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2293 /* Not even root can pretend to send signals from the kernel.
2294 Nor can they impersonate a kill(), which adds source info. */
2295 if (info.si_code >= 0)
2297 info.si_signo = sig;
2299 /* POSIX.1b doesn't mention process groups. */
2300 return kill_proc_info(sig, &info, pid);
2303 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2305 struct task_struct *t = current;
2306 struct k_sigaction *k;
2309 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2312 k = &t->sighand->action[sig-1];
2314 spin_lock_irq(¤t->sighand->siglock);
2319 sigdelsetmask(&act->sa.sa_mask,
2320 sigmask(SIGKILL) | sigmask(SIGSTOP));
2324 * "Setting a signal action to SIG_IGN for a signal that is
2325 * pending shall cause the pending signal to be discarded,
2326 * whether or not it is blocked."
2328 * "Setting a signal action to SIG_DFL for a signal that is
2329 * pending and whose default action is to ignore the signal
2330 * (for example, SIGCHLD), shall cause the pending signal to
2331 * be discarded, whether or not it is blocked"
2333 if (__sig_ignored(t, sig)) {
2335 sigaddset(&mask, sig);
2336 rm_from_queue_full(&mask, &t->signal->shared_pending);
2338 rm_from_queue_full(&mask, &t->pending);
2340 } while (t != current);
2344 spin_unlock_irq(¤t->sighand->siglock);
2349 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2355 oss.ss_sp = (void __user *) current->sas_ss_sp;
2356 oss.ss_size = current->sas_ss_size;
2357 oss.ss_flags = sas_ss_flags(sp);
2366 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2367 || __get_user(ss_sp, &uss->ss_sp)
2368 || __get_user(ss_flags, &uss->ss_flags)
2369 || __get_user(ss_size, &uss->ss_size))
2373 if (on_sig_stack(sp))
2379 * Note - this code used to test ss_flags incorrectly
2380 * old code may have been written using ss_flags==0
2381 * to mean ss_flags==SS_ONSTACK (as this was the only
2382 * way that worked) - this fix preserves that older
2385 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2388 if (ss_flags == SS_DISABLE) {
2393 if (ss_size < MINSIGSTKSZ)
2397 current->sas_ss_sp = (unsigned long) ss_sp;
2398 current->sas_ss_size = ss_size;
2403 if (copy_to_user(uoss, &oss, sizeof(oss)))
2412 #ifdef __ARCH_WANT_SYS_SIGPENDING
2415 sys_sigpending(old_sigset_t __user *set)
2417 return do_sigpending(set, sizeof(*set));
2422 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2423 /* Some platforms have their own version with special arguments others
2424 support only sys_rt_sigprocmask. */
2427 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2430 old_sigset_t old_set, new_set;
2434 if (copy_from_user(&new_set, set, sizeof(*set)))
2436 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2438 spin_lock_irq(¤t->sighand->siglock);
2439 old_set = current->blocked.sig[0];
2447 sigaddsetmask(¤t->blocked, new_set);
2450 sigdelsetmask(¤t->blocked, new_set);
2453 current->blocked.sig[0] = new_set;
2457 recalc_sigpending();
2458 spin_unlock_irq(¤t->sighand->siglock);
2464 old_set = current->blocked.sig[0];
2467 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2474 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2476 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2478 sys_rt_sigaction(int sig,
2479 const struct sigaction __user *act,
2480 struct sigaction __user *oact,
2483 struct k_sigaction new_sa, old_sa;
2486 /* XXX: Don't preclude handling different sized sigset_t's. */
2487 if (sigsetsize != sizeof(sigset_t))
2491 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2495 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2498 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2504 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2506 #ifdef __ARCH_WANT_SYS_SGETMASK
2509 * For backwards compatibility. Functionality superseded by sigprocmask.
2515 return current->blocked.sig[0];
2519 sys_ssetmask(int newmask)
2523 spin_lock_irq(¤t->sighand->siglock);
2524 old = current->blocked.sig[0];
2526 siginitset(¤t->blocked, newmask & ~(sigmask(SIGKILL)|
2528 recalc_sigpending();
2529 spin_unlock_irq(¤t->sighand->siglock);
2533 #endif /* __ARCH_WANT_SGETMASK */
2535 #ifdef __ARCH_WANT_SYS_SIGNAL
2537 * For backwards compatibility. Functionality superseded by sigaction.
2539 asmlinkage unsigned long
2540 sys_signal(int sig, __sighandler_t handler)
2542 struct k_sigaction new_sa, old_sa;
2545 new_sa.sa.sa_handler = handler;
2546 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2547 sigemptyset(&new_sa.sa.sa_mask);
2549 ret = do_sigaction(sig, &new_sa, &old_sa);
2551 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2553 #endif /* __ARCH_WANT_SYS_SIGNAL */
2555 #ifdef __ARCH_WANT_SYS_PAUSE
2560 current->state = TASK_INTERRUPTIBLE;
2562 return -ERESTARTNOHAND;
2567 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2568 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2572 /* XXX: Don't preclude handling different sized sigset_t's. */
2573 if (sigsetsize != sizeof(sigset_t))
2576 if (copy_from_user(&newset, unewset, sizeof(newset)))
2578 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2580 spin_lock_irq(¤t->sighand->siglock);
2581 current->saved_sigmask = current->blocked;
2582 current->blocked = newset;
2583 recalc_sigpending();
2584 spin_unlock_irq(¤t->sighand->siglock);
2586 current->state = TASK_INTERRUPTIBLE;
2588 set_thread_flag(TIF_RESTORE_SIGMASK);
2589 return -ERESTARTNOHAND;
2591 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2593 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2598 void __init signals_init(void)
2600 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);