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/export.h>
15 #include <linux/init.h>
16 #include <linux/sched.h>
17 #include <linux/sched/rt.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/coredump.h>
22 #include <linux/security.h>
23 #include <linux/syscalls.h>
24 #include <linux/ptrace.h>
25 #include <linux/signal.h>
26 #include <linux/signalfd.h>
27 #include <linux/ratelimit.h>
28 #include <linux/tracehook.h>
29 #include <linux/capability.h>
30 #include <linux/freezer.h>
31 #include <linux/pid_namespace.h>
32 #include <linux/nsproxy.h>
33 #include <linux/user_namespace.h>
34 #include <linux/uprobes.h>
35 #include <linux/compat.h>
36 #include <linux/cn_proc.h>
37 #include <linux/compiler.h>
39 #define CREATE_TRACE_POINTS
40 #include <trace/events/signal.h>
42 #include <asm/param.h>
43 #include <asm/uaccess.h>
44 #include <asm/unistd.h>
45 #include <asm/siginfo.h>
46 #include <asm/cacheflush.h>
47 #include "audit.h" /* audit_signal_info() */
50 * SLAB caches for signal bits.
53 static struct kmem_cache *sigqueue_cachep;
55 int print_fatal_signals __read_mostly;
57 static void __user *sig_handler(struct task_struct *t, int sig)
59 return t->sighand->action[sig - 1].sa.sa_handler;
62 static int sig_handler_ignored(void __user *handler, int sig)
64 /* Is it explicitly or implicitly ignored? */
65 return handler == SIG_IGN ||
66 (handler == SIG_DFL && sig_kernel_ignore(sig));
69 static int sig_task_ignored(struct task_struct *t, int sig, bool force)
73 handler = sig_handler(t, sig);
75 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
76 handler == SIG_DFL && !force)
79 return sig_handler_ignored(handler, sig);
82 static int sig_ignored(struct task_struct *t, int sig, bool force)
85 * Blocked signals are never ignored, since the
86 * signal handler may change by the time it is
89 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
92 if (!sig_task_ignored(t, sig, force))
96 * Tracers may want to know about even ignored signals.
102 * Re-calculate pending state from the set of locally pending
103 * signals, globally pending signals, and blocked signals.
105 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
110 switch (_NSIG_WORDS) {
112 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
113 ready |= signal->sig[i] &~ blocked->sig[i];
116 case 4: ready = signal->sig[3] &~ blocked->sig[3];
117 ready |= signal->sig[2] &~ blocked->sig[2];
118 ready |= signal->sig[1] &~ blocked->sig[1];
119 ready |= signal->sig[0] &~ blocked->sig[0];
122 case 2: ready = signal->sig[1] &~ blocked->sig[1];
123 ready |= signal->sig[0] &~ blocked->sig[0];
126 case 1: ready = signal->sig[0] &~ blocked->sig[0];
131 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
133 static int recalc_sigpending_tsk(struct task_struct *t)
135 if ((t->jobctl & JOBCTL_PENDING_MASK) ||
136 PENDING(&t->pending, &t->blocked) ||
137 PENDING(&t->signal->shared_pending, &t->blocked)) {
138 set_tsk_thread_flag(t, TIF_SIGPENDING);
142 * We must never clear the flag in another thread, or in current
143 * when it's possible the current syscall is returning -ERESTART*.
144 * So we don't clear it here, and only callers who know they should do.
150 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
151 * This is superfluous when called on current, the wakeup is a harmless no-op.
153 void recalc_sigpending_and_wake(struct task_struct *t)
155 if (recalc_sigpending_tsk(t))
156 signal_wake_up(t, 0);
159 void recalc_sigpending(void)
161 if (!recalc_sigpending_tsk(current) && !freezing(current))
162 clear_thread_flag(TIF_SIGPENDING);
166 /* Given the mask, find the first available signal that should be serviced. */
168 #define SYNCHRONOUS_MASK \
169 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
170 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
172 int next_signal(struct sigpending *pending, sigset_t *mask)
174 unsigned long i, *s, *m, x;
177 s = pending->signal.sig;
181 * Handle the first word specially: it contains the
182 * synchronous signals that need to be dequeued first.
186 if (x & SYNCHRONOUS_MASK)
187 x &= SYNCHRONOUS_MASK;
192 switch (_NSIG_WORDS) {
194 for (i = 1; i < _NSIG_WORDS; ++i) {
198 sig = ffz(~x) + i*_NSIG_BPW + 1;
207 sig = ffz(~x) + _NSIG_BPW + 1;
218 static inline void print_dropped_signal(int sig)
220 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
222 if (!print_fatal_signals)
225 if (!__ratelimit(&ratelimit_state))
228 printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
229 current->comm, current->pid, sig);
233 * task_set_jobctl_pending - set jobctl pending bits
235 * @mask: pending bits to set
237 * Clear @mask from @task->jobctl. @mask must be subset of
238 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
239 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
240 * cleared. If @task is already being killed or exiting, this function
244 * Must be called with @task->sighand->siglock held.
247 * %true if @mask is set, %false if made noop because @task was dying.
249 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
251 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
252 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
253 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
255 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
258 if (mask & JOBCTL_STOP_SIGMASK)
259 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
261 task->jobctl |= mask;
266 * task_clear_jobctl_trapping - clear jobctl trapping bit
269 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
270 * Clear it and wake up the ptracer. Note that we don't need any further
271 * locking. @task->siglock guarantees that @task->parent points to the
275 * Must be called with @task->sighand->siglock held.
277 void task_clear_jobctl_trapping(struct task_struct *task)
279 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
280 task->jobctl &= ~JOBCTL_TRAPPING;
281 smp_mb(); /* advised by wake_up_bit() */
282 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
287 * task_clear_jobctl_pending - clear jobctl pending bits
289 * @mask: pending bits to clear
291 * Clear @mask from @task->jobctl. @mask must be subset of
292 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
293 * STOP bits are cleared together.
295 * If clearing of @mask leaves no stop or trap pending, this function calls
296 * task_clear_jobctl_trapping().
299 * Must be called with @task->sighand->siglock held.
301 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
303 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
305 if (mask & JOBCTL_STOP_PENDING)
306 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
308 task->jobctl &= ~mask;
310 if (!(task->jobctl & JOBCTL_PENDING_MASK))
311 task_clear_jobctl_trapping(task);
315 * task_participate_group_stop - participate in a group stop
316 * @task: task participating in a group stop
318 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
319 * Group stop states are cleared and the group stop count is consumed if
320 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
321 * stop, the appropriate %SIGNAL_* flags are set.
324 * Must be called with @task->sighand->siglock held.
327 * %true if group stop completion should be notified to the parent, %false
330 static bool task_participate_group_stop(struct task_struct *task)
332 struct signal_struct *sig = task->signal;
333 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
335 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
337 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
342 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
343 sig->group_stop_count--;
346 * Tell the caller to notify completion iff we are entering into a
347 * fresh group stop. Read comment in do_signal_stop() for details.
349 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
350 sig->flags = SIGNAL_STOP_STOPPED;
356 static inline struct sigqueue *get_task_cache(struct task_struct *t)
358 struct sigqueue *q = t->sigqueue_cache;
360 if (cmpxchg(&t->sigqueue_cache, q, NULL) != q)
365 static inline int put_task_cache(struct task_struct *t, struct sigqueue *q)
367 if (cmpxchg(&t->sigqueue_cache, NULL, q) == NULL)
373 * allocate a new signal queue record
374 * - this may be called without locks if and only if t == current, otherwise an
375 * appropriate lock must be held to stop the target task from exiting
377 static struct sigqueue *
378 __sigqueue_do_alloc(int sig, struct task_struct *t, gfp_t flags,
379 int override_rlimit, int fromslab)
381 struct sigqueue *q = NULL;
382 struct user_struct *user;
385 * Protect access to @t credentials. This can go away when all
386 * callers hold rcu read lock.
389 user = get_uid(__task_cred(t)->user);
390 atomic_inc(&user->sigpending);
393 if (override_rlimit ||
394 atomic_read(&user->sigpending) <=
395 task_rlimit(t, RLIMIT_SIGPENDING)) {
397 q = get_task_cache(t);
399 q = kmem_cache_alloc(sigqueue_cachep, flags);
401 print_dropped_signal(sig);
404 if (unlikely(q == NULL)) {
405 atomic_dec(&user->sigpending);
408 INIT_LIST_HEAD(&q->list);
416 static struct sigqueue *
417 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags,
420 return __sigqueue_do_alloc(sig, t, flags, override_rlimit, 0);
423 static void __sigqueue_free(struct sigqueue *q)
425 if (q->flags & SIGQUEUE_PREALLOC)
427 atomic_dec(&q->user->sigpending);
429 kmem_cache_free(sigqueue_cachep, q);
432 static void sigqueue_free_current(struct sigqueue *q)
434 struct user_struct *up;
436 if (q->flags & SIGQUEUE_PREALLOC)
440 if (rt_prio(current->normal_prio) && !put_task_cache(current, q)) {
441 atomic_dec(&up->sigpending);
447 void flush_sigqueue(struct sigpending *queue)
451 sigemptyset(&queue->signal);
452 while (!list_empty(&queue->list)) {
453 q = list_entry(queue->list.next, struct sigqueue , list);
454 list_del_init(&q->list);
460 * Called from __exit_signal. Flush tsk->pending and
461 * tsk->sigqueue_cache
463 void flush_task_sigqueue(struct task_struct *tsk)
467 flush_sigqueue(&tsk->pending);
469 q = get_task_cache(tsk);
471 kmem_cache_free(sigqueue_cachep, q);
475 * Flush all pending signals for this kthread.
477 void flush_signals(struct task_struct *t)
481 spin_lock_irqsave(&t->sighand->siglock, flags);
482 clear_tsk_thread_flag(t, TIF_SIGPENDING);
483 flush_sigqueue(&t->pending);
484 flush_sigqueue(&t->signal->shared_pending);
485 spin_unlock_irqrestore(&t->sighand->siglock, flags);
488 static void __flush_itimer_signals(struct sigpending *pending)
490 sigset_t signal, retain;
491 struct sigqueue *q, *n;
493 signal = pending->signal;
494 sigemptyset(&retain);
496 list_for_each_entry_safe(q, n, &pending->list, list) {
497 int sig = q->info.si_signo;
499 if (likely(q->info.si_code != SI_TIMER)) {
500 sigaddset(&retain, sig);
502 sigdelset(&signal, sig);
503 list_del_init(&q->list);
508 sigorsets(&pending->signal, &signal, &retain);
511 void flush_itimer_signals(void)
513 struct task_struct *tsk = current;
516 spin_lock_irqsave(&tsk->sighand->siglock, flags);
517 __flush_itimer_signals(&tsk->pending);
518 __flush_itimer_signals(&tsk->signal->shared_pending);
519 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
522 void ignore_signals(struct task_struct *t)
526 for (i = 0; i < _NSIG; ++i)
527 t->sighand->action[i].sa.sa_handler = SIG_IGN;
533 * Flush all handlers for a task.
537 flush_signal_handlers(struct task_struct *t, int force_default)
540 struct k_sigaction *ka = &t->sighand->action[0];
541 for (i = _NSIG ; i != 0 ; i--) {
542 if (force_default || ka->sa.sa_handler != SIG_IGN)
543 ka->sa.sa_handler = SIG_DFL;
545 #ifdef __ARCH_HAS_SA_RESTORER
546 ka->sa.sa_restorer = NULL;
548 sigemptyset(&ka->sa.sa_mask);
553 int unhandled_signal(struct task_struct *tsk, int sig)
555 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
556 if (is_global_init(tsk))
558 if (handler != SIG_IGN && handler != SIG_DFL)
560 /* if ptraced, let the tracer determine */
564 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
566 struct sigqueue *q, *first = NULL;
569 * Collect the siginfo appropriate to this signal. Check if
570 * there is another siginfo for the same signal.
572 list_for_each_entry(q, &list->list, list) {
573 if (q->info.si_signo == sig) {
580 sigdelset(&list->signal, sig);
584 list_del_init(&first->list);
585 copy_siginfo(info, &first->info);
586 sigqueue_free_current(first);
589 * Ok, it wasn't in the queue. This must be
590 * a fast-pathed signal or we must have been
591 * out of queue space. So zero out the info.
593 info->si_signo = sig;
595 info->si_code = SI_USER;
601 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
604 int sig = next_signal(pending, mask);
607 collect_signal(sig, pending, info);
612 * Dequeue a signal and return the element to the caller, which is
613 * expected to free it.
615 * All callers have to hold the siglock.
617 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
621 WARN_ON_ONCE(tsk != current);
623 /* We only dequeue private signals from ourselves, we don't let
624 * signalfd steal them
626 signr = __dequeue_signal(&tsk->pending, mask, info);
628 signr = __dequeue_signal(&tsk->signal->shared_pending,
633 * itimers are process shared and we restart periodic
634 * itimers in the signal delivery path to prevent DoS
635 * attacks in the high resolution timer case. This is
636 * compliant with the old way of self-restarting
637 * itimers, as the SIGALRM is a legacy signal and only
638 * queued once. Changing the restart behaviour to
639 * restart the timer in the signal dequeue path is
640 * reducing the timer noise on heavy loaded !highres
643 if (unlikely(signr == SIGALRM)) {
644 struct hrtimer *tmr = &tsk->signal->real_timer;
646 if (!hrtimer_is_queued(tmr) &&
647 tsk->signal->it_real_incr.tv64 != 0) {
648 hrtimer_forward(tmr, tmr->base->get_time(),
649 tsk->signal->it_real_incr);
650 hrtimer_restart(tmr);
659 if (unlikely(sig_kernel_stop(signr))) {
661 * Set a marker that we have dequeued a stop signal. Our
662 * caller might release the siglock and then the pending
663 * stop signal it is about to process is no longer in the
664 * pending bitmasks, but must still be cleared by a SIGCONT
665 * (and overruled by a SIGKILL). So those cases clear this
666 * shared flag after we've set it. Note that this flag may
667 * remain set after the signal we return is ignored or
668 * handled. That doesn't matter because its only purpose
669 * is to alert stop-signal processing code when another
670 * processor has come along and cleared the flag.
672 current->jobctl |= JOBCTL_STOP_DEQUEUED;
674 if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
676 * Release the siglock to ensure proper locking order
677 * of timer locks outside of siglocks. Note, we leave
678 * irqs disabled here, since the posix-timers code is
679 * about to disable them again anyway.
681 spin_unlock(&tsk->sighand->siglock);
682 do_schedule_next_timer(info);
683 spin_lock(&tsk->sighand->siglock);
689 * Tell a process that it has a new active signal..
691 * NOTE! we rely on the previous spin_lock to
692 * lock interrupts for us! We can only be called with
693 * "siglock" held, and the local interrupt must
694 * have been disabled when that got acquired!
696 * No need to set need_resched since signal event passing
697 * goes through ->blocked
699 void signal_wake_up_state(struct task_struct *t, unsigned int state)
701 set_tsk_thread_flag(t, TIF_SIGPENDING);
703 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
704 * case. We don't check t->state here because there is a race with it
705 * executing another processor and just now entering stopped state.
706 * By using wake_up_state, we ensure the process will wake up and
707 * handle its death signal.
709 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
714 * Remove signals in mask from the pending set and queue.
715 * Returns 1 if any signals were found.
717 * All callers must be holding the siglock.
719 static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
721 struct sigqueue *q, *n;
724 sigandsets(&m, mask, &s->signal);
725 if (sigisemptyset(&m))
728 sigandnsets(&s->signal, &s->signal, mask);
729 list_for_each_entry_safe(q, n, &s->list, list) {
730 if (sigismember(mask, q->info.si_signo)) {
731 list_del_init(&q->list);
738 static inline int is_si_special(const struct siginfo *info)
740 return info <= SEND_SIG_FORCED;
743 static inline bool si_fromuser(const struct siginfo *info)
745 return info == SEND_SIG_NOINFO ||
746 (!is_si_special(info) && SI_FROMUSER(info));
750 * called with RCU read lock from check_kill_permission()
752 static int kill_ok_by_cred(struct task_struct *t)
754 const struct cred *cred = current_cred();
755 const struct cred *tcred = __task_cred(t);
757 if (uid_eq(cred->euid, tcred->suid) ||
758 uid_eq(cred->euid, tcred->uid) ||
759 uid_eq(cred->uid, tcred->suid) ||
760 uid_eq(cred->uid, tcred->uid))
763 if (ns_capable(tcred->user_ns, CAP_KILL))
770 * Bad permissions for sending the signal
771 * - the caller must hold the RCU read lock
773 static int check_kill_permission(int sig, struct siginfo *info,
774 struct task_struct *t)
779 if (!valid_signal(sig))
782 if (!si_fromuser(info))
785 error = audit_signal_info(sig, t); /* Let audit system see the signal */
789 if (!same_thread_group(current, t) &&
790 !kill_ok_by_cred(t)) {
793 sid = task_session(t);
795 * We don't return the error if sid == NULL. The
796 * task was unhashed, the caller must notice this.
798 if (!sid || sid == task_session(current))
805 return security_task_kill(t, info, sig, 0);
809 * ptrace_trap_notify - schedule trap to notify ptracer
810 * @t: tracee wanting to notify tracer
812 * This function schedules sticky ptrace trap which is cleared on the next
813 * TRAP_STOP to notify ptracer of an event. @t must have been seized by
816 * If @t is running, STOP trap will be taken. If trapped for STOP and
817 * ptracer is listening for events, tracee is woken up so that it can
818 * re-trap for the new event. If trapped otherwise, STOP trap will be
819 * eventually taken without returning to userland after the existing traps
820 * are finished by PTRACE_CONT.
823 * Must be called with @task->sighand->siglock held.
825 static void ptrace_trap_notify(struct task_struct *t)
827 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
828 assert_spin_locked(&t->sighand->siglock);
830 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
831 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
835 * Handle magic process-wide effects of stop/continue signals. Unlike
836 * the signal actions, these happen immediately at signal-generation
837 * time regardless of blocking, ignoring, or handling. This does the
838 * actual continuing for SIGCONT, but not the actual stopping for stop
839 * signals. The process stop is done as a signal action for SIG_DFL.
841 * Returns true if the signal should be actually delivered, otherwise
842 * it should be dropped.
844 static bool prepare_signal(int sig, struct task_struct *p, bool force)
846 struct signal_struct *signal = p->signal;
847 struct task_struct *t;
850 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
851 if (!(signal->flags & SIGNAL_GROUP_EXIT))
852 return sig == SIGKILL;
854 * The process is in the middle of dying, nothing to do.
856 } else if (sig_kernel_stop(sig)) {
858 * This is a stop signal. Remove SIGCONT from all queues.
860 siginitset(&flush, sigmask(SIGCONT));
861 flush_sigqueue_mask(&flush, &signal->shared_pending);
862 for_each_thread(p, t)
863 flush_sigqueue_mask(&flush, &t->pending);
864 } else if (sig == SIGCONT) {
867 * Remove all stop signals from all queues, wake all threads.
869 siginitset(&flush, SIG_KERNEL_STOP_MASK);
870 flush_sigqueue_mask(&flush, &signal->shared_pending);
871 for_each_thread(p, t) {
872 flush_sigqueue_mask(&flush, &t->pending);
873 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
874 if (likely(!(t->ptrace & PT_SEIZED)))
875 wake_up_state(t, __TASK_STOPPED);
877 ptrace_trap_notify(t);
881 * Notify the parent with CLD_CONTINUED if we were stopped.
883 * If we were in the middle of a group stop, we pretend it
884 * was already finished, and then continued. Since SIGCHLD
885 * doesn't queue we report only CLD_STOPPED, as if the next
886 * CLD_CONTINUED was dropped.
889 if (signal->flags & SIGNAL_STOP_STOPPED)
890 why |= SIGNAL_CLD_CONTINUED;
891 else if (signal->group_stop_count)
892 why |= SIGNAL_CLD_STOPPED;
896 * The first thread which returns from do_signal_stop()
897 * will take ->siglock, notice SIGNAL_CLD_MASK, and
898 * notify its parent. See get_signal_to_deliver().
900 signal->flags = why | SIGNAL_STOP_CONTINUED;
901 signal->group_stop_count = 0;
902 signal->group_exit_code = 0;
906 return !sig_ignored(p, sig, force);
910 * Test if P wants to take SIG. After we've checked all threads with this,
911 * it's equivalent to finding no threads not blocking SIG. Any threads not
912 * blocking SIG were ruled out because they are not running and already
913 * have pending signals. Such threads will dequeue from the shared queue
914 * as soon as they're available, so putting the signal on the shared queue
915 * will be equivalent to sending it to one such thread.
917 static inline int wants_signal(int sig, struct task_struct *p)
919 if (sigismember(&p->blocked, sig))
921 if (p->flags & PF_EXITING)
925 if (task_is_stopped_or_traced(p))
927 return task_curr(p) || !signal_pending(p);
930 static void complete_signal(int sig, struct task_struct *p, int group)
932 struct signal_struct *signal = p->signal;
933 struct task_struct *t;
936 * Now find a thread we can wake up to take the signal off the queue.
938 * If the main thread wants the signal, it gets first crack.
939 * Probably the least surprising to the average bear.
941 if (wants_signal(sig, p))
943 else if (!group || thread_group_empty(p))
945 * There is just one thread and it does not need to be woken.
946 * It will dequeue unblocked signals before it runs again.
951 * Otherwise try to find a suitable thread.
953 t = signal->curr_target;
954 while (!wants_signal(sig, t)) {
956 if (t == signal->curr_target)
958 * No thread needs to be woken.
959 * Any eligible threads will see
960 * the signal in the queue soon.
964 signal->curr_target = t;
968 * Found a killable thread. If the signal will be fatal,
969 * then start taking the whole group down immediately.
971 if (sig_fatal(p, sig) &&
972 !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
973 !sigismember(&t->real_blocked, sig) &&
974 (sig == SIGKILL || !t->ptrace)) {
976 * This signal will be fatal to the whole group.
978 if (!sig_kernel_coredump(sig)) {
980 * Start a group exit and wake everybody up.
981 * This way we don't have other threads
982 * running and doing things after a slower
983 * thread has the fatal signal pending.
985 signal->flags = SIGNAL_GROUP_EXIT;
986 signal->group_exit_code = sig;
987 signal->group_stop_count = 0;
990 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
991 sigaddset(&t->pending.signal, SIGKILL);
992 signal_wake_up(t, 1);
993 } while_each_thread(p, t);
999 * The signal is already in the shared-pending queue.
1000 * Tell the chosen thread to wake up and dequeue it.
1002 signal_wake_up(t, sig == SIGKILL);
1006 static inline int legacy_queue(struct sigpending *signals, int sig)
1008 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1011 #ifdef CONFIG_USER_NS
1012 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
1014 if (current_user_ns() == task_cred_xxx(t, user_ns))
1017 if (SI_FROMKERNEL(info))
1021 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
1022 make_kuid(current_user_ns(), info->si_uid));
1026 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
1032 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
1033 int group, int from_ancestor_ns)
1035 struct sigpending *pending;
1037 int override_rlimit;
1038 int ret = 0, result;
1040 assert_spin_locked(&t->sighand->siglock);
1042 result = TRACE_SIGNAL_IGNORED;
1043 if (!prepare_signal(sig, t,
1044 from_ancestor_ns || (info == SEND_SIG_FORCED)))
1047 pending = group ? &t->signal->shared_pending : &t->pending;
1049 * Short-circuit ignored signals and support queuing
1050 * exactly one non-rt signal, so that we can get more
1051 * detailed information about the cause of the signal.
1053 result = TRACE_SIGNAL_ALREADY_PENDING;
1054 if (legacy_queue(pending, sig))
1057 result = TRACE_SIGNAL_DELIVERED;
1059 * fast-pathed signals for kernel-internal things like SIGSTOP
1062 if (info == SEND_SIG_FORCED)
1066 * Real-time signals must be queued if sent by sigqueue, or
1067 * some other real-time mechanism. It is implementation
1068 * defined whether kill() does so. We attempt to do so, on
1069 * the principle of least surprise, but since kill is not
1070 * allowed to fail with EAGAIN when low on memory we just
1071 * make sure at least one signal gets delivered and don't
1072 * pass on the info struct.
1075 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1077 override_rlimit = 0;
1079 q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
1082 list_add_tail(&q->list, &pending->list);
1083 switch ((unsigned long) info) {
1084 case (unsigned long) SEND_SIG_NOINFO:
1085 q->info.si_signo = sig;
1086 q->info.si_errno = 0;
1087 q->info.si_code = SI_USER;
1088 q->info.si_pid = task_tgid_nr_ns(current,
1089 task_active_pid_ns(t));
1090 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1092 case (unsigned long) SEND_SIG_PRIV:
1093 q->info.si_signo = sig;
1094 q->info.si_errno = 0;
1095 q->info.si_code = SI_KERNEL;
1100 copy_siginfo(&q->info, info);
1101 if (from_ancestor_ns)
1106 userns_fixup_signal_uid(&q->info, t);
1108 } else if (!is_si_special(info)) {
1109 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1111 * Queue overflow, abort. We may abort if the
1112 * signal was rt and sent by user using something
1113 * other than kill().
1115 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1120 * This is a silent loss of information. We still
1121 * send the signal, but the *info bits are lost.
1123 result = TRACE_SIGNAL_LOSE_INFO;
1128 signalfd_notify(t, sig);
1129 sigaddset(&pending->signal, sig);
1130 complete_signal(sig, t, group);
1132 trace_signal_generate(sig, info, t, group, result);
1136 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1139 int from_ancestor_ns = 0;
1141 #ifdef CONFIG_PID_NS
1142 from_ancestor_ns = si_fromuser(info) &&
1143 !task_pid_nr_ns(current, task_active_pid_ns(t));
1146 return __send_signal(sig, info, t, group, from_ancestor_ns);
1149 static void print_fatal_signal(int signr)
1151 struct pt_regs *regs = signal_pt_regs();
1152 printk(KERN_INFO "potentially unexpected fatal signal %d.\n", signr);
1154 #if defined(__i386__) && !defined(__arch_um__)
1155 printk(KERN_INFO "code at %08lx: ", regs->ip);
1158 for (i = 0; i < 16; i++) {
1161 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1163 printk(KERN_CONT "%02x ", insn);
1166 printk(KERN_CONT "\n");
1173 static int __init setup_print_fatal_signals(char *str)
1175 get_option (&str, &print_fatal_signals);
1180 __setup("print-fatal-signals=", setup_print_fatal_signals);
1183 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1185 return send_signal(sig, info, p, 1);
1189 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1191 return send_signal(sig, info, t, 0);
1194 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1197 unsigned long flags;
1200 if (lock_task_sighand(p, &flags)) {
1201 ret = send_signal(sig, info, p, group);
1202 unlock_task_sighand(p, &flags);
1209 * Force a signal that the process can't ignore: if necessary
1210 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1212 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1213 * since we do not want to have a signal handler that was blocked
1214 * be invoked when user space had explicitly blocked it.
1216 * We don't want to have recursive SIGSEGV's etc, for example,
1217 * that is why we also clear SIGNAL_UNKILLABLE.
1220 do_force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1222 unsigned long int flags;
1223 int ret, blocked, ignored;
1224 struct k_sigaction *action;
1226 spin_lock_irqsave(&t->sighand->siglock, flags);
1227 action = &t->sighand->action[sig-1];
1228 ignored = action->sa.sa_handler == SIG_IGN;
1229 blocked = sigismember(&t->blocked, sig);
1230 if (blocked || ignored) {
1231 action->sa.sa_handler = SIG_DFL;
1233 sigdelset(&t->blocked, sig);
1234 recalc_sigpending_and_wake(t);
1237 if (action->sa.sa_handler == SIG_DFL)
1238 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1239 ret = specific_send_sig_info(sig, info, t);
1240 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1245 int force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1248 * On some archs, PREEMPT_RT has to delay sending a signal from a trap
1249 * since it can not enable preemption, and the signal code's spin_locks
1250 * turn into mutexes. Instead, it must set TIF_NOTIFY_RESUME which will
1251 * send the signal on exit of the trap.
1253 #ifdef ARCH_RT_DELAYS_SIGNAL_SEND
1255 if (WARN_ON_ONCE(t != current))
1257 if (WARN_ON_ONCE(t->forced_info.si_signo))
1260 if (is_si_special(info)) {
1261 WARN_ON_ONCE(info != SEND_SIG_PRIV);
1262 t->forced_info.si_signo = sig;
1263 t->forced_info.si_errno = 0;
1264 t->forced_info.si_code = SI_KERNEL;
1265 t->forced_info.si_pid = 0;
1266 t->forced_info.si_uid = 0;
1268 t->forced_info = *info;
1271 set_tsk_thread_flag(t, TIF_NOTIFY_RESUME);
1275 return do_force_sig_info(sig, info, t);
1279 * Nuke all other threads in the group.
1281 int zap_other_threads(struct task_struct *p)
1283 struct task_struct *t = p;
1286 p->signal->group_stop_count = 0;
1288 while_each_thread(p, t) {
1289 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1292 /* Don't bother with already dead threads */
1295 sigaddset(&t->pending.signal, SIGKILL);
1296 signal_wake_up(t, 1);
1302 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1303 unsigned long *flags)
1305 struct sighand_struct *sighand;
1309 * Disable interrupts early to avoid deadlocks.
1310 * See rcu_read_unlock() comment header for details.
1312 local_irq_save_nort(*flags);
1314 sighand = rcu_dereference(tsk->sighand);
1315 if (unlikely(sighand == NULL)) {
1317 local_irq_restore_nort(*flags);
1321 * This sighand can be already freed and even reused, but
1322 * we rely on SLAB_DESTROY_BY_RCU and sighand_ctor() which
1323 * initializes ->siglock: this slab can't go away, it has
1324 * the same object type, ->siglock can't be reinitialized.
1326 * We need to ensure that tsk->sighand is still the same
1327 * after we take the lock, we can race with de_thread() or
1328 * __exit_signal(). In the latter case the next iteration
1329 * must see ->sighand == NULL.
1331 spin_lock(&sighand->siglock);
1332 if (likely(sighand == tsk->sighand)) {
1336 spin_unlock(&sighand->siglock);
1338 local_irq_restore_nort(*flags);
1345 * send signal info to all the members of a group
1347 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1352 ret = check_kill_permission(sig, info, p);
1356 ret = do_send_sig_info(sig, info, p, true);
1362 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1363 * control characters do (^C, ^Z etc)
1364 * - the caller must hold at least a readlock on tasklist_lock
1366 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1368 struct task_struct *p = NULL;
1369 int retval, success;
1373 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1374 int err = group_send_sig_info(sig, info, p);
1377 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1378 return success ? 0 : retval;
1381 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1384 struct task_struct *p;
1388 p = pid_task(pid, PIDTYPE_PID);
1390 error = group_send_sig_info(sig, info, p);
1392 if (likely(!p || error != -ESRCH))
1396 * The task was unhashed in between, try again. If it
1397 * is dead, pid_task() will return NULL, if we race with
1398 * de_thread() it will find the new leader.
1403 int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1407 error = kill_pid_info(sig, info, find_vpid(pid));
1412 static int kill_as_cred_perm(const struct cred *cred,
1413 struct task_struct *target)
1415 const struct cred *pcred = __task_cred(target);
1416 if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1417 !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid))
1422 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1423 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1424 const struct cred *cred, u32 secid)
1427 struct task_struct *p;
1428 unsigned long flags;
1430 if (!valid_signal(sig))
1434 p = pid_task(pid, PIDTYPE_PID);
1439 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1443 ret = security_task_kill(p, info, sig, secid);
1448 if (lock_task_sighand(p, &flags)) {
1449 ret = __send_signal(sig, info, p, 1, 0);
1450 unlock_task_sighand(p, &flags);
1458 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1461 * kill_something_info() interprets pid in interesting ways just like kill(2).
1463 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1464 * is probably wrong. Should make it like BSD or SYSV.
1467 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1473 ret = kill_pid_info(sig, info, find_vpid(pid));
1478 read_lock(&tasklist_lock);
1480 ret = __kill_pgrp_info(sig, info,
1481 pid ? find_vpid(-pid) : task_pgrp(current));
1483 int retval = 0, count = 0;
1484 struct task_struct * p;
1486 for_each_process(p) {
1487 if (task_pid_vnr(p) > 1 &&
1488 !same_thread_group(p, current)) {
1489 int err = group_send_sig_info(sig, info, p);
1495 ret = count ? retval : -ESRCH;
1497 read_unlock(&tasklist_lock);
1503 * These are for backward compatibility with the rest of the kernel source.
1506 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1509 * Make sure legacy kernel users don't send in bad values
1510 * (normal paths check this in check_kill_permission).
1512 if (!valid_signal(sig))
1515 return do_send_sig_info(sig, info, p, false);
1518 #define __si_special(priv) \
1519 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1522 send_sig(int sig, struct task_struct *p, int priv)
1524 return send_sig_info(sig, __si_special(priv), p);
1528 force_sig(int sig, struct task_struct *p)
1530 force_sig_info(sig, SEND_SIG_PRIV, p);
1534 * When things go south during signal handling, we
1535 * will force a SIGSEGV. And if the signal that caused
1536 * the problem was already a SIGSEGV, we'll want to
1537 * make sure we don't even try to deliver the signal..
1540 force_sigsegv(int sig, struct task_struct *p)
1542 if (sig == SIGSEGV) {
1543 unsigned long flags;
1544 spin_lock_irqsave(&p->sighand->siglock, flags);
1545 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1546 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1548 force_sig(SIGSEGV, p);
1552 int kill_pgrp(struct pid *pid, int sig, int priv)
1556 read_lock(&tasklist_lock);
1557 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1558 read_unlock(&tasklist_lock);
1562 EXPORT_SYMBOL(kill_pgrp);
1564 int kill_pid(struct pid *pid, int sig, int priv)
1566 return kill_pid_info(sig, __si_special(priv), pid);
1568 EXPORT_SYMBOL(kill_pid);
1571 * These functions support sending signals using preallocated sigqueue
1572 * structures. This is needed "because realtime applications cannot
1573 * afford to lose notifications of asynchronous events, like timer
1574 * expirations or I/O completions". In the case of POSIX Timers
1575 * we allocate the sigqueue structure from the timer_create. If this
1576 * allocation fails we are able to report the failure to the application
1577 * with an EAGAIN error.
1579 struct sigqueue *sigqueue_alloc(void)
1581 /* Preallocated sigqueue objects always from the slabcache ! */
1582 struct sigqueue *q = __sigqueue_do_alloc(-1, current, GFP_KERNEL, 0, 1);
1585 q->flags |= SIGQUEUE_PREALLOC;
1590 void sigqueue_free(struct sigqueue *q)
1592 unsigned long flags;
1593 spinlock_t *lock = ¤t->sighand->siglock;
1595 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1597 * We must hold ->siglock while testing q->list
1598 * to serialize with collect_signal() or with
1599 * __exit_signal()->flush_sigqueue().
1601 spin_lock_irqsave(lock, flags);
1602 q->flags &= ~SIGQUEUE_PREALLOC;
1604 * If it is queued it will be freed when dequeued,
1605 * like the "regular" sigqueue.
1607 if (!list_empty(&q->list))
1609 spin_unlock_irqrestore(lock, flags);
1615 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1617 int sig = q->info.si_signo;
1618 struct sigpending *pending;
1619 unsigned long flags;
1622 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1625 if (!likely(lock_task_sighand(t, &flags)))
1628 ret = 1; /* the signal is ignored */
1629 result = TRACE_SIGNAL_IGNORED;
1630 if (!prepare_signal(sig, t, false))
1634 if (unlikely(!list_empty(&q->list))) {
1636 * If an SI_TIMER entry is already queue just increment
1637 * the overrun count.
1639 BUG_ON(q->info.si_code != SI_TIMER);
1640 q->info.si_overrun++;
1641 result = TRACE_SIGNAL_ALREADY_PENDING;
1644 q->info.si_overrun = 0;
1646 signalfd_notify(t, sig);
1647 pending = group ? &t->signal->shared_pending : &t->pending;
1648 list_add_tail(&q->list, &pending->list);
1649 sigaddset(&pending->signal, sig);
1650 complete_signal(sig, t, group);
1651 result = TRACE_SIGNAL_DELIVERED;
1653 trace_signal_generate(sig, &q->info, t, group, result);
1654 unlock_task_sighand(t, &flags);
1660 * Let a parent know about the death of a child.
1661 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1663 * Returns true if our parent ignored us and so we've switched to
1666 bool do_notify_parent(struct task_struct *tsk, int sig)
1668 struct siginfo info;
1669 unsigned long flags;
1670 struct sighand_struct *psig;
1671 bool autoreap = false;
1672 cputime_t utime, stime;
1676 /* do_notify_parent_cldstop should have been called instead. */
1677 BUG_ON(task_is_stopped_or_traced(tsk));
1679 BUG_ON(!tsk->ptrace &&
1680 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1682 if (sig != SIGCHLD) {
1684 * This is only possible if parent == real_parent.
1685 * Check if it has changed security domain.
1687 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1691 info.si_signo = sig;
1694 * We are under tasklist_lock here so our parent is tied to
1695 * us and cannot change.
1697 * task_active_pid_ns will always return the same pid namespace
1698 * until a task passes through release_task.
1700 * write_lock() currently calls preempt_disable() which is the
1701 * same as rcu_read_lock(), but according to Oleg, this is not
1702 * correct to rely on this
1705 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1706 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1710 task_cputime(tsk, &utime, &stime);
1711 info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime);
1712 info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime);
1714 info.si_status = tsk->exit_code & 0x7f;
1715 if (tsk->exit_code & 0x80)
1716 info.si_code = CLD_DUMPED;
1717 else if (tsk->exit_code & 0x7f)
1718 info.si_code = CLD_KILLED;
1720 info.si_code = CLD_EXITED;
1721 info.si_status = tsk->exit_code >> 8;
1724 psig = tsk->parent->sighand;
1725 spin_lock_irqsave(&psig->siglock, flags);
1726 if (!tsk->ptrace && sig == SIGCHLD &&
1727 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1728 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1730 * We are exiting and our parent doesn't care. POSIX.1
1731 * defines special semantics for setting SIGCHLD to SIG_IGN
1732 * or setting the SA_NOCLDWAIT flag: we should be reaped
1733 * automatically and not left for our parent's wait4 call.
1734 * Rather than having the parent do it as a magic kind of
1735 * signal handler, we just set this to tell do_exit that we
1736 * can be cleaned up without becoming a zombie. Note that
1737 * we still call __wake_up_parent in this case, because a
1738 * blocked sys_wait4 might now return -ECHILD.
1740 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1741 * is implementation-defined: we do (if you don't want
1742 * it, just use SIG_IGN instead).
1745 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1748 if (valid_signal(sig) && sig)
1749 __group_send_sig_info(sig, &info, tsk->parent);
1750 __wake_up_parent(tsk, tsk->parent);
1751 spin_unlock_irqrestore(&psig->siglock, flags);
1757 * do_notify_parent_cldstop - notify parent of stopped/continued state change
1758 * @tsk: task reporting the state change
1759 * @for_ptracer: the notification is for ptracer
1760 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1762 * Notify @tsk's parent that the stopped/continued state has changed. If
1763 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1764 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1767 * Must be called with tasklist_lock at least read locked.
1769 static void do_notify_parent_cldstop(struct task_struct *tsk,
1770 bool for_ptracer, int why)
1772 struct siginfo info;
1773 unsigned long flags;
1774 struct task_struct *parent;
1775 struct sighand_struct *sighand;
1776 cputime_t utime, stime;
1779 parent = tsk->parent;
1781 tsk = tsk->group_leader;
1782 parent = tsk->real_parent;
1785 info.si_signo = SIGCHLD;
1788 * see comment in do_notify_parent() about the following 4 lines
1791 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1792 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1795 task_cputime(tsk, &utime, &stime);
1796 info.si_utime = cputime_to_clock_t(utime);
1797 info.si_stime = cputime_to_clock_t(stime);
1802 info.si_status = SIGCONT;
1805 info.si_status = tsk->signal->group_exit_code & 0x7f;
1808 info.si_status = tsk->exit_code & 0x7f;
1814 sighand = parent->sighand;
1815 spin_lock_irqsave(&sighand->siglock, flags);
1816 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1817 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1818 __group_send_sig_info(SIGCHLD, &info, parent);
1820 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1822 __wake_up_parent(tsk, parent);
1823 spin_unlock_irqrestore(&sighand->siglock, flags);
1826 static inline int may_ptrace_stop(void)
1828 if (!likely(current->ptrace))
1831 * Are we in the middle of do_coredump?
1832 * If so and our tracer is also part of the coredump stopping
1833 * is a deadlock situation, and pointless because our tracer
1834 * is dead so don't allow us to stop.
1835 * If SIGKILL was already sent before the caller unlocked
1836 * ->siglock we must see ->core_state != NULL. Otherwise it
1837 * is safe to enter schedule().
1839 * This is almost outdated, a task with the pending SIGKILL can't
1840 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1841 * after SIGKILL was already dequeued.
1843 if (unlikely(current->mm->core_state) &&
1844 unlikely(current->mm == current->parent->mm))
1851 * Return non-zero if there is a SIGKILL that should be waking us up.
1852 * Called with the siglock held.
1854 static int sigkill_pending(struct task_struct *tsk)
1856 return sigismember(&tsk->pending.signal, SIGKILL) ||
1857 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1861 * This must be called with current->sighand->siglock held.
1863 * This should be the path for all ptrace stops.
1864 * We always set current->last_siginfo while stopped here.
1865 * That makes it a way to test a stopped process for
1866 * being ptrace-stopped vs being job-control-stopped.
1868 * If we actually decide not to stop at all because the tracer
1869 * is gone, we keep current->exit_code unless clear_code.
1871 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1872 __releases(¤t->sighand->siglock)
1873 __acquires(¤t->sighand->siglock)
1875 bool gstop_done = false;
1877 if (arch_ptrace_stop_needed(exit_code, info)) {
1879 * The arch code has something special to do before a
1880 * ptrace stop. This is allowed to block, e.g. for faults
1881 * on user stack pages. We can't keep the siglock while
1882 * calling arch_ptrace_stop, so we must release it now.
1883 * To preserve proper semantics, we must do this before
1884 * any signal bookkeeping like checking group_stop_count.
1885 * Meanwhile, a SIGKILL could come in before we retake the
1886 * siglock. That must prevent us from sleeping in TASK_TRACED.
1887 * So after regaining the lock, we must check for SIGKILL.
1889 spin_unlock_irq(¤t->sighand->siglock);
1890 arch_ptrace_stop(exit_code, info);
1891 spin_lock_irq(¤t->sighand->siglock);
1892 if (sigkill_pending(current))
1897 * We're committing to trapping. TRACED should be visible before
1898 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1899 * Also, transition to TRACED and updates to ->jobctl should be
1900 * atomic with respect to siglock and should be done after the arch
1901 * hook as siglock is released and regrabbed across it.
1903 set_current_state(TASK_TRACED);
1905 current->last_siginfo = info;
1906 current->exit_code = exit_code;
1909 * If @why is CLD_STOPPED, we're trapping to participate in a group
1910 * stop. Do the bookkeeping. Note that if SIGCONT was delievered
1911 * across siglock relocks since INTERRUPT was scheduled, PENDING
1912 * could be clear now. We act as if SIGCONT is received after
1913 * TASK_TRACED is entered - ignore it.
1915 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1916 gstop_done = task_participate_group_stop(current);
1918 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1919 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1920 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1921 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
1923 /* entering a trap, clear TRAPPING */
1924 task_clear_jobctl_trapping(current);
1926 spin_unlock_irq(¤t->sighand->siglock);
1927 read_lock(&tasklist_lock);
1928 if (may_ptrace_stop()) {
1930 * Notify parents of the stop.
1932 * While ptraced, there are two parents - the ptracer and
1933 * the real_parent of the group_leader. The ptracer should
1934 * know about every stop while the real parent is only
1935 * interested in the completion of group stop. The states
1936 * for the two don't interact with each other. Notify
1937 * separately unless they're gonna be duplicates.
1939 do_notify_parent_cldstop(current, true, why);
1940 if (gstop_done && ptrace_reparented(current))
1941 do_notify_parent_cldstop(current, false, why);
1943 read_unlock(&tasklist_lock);
1944 freezable_schedule();
1947 * By the time we got the lock, our tracer went away.
1948 * Don't drop the lock yet, another tracer may come.
1950 * If @gstop_done, the ptracer went away between group stop
1951 * completion and here. During detach, it would have set
1952 * JOBCTL_STOP_PENDING on us and we'll re-enter
1953 * TASK_STOPPED in do_signal_stop() on return, so notifying
1954 * the real parent of the group stop completion is enough.
1957 do_notify_parent_cldstop(current, false, why);
1959 /* tasklist protects us from ptrace_freeze_traced() */
1960 __set_current_state(TASK_RUNNING);
1962 current->exit_code = 0;
1963 read_unlock(&tasklist_lock);
1967 * We are back. Now reacquire the siglock before touching
1968 * last_siginfo, so that we are sure to have synchronized with
1969 * any signal-sending on another CPU that wants to examine it.
1971 spin_lock_irq(¤t->sighand->siglock);
1972 current->last_siginfo = NULL;
1974 /* LISTENING can be set only during STOP traps, clear it */
1975 current->jobctl &= ~JOBCTL_LISTENING;
1978 * Queued signals ignored us while we were stopped for tracing.
1979 * So check for any that we should take before resuming user mode.
1980 * This sets TIF_SIGPENDING, but never clears it.
1982 recalc_sigpending_tsk(current);
1985 static void ptrace_do_notify(int signr, int exit_code, int why)
1989 memset(&info, 0, sizeof info);
1990 info.si_signo = signr;
1991 info.si_code = exit_code;
1992 info.si_pid = task_pid_vnr(current);
1993 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1995 /* Let the debugger run. */
1996 ptrace_stop(exit_code, why, 1, &info);
1999 void ptrace_notify(int exit_code)
2001 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2002 if (unlikely(current->task_works))
2005 spin_lock_irq(¤t->sighand->siglock);
2006 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
2007 spin_unlock_irq(¤t->sighand->siglock);
2011 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
2012 * @signr: signr causing group stop if initiating
2014 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
2015 * and participate in it. If already set, participate in the existing
2016 * group stop. If participated in a group stop (and thus slept), %true is
2017 * returned with siglock released.
2019 * If ptraced, this function doesn't handle stop itself. Instead,
2020 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
2021 * untouched. The caller must ensure that INTERRUPT trap handling takes
2022 * places afterwards.
2025 * Must be called with @current->sighand->siglock held, which is released
2029 * %false if group stop is already cancelled or ptrace trap is scheduled.
2030 * %true if participated in group stop.
2032 static bool do_signal_stop(int signr)
2033 __releases(¤t->sighand->siglock)
2035 struct signal_struct *sig = current->signal;
2037 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2038 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2039 struct task_struct *t;
2041 /* signr will be recorded in task->jobctl for retries */
2042 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2044 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2045 unlikely(signal_group_exit(sig)))
2048 * There is no group stop already in progress. We must
2051 * While ptraced, a task may be resumed while group stop is
2052 * still in effect and then receive a stop signal and
2053 * initiate another group stop. This deviates from the
2054 * usual behavior as two consecutive stop signals can't
2055 * cause two group stops when !ptraced. That is why we
2056 * also check !task_is_stopped(t) below.
2058 * The condition can be distinguished by testing whether
2059 * SIGNAL_STOP_STOPPED is already set. Don't generate
2060 * group_exit_code in such case.
2062 * This is not necessary for SIGNAL_STOP_CONTINUED because
2063 * an intervening stop signal is required to cause two
2064 * continued events regardless of ptrace.
2066 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2067 sig->group_exit_code = signr;
2069 sig->group_stop_count = 0;
2071 if (task_set_jobctl_pending(current, signr | gstop))
2072 sig->group_stop_count++;
2075 while_each_thread(current, t) {
2077 * Setting state to TASK_STOPPED for a group
2078 * stop is always done with the siglock held,
2079 * so this check has no races.
2081 if (!task_is_stopped(t) &&
2082 task_set_jobctl_pending(t, signr | gstop)) {
2083 sig->group_stop_count++;
2084 if (likely(!(t->ptrace & PT_SEIZED)))
2085 signal_wake_up(t, 0);
2087 ptrace_trap_notify(t);
2092 if (likely(!current->ptrace)) {
2096 * If there are no other threads in the group, or if there
2097 * is a group stop in progress and we are the last to stop,
2098 * report to the parent.
2100 if (task_participate_group_stop(current))
2101 notify = CLD_STOPPED;
2103 __set_current_state(TASK_STOPPED);
2104 spin_unlock_irq(¤t->sighand->siglock);
2107 * Notify the parent of the group stop completion. Because
2108 * we're not holding either the siglock or tasklist_lock
2109 * here, ptracer may attach inbetween; however, this is for
2110 * group stop and should always be delivered to the real
2111 * parent of the group leader. The new ptracer will get
2112 * its notification when this task transitions into
2116 read_lock(&tasklist_lock);
2117 do_notify_parent_cldstop(current, false, notify);
2118 read_unlock(&tasklist_lock);
2121 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2122 freezable_schedule();
2126 * While ptraced, group stop is handled by STOP trap.
2127 * Schedule it and let the caller deal with it.
2129 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2135 * do_jobctl_trap - take care of ptrace jobctl traps
2137 * When PT_SEIZED, it's used for both group stop and explicit
2138 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
2139 * accompanying siginfo. If stopped, lower eight bits of exit_code contain
2140 * the stop signal; otherwise, %SIGTRAP.
2142 * When !PT_SEIZED, it's used only for group stop trap with stop signal
2143 * number as exit_code and no siginfo.
2146 * Must be called with @current->sighand->siglock held, which may be
2147 * released and re-acquired before returning with intervening sleep.
2149 static void do_jobctl_trap(void)
2151 struct signal_struct *signal = current->signal;
2152 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2154 if (current->ptrace & PT_SEIZED) {
2155 if (!signal->group_stop_count &&
2156 !(signal->flags & SIGNAL_STOP_STOPPED))
2158 WARN_ON_ONCE(!signr);
2159 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2162 WARN_ON_ONCE(!signr);
2163 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2164 current->exit_code = 0;
2168 static int ptrace_signal(int signr, siginfo_t *info)
2170 ptrace_signal_deliver();
2172 * We do not check sig_kernel_stop(signr) but set this marker
2173 * unconditionally because we do not know whether debugger will
2174 * change signr. This flag has no meaning unless we are going
2175 * to stop after return from ptrace_stop(). In this case it will
2176 * be checked in do_signal_stop(), we should only stop if it was
2177 * not cleared by SIGCONT while we were sleeping. See also the
2178 * comment in dequeue_signal().
2180 current->jobctl |= JOBCTL_STOP_DEQUEUED;
2181 ptrace_stop(signr, CLD_TRAPPED, 0, info);
2183 /* We're back. Did the debugger cancel the sig? */
2184 signr = current->exit_code;
2188 current->exit_code = 0;
2191 * Update the siginfo structure if the signal has
2192 * changed. If the debugger wanted something
2193 * specific in the siginfo structure then it should
2194 * have updated *info via PTRACE_SETSIGINFO.
2196 if (signr != info->si_signo) {
2197 info->si_signo = signr;
2199 info->si_code = SI_USER;
2201 info->si_pid = task_pid_vnr(current->parent);
2202 info->si_uid = from_kuid_munged(current_user_ns(),
2203 task_uid(current->parent));
2207 /* If the (new) signal is now blocked, requeue it. */
2208 if (sigismember(¤t->blocked, signr)) {
2209 specific_send_sig_info(signr, info, current);
2216 int get_signal(struct ksignal *ksig)
2218 struct sighand_struct *sighand = current->sighand;
2219 struct signal_struct *signal = current->signal;
2222 if (unlikely(current->task_works))
2225 if (unlikely(uprobe_deny_signal()))
2229 * Do this once, we can't return to user-mode if freezing() == T.
2230 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2231 * thus do not need another check after return.
2236 spin_lock_irq(&sighand->siglock);
2238 * Every stopped thread goes here after wakeup. Check to see if
2239 * we should notify the parent, prepare_signal(SIGCONT) encodes
2240 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2242 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2245 if (signal->flags & SIGNAL_CLD_CONTINUED)
2246 why = CLD_CONTINUED;
2250 signal->flags &= ~SIGNAL_CLD_MASK;
2252 spin_unlock_irq(&sighand->siglock);
2255 * Notify the parent that we're continuing. This event is
2256 * always per-process and doesn't make whole lot of sense
2257 * for ptracers, who shouldn't consume the state via
2258 * wait(2) either, but, for backward compatibility, notify
2259 * the ptracer of the group leader too unless it's gonna be
2262 read_lock(&tasklist_lock);
2263 do_notify_parent_cldstop(current, false, why);
2265 if (ptrace_reparented(current->group_leader))
2266 do_notify_parent_cldstop(current->group_leader,
2268 read_unlock(&tasklist_lock);
2274 struct k_sigaction *ka;
2276 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2280 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2282 spin_unlock_irq(&sighand->siglock);
2286 signr = dequeue_signal(current, ¤t->blocked, &ksig->info);
2289 break; /* will return 0 */
2291 if (unlikely(current->ptrace) && signr != SIGKILL) {
2292 signr = ptrace_signal(signr, &ksig->info);
2297 ka = &sighand->action[signr-1];
2299 /* Trace actually delivered signals. */
2300 trace_signal_deliver(signr, &ksig->info, ka);
2302 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
2304 if (ka->sa.sa_handler != SIG_DFL) {
2305 /* Run the handler. */
2308 if (ka->sa.sa_flags & SA_ONESHOT)
2309 ka->sa.sa_handler = SIG_DFL;
2311 break; /* will return non-zero "signr" value */
2315 * Now we are doing the default action for this signal.
2317 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2321 * Global init gets no signals it doesn't want.
2322 * Container-init gets no signals it doesn't want from same
2325 * Note that if global/container-init sees a sig_kernel_only()
2326 * signal here, the signal must have been generated internally
2327 * or must have come from an ancestor namespace. In either
2328 * case, the signal cannot be dropped.
2330 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2331 !sig_kernel_only(signr))
2334 if (sig_kernel_stop(signr)) {
2336 * The default action is to stop all threads in
2337 * the thread group. The job control signals
2338 * do nothing in an orphaned pgrp, but SIGSTOP
2339 * always works. Note that siglock needs to be
2340 * dropped during the call to is_orphaned_pgrp()
2341 * because of lock ordering with tasklist_lock.
2342 * This allows an intervening SIGCONT to be posted.
2343 * We need to check for that and bail out if necessary.
2345 if (signr != SIGSTOP) {
2346 spin_unlock_irq(&sighand->siglock);
2348 /* signals can be posted during this window */
2350 if (is_current_pgrp_orphaned())
2353 spin_lock_irq(&sighand->siglock);
2356 if (likely(do_signal_stop(ksig->info.si_signo))) {
2357 /* It released the siglock. */
2362 * We didn't actually stop, due to a race
2363 * with SIGCONT or something like that.
2368 spin_unlock_irq(&sighand->siglock);
2371 * Anything else is fatal, maybe with a core dump.
2373 current->flags |= PF_SIGNALED;
2375 if (sig_kernel_coredump(signr)) {
2376 if (print_fatal_signals)
2377 print_fatal_signal(ksig->info.si_signo);
2378 proc_coredump_connector(current);
2380 * If it was able to dump core, this kills all
2381 * other threads in the group and synchronizes with
2382 * their demise. If we lost the race with another
2383 * thread getting here, it set group_exit_code
2384 * first and our do_group_exit call below will use
2385 * that value and ignore the one we pass it.
2387 do_coredump(&ksig->info);
2391 * Death signals, no core dump.
2393 do_group_exit(ksig->info.si_signo);
2396 spin_unlock_irq(&sighand->siglock);
2399 return ksig->sig > 0;
2403 * signal_delivered -
2404 * @ksig: kernel signal struct
2405 * @stepping: nonzero if debugger single-step or block-step in use
2407 * This function should be called when a signal has successfully been
2408 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2409 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2410 * is set in @ksig->ka.sa.sa_flags. Tracing is notified.
2412 static void signal_delivered(struct ksignal *ksig, int stepping)
2416 /* A signal was successfully delivered, and the
2417 saved sigmask was stored on the signal frame,
2418 and will be restored by sigreturn. So we can
2419 simply clear the restore sigmask flag. */
2420 clear_restore_sigmask();
2422 sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask);
2423 if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2424 sigaddset(&blocked, ksig->sig);
2425 set_current_blocked(&blocked);
2426 tracehook_signal_handler(stepping);
2429 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2432 force_sigsegv(ksig->sig, current);
2434 signal_delivered(ksig, stepping);
2438 * It could be that complete_signal() picked us to notify about the
2439 * group-wide signal. Other threads should be notified now to take
2440 * the shared signals in @which since we will not.
2442 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2445 struct task_struct *t;
2447 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2448 if (sigisemptyset(&retarget))
2452 while_each_thread(tsk, t) {
2453 if (t->flags & PF_EXITING)
2456 if (!has_pending_signals(&retarget, &t->blocked))
2458 /* Remove the signals this thread can handle. */
2459 sigandsets(&retarget, &retarget, &t->blocked);
2461 if (!signal_pending(t))
2462 signal_wake_up(t, 0);
2464 if (sigisemptyset(&retarget))
2469 void exit_signals(struct task_struct *tsk)
2475 * @tsk is about to have PF_EXITING set - lock out users which
2476 * expect stable threadgroup.
2478 threadgroup_change_begin(tsk);
2480 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2481 tsk->flags |= PF_EXITING;
2482 threadgroup_change_end(tsk);
2486 spin_lock_irq(&tsk->sighand->siglock);
2488 * From now this task is not visible for group-wide signals,
2489 * see wants_signal(), do_signal_stop().
2491 tsk->flags |= PF_EXITING;
2493 threadgroup_change_end(tsk);
2495 if (!signal_pending(tsk))
2498 unblocked = tsk->blocked;
2499 signotset(&unblocked);
2500 retarget_shared_pending(tsk, &unblocked);
2502 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2503 task_participate_group_stop(tsk))
2504 group_stop = CLD_STOPPED;
2506 spin_unlock_irq(&tsk->sighand->siglock);
2509 * If group stop has completed, deliver the notification. This
2510 * should always go to the real parent of the group leader.
2512 if (unlikely(group_stop)) {
2513 read_lock(&tasklist_lock);
2514 do_notify_parent_cldstop(tsk, false, group_stop);
2515 read_unlock(&tasklist_lock);
2519 EXPORT_SYMBOL(recalc_sigpending);
2520 EXPORT_SYMBOL_GPL(dequeue_signal);
2521 EXPORT_SYMBOL(flush_signals);
2522 EXPORT_SYMBOL(force_sig);
2523 EXPORT_SYMBOL(send_sig);
2524 EXPORT_SYMBOL(send_sig_info);
2525 EXPORT_SYMBOL(sigprocmask);
2528 * System call entry points.
2532 * sys_restart_syscall - restart a system call
2534 SYSCALL_DEFINE0(restart_syscall)
2536 struct restart_block *restart = ¤t->restart_block;
2537 return restart->fn(restart);
2540 long do_no_restart_syscall(struct restart_block *param)
2545 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2547 if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2548 sigset_t newblocked;
2549 /* A set of now blocked but previously unblocked signals. */
2550 sigandnsets(&newblocked, newset, ¤t->blocked);
2551 retarget_shared_pending(tsk, &newblocked);
2553 tsk->blocked = *newset;
2554 recalc_sigpending();
2558 * set_current_blocked - change current->blocked mask
2561 * It is wrong to change ->blocked directly, this helper should be used
2562 * to ensure the process can't miss a shared signal we are going to block.
2564 void set_current_blocked(sigset_t *newset)
2566 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2567 __set_current_blocked(newset);
2570 void __set_current_blocked(const sigset_t *newset)
2572 struct task_struct *tsk = current;
2574 spin_lock_irq(&tsk->sighand->siglock);
2575 __set_task_blocked(tsk, newset);
2576 spin_unlock_irq(&tsk->sighand->siglock);
2580 * This is also useful for kernel threads that want to temporarily
2581 * (or permanently) block certain signals.
2583 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2584 * interface happily blocks "unblockable" signals like SIGKILL
2587 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2589 struct task_struct *tsk = current;
2592 /* Lockless, only current can change ->blocked, never from irq */
2594 *oldset = tsk->blocked;
2598 sigorsets(&newset, &tsk->blocked, set);
2601 sigandnsets(&newset, &tsk->blocked, set);
2610 __set_current_blocked(&newset);
2615 * sys_rt_sigprocmask - change the list of currently blocked signals
2616 * @how: whether to add, remove, or set signals
2617 * @nset: stores pending signals
2618 * @oset: previous value of signal mask if non-null
2619 * @sigsetsize: size of sigset_t type
2621 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2622 sigset_t __user *, oset, size_t, sigsetsize)
2624 sigset_t old_set, new_set;
2627 /* XXX: Don't preclude handling different sized sigset_t's. */
2628 if (sigsetsize != sizeof(sigset_t))
2631 old_set = current->blocked;
2634 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2636 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2638 error = sigprocmask(how, &new_set, NULL);
2644 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2651 #ifdef CONFIG_COMPAT
2652 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2653 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2656 sigset_t old_set = current->blocked;
2658 /* XXX: Don't preclude handling different sized sigset_t's. */
2659 if (sigsetsize != sizeof(sigset_t))
2663 compat_sigset_t new32;
2666 if (copy_from_user(&new32, nset, sizeof(compat_sigset_t)))
2669 sigset_from_compat(&new_set, &new32);
2670 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2672 error = sigprocmask(how, &new_set, NULL);
2677 compat_sigset_t old32;
2678 sigset_to_compat(&old32, &old_set);
2679 if (copy_to_user(oset, &old32, sizeof(compat_sigset_t)))
2684 return sys_rt_sigprocmask(how, (sigset_t __user *)nset,
2685 (sigset_t __user *)oset, sigsetsize);
2690 static int do_sigpending(void *set, unsigned long sigsetsize)
2692 if (sigsetsize > sizeof(sigset_t))
2695 spin_lock_irq(¤t->sighand->siglock);
2696 sigorsets(set, ¤t->pending.signal,
2697 ¤t->signal->shared_pending.signal);
2698 spin_unlock_irq(¤t->sighand->siglock);
2700 /* Outside the lock because only this thread touches it. */
2701 sigandsets(set, ¤t->blocked, set);
2706 * sys_rt_sigpending - examine a pending signal that has been raised
2708 * @uset: stores pending signals
2709 * @sigsetsize: size of sigset_t type or larger
2711 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2714 int err = do_sigpending(&set, sigsetsize);
2715 if (!err && copy_to_user(uset, &set, sigsetsize))
2720 #ifdef CONFIG_COMPAT
2721 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2722 compat_size_t, sigsetsize)
2726 int err = do_sigpending(&set, sigsetsize);
2728 compat_sigset_t set32;
2729 sigset_to_compat(&set32, &set);
2730 /* we can get here only if sigsetsize <= sizeof(set) */
2731 if (copy_to_user(uset, &set32, sigsetsize))
2736 return sys_rt_sigpending((sigset_t __user *)uset, sigsetsize);
2741 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2743 int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
2747 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2749 if (from->si_code < 0)
2750 return __copy_to_user(to, from, sizeof(siginfo_t))
2753 * If you change siginfo_t structure, please be sure
2754 * this code is fixed accordingly.
2755 * Please remember to update the signalfd_copyinfo() function
2756 * inside fs/signalfd.c too, in case siginfo_t changes.
2757 * It should never copy any pad contained in the structure
2758 * to avoid security leaks, but must copy the generic
2759 * 3 ints plus the relevant union member.
2761 err = __put_user(from->si_signo, &to->si_signo);
2762 err |= __put_user(from->si_errno, &to->si_errno);
2763 err |= __put_user((short)from->si_code, &to->si_code);
2764 switch (from->si_code & __SI_MASK) {
2766 err |= __put_user(from->si_pid, &to->si_pid);
2767 err |= __put_user(from->si_uid, &to->si_uid);
2770 err |= __put_user(from->si_tid, &to->si_tid);
2771 err |= __put_user(from->si_overrun, &to->si_overrun);
2772 err |= __put_user(from->si_ptr, &to->si_ptr);
2775 err |= __put_user(from->si_band, &to->si_band);
2776 err |= __put_user(from->si_fd, &to->si_fd);
2779 err |= __put_user(from->si_addr, &to->si_addr);
2780 #ifdef __ARCH_SI_TRAPNO
2781 err |= __put_user(from->si_trapno, &to->si_trapno);
2783 #ifdef BUS_MCEERR_AO
2785 * Other callers might not initialize the si_lsb field,
2786 * so check explicitly for the right codes here.
2788 if (from->si_signo == SIGBUS &&
2789 (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO))
2790 err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2793 if (from->si_signo == SIGSEGV && from->si_code == SEGV_BNDERR) {
2794 err |= __put_user(from->si_lower, &to->si_lower);
2795 err |= __put_user(from->si_upper, &to->si_upper);
2800 err |= __put_user(from->si_pid, &to->si_pid);
2801 err |= __put_user(from->si_uid, &to->si_uid);
2802 err |= __put_user(from->si_status, &to->si_status);
2803 err |= __put_user(from->si_utime, &to->si_utime);
2804 err |= __put_user(from->si_stime, &to->si_stime);
2806 case __SI_RT: /* This is not generated by the kernel as of now. */
2807 case __SI_MESGQ: /* But this is */
2808 err |= __put_user(from->si_pid, &to->si_pid);
2809 err |= __put_user(from->si_uid, &to->si_uid);
2810 err |= __put_user(from->si_ptr, &to->si_ptr);
2812 #ifdef __ARCH_SIGSYS
2814 err |= __put_user(from->si_call_addr, &to->si_call_addr);
2815 err |= __put_user(from->si_syscall, &to->si_syscall);
2816 err |= __put_user(from->si_arch, &to->si_arch);
2819 default: /* this is just in case for now ... */
2820 err |= __put_user(from->si_pid, &to->si_pid);
2821 err |= __put_user(from->si_uid, &to->si_uid);
2830 * do_sigtimedwait - wait for queued signals specified in @which
2831 * @which: queued signals to wait for
2832 * @info: if non-null, the signal's siginfo is returned here
2833 * @ts: upper bound on process time suspension
2835 int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
2836 const struct timespec *ts)
2838 struct task_struct *tsk = current;
2839 long timeout = MAX_SCHEDULE_TIMEOUT;
2840 sigset_t mask = *which;
2844 if (!timespec_valid(ts))
2846 timeout = timespec_to_jiffies(ts);
2848 * We can be close to the next tick, add another one
2849 * to ensure we will wait at least the time asked for.
2851 if (ts->tv_sec || ts->tv_nsec)
2856 * Invert the set of allowed signals to get those we want to block.
2858 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
2861 spin_lock_irq(&tsk->sighand->siglock);
2862 sig = dequeue_signal(tsk, &mask, info);
2863 if (!sig && timeout) {
2865 * None ready, temporarily unblock those we're interested
2866 * while we are sleeping in so that we'll be awakened when
2867 * they arrive. Unblocking is always fine, we can avoid
2868 * set_current_blocked().
2870 tsk->real_blocked = tsk->blocked;
2871 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
2872 recalc_sigpending();
2873 spin_unlock_irq(&tsk->sighand->siglock);
2875 timeout = freezable_schedule_timeout_interruptible(timeout);
2877 spin_lock_irq(&tsk->sighand->siglock);
2878 __set_task_blocked(tsk, &tsk->real_blocked);
2879 sigemptyset(&tsk->real_blocked);
2880 sig = dequeue_signal(tsk, &mask, info);
2882 spin_unlock_irq(&tsk->sighand->siglock);
2886 return timeout ? -EINTR : -EAGAIN;
2890 * sys_rt_sigtimedwait - synchronously wait for queued signals specified
2892 * @uthese: queued signals to wait for
2893 * @uinfo: if non-null, the signal's siginfo is returned here
2894 * @uts: upper bound on process time suspension
2895 * @sigsetsize: size of sigset_t type
2897 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2898 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2906 /* XXX: Don't preclude handling different sized sigset_t's. */
2907 if (sigsetsize != sizeof(sigset_t))
2910 if (copy_from_user(&these, uthese, sizeof(these)))
2914 if (copy_from_user(&ts, uts, sizeof(ts)))
2918 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
2920 if (ret > 0 && uinfo) {
2921 if (copy_siginfo_to_user(uinfo, &info))
2929 * sys_kill - send a signal to a process
2930 * @pid: the PID of the process
2931 * @sig: signal to be sent
2933 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2935 struct siginfo info;
2937 info.si_signo = sig;
2939 info.si_code = SI_USER;
2940 info.si_pid = task_tgid_vnr(current);
2941 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2943 return kill_something_info(sig, &info, pid);
2947 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2949 struct task_struct *p;
2953 p = find_task_by_vpid(pid);
2954 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2955 error = check_kill_permission(sig, info, p);
2957 * The null signal is a permissions and process existence
2958 * probe. No signal is actually delivered.
2960 if (!error && sig) {
2961 error = do_send_sig_info(sig, info, p, false);
2963 * If lock_task_sighand() failed we pretend the task
2964 * dies after receiving the signal. The window is tiny,
2965 * and the signal is private anyway.
2967 if (unlikely(error == -ESRCH))
2976 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2978 struct siginfo info = {};
2980 info.si_signo = sig;
2982 info.si_code = SI_TKILL;
2983 info.si_pid = task_tgid_vnr(current);
2984 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2986 return do_send_specific(tgid, pid, sig, &info);
2990 * sys_tgkill - send signal to one specific thread
2991 * @tgid: the thread group ID of the thread
2992 * @pid: the PID of the thread
2993 * @sig: signal to be sent
2995 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2996 * exists but it's not belonging to the target process anymore. This
2997 * method solves the problem of threads exiting and PIDs getting reused.
2999 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3001 /* This is only valid for single tasks */
3002 if (pid <= 0 || tgid <= 0)
3005 return do_tkill(tgid, pid, sig);
3009 * sys_tkill - send signal to one specific task
3010 * @pid: the PID of the task
3011 * @sig: signal to be sent
3013 * Send a signal to only one task, even if it's a CLONE_THREAD task.
3015 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
3017 /* This is only valid for single tasks */
3021 return do_tkill(0, pid, sig);
3024 static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
3026 /* Not even root can pretend to send signals from the kernel.
3027 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3029 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3030 (task_pid_vnr(current) != pid))
3033 info->si_signo = sig;
3035 /* POSIX.1b doesn't mention process groups. */
3036 return kill_proc_info(sig, info, pid);
3040 * sys_rt_sigqueueinfo - send signal information to a signal
3041 * @pid: the PID of the thread
3042 * @sig: signal to be sent
3043 * @uinfo: signal info to be sent
3045 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3046 siginfo_t __user *, uinfo)
3049 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3051 return do_rt_sigqueueinfo(pid, sig, &info);
3054 #ifdef CONFIG_COMPAT
3055 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3058 struct compat_siginfo __user *, uinfo)
3060 siginfo_t info = {};
3061 int ret = copy_siginfo_from_user32(&info, uinfo);
3064 return do_rt_sigqueueinfo(pid, sig, &info);
3068 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3070 /* This is only valid for single tasks */
3071 if (pid <= 0 || tgid <= 0)
3074 /* Not even root can pretend to send signals from the kernel.
3075 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3077 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3078 (task_pid_vnr(current) != pid))
3081 info->si_signo = sig;
3083 return do_send_specific(tgid, pid, sig, info);
3086 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3087 siginfo_t __user *, uinfo)
3091 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3094 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3097 #ifdef CONFIG_COMPAT
3098 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3102 struct compat_siginfo __user *, uinfo)
3104 siginfo_t info = {};
3106 if (copy_siginfo_from_user32(&info, uinfo))
3108 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3113 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3115 void kernel_sigaction(int sig, __sighandler_t action)
3117 spin_lock_irq(¤t->sighand->siglock);
3118 current->sighand->action[sig - 1].sa.sa_handler = action;
3119 if (action == SIG_IGN) {
3123 sigaddset(&mask, sig);
3125 flush_sigqueue_mask(&mask, ¤t->signal->shared_pending);
3126 flush_sigqueue_mask(&mask, ¤t->pending);
3127 recalc_sigpending();
3129 spin_unlock_irq(¤t->sighand->siglock);
3131 EXPORT_SYMBOL(kernel_sigaction);
3133 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3135 struct task_struct *p = current, *t;
3136 struct k_sigaction *k;
3139 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3142 k = &p->sighand->action[sig-1];
3144 spin_lock_irq(&p->sighand->siglock);
3149 sigdelsetmask(&act->sa.sa_mask,
3150 sigmask(SIGKILL) | sigmask(SIGSTOP));
3154 * "Setting a signal action to SIG_IGN for a signal that is
3155 * pending shall cause the pending signal to be discarded,
3156 * whether or not it is blocked."
3158 * "Setting a signal action to SIG_DFL for a signal that is
3159 * pending and whose default action is to ignore the signal
3160 * (for example, SIGCHLD), shall cause the pending signal to
3161 * be discarded, whether or not it is blocked"
3163 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3165 sigaddset(&mask, sig);
3166 flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3167 for_each_thread(p, t)
3168 flush_sigqueue_mask(&mask, &t->pending);
3172 spin_unlock_irq(&p->sighand->siglock);
3177 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
3182 oss.ss_sp = (void __user *) current->sas_ss_sp;
3183 oss.ss_size = current->sas_ss_size;
3184 oss.ss_flags = sas_ss_flags(sp);
3192 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
3194 error = __get_user(ss_sp, &uss->ss_sp) |
3195 __get_user(ss_flags, &uss->ss_flags) |
3196 __get_user(ss_size, &uss->ss_size);
3201 if (on_sig_stack(sp))
3206 * Note - this code used to test ss_flags incorrectly:
3207 * old code may have been written using ss_flags==0
3208 * to mean ss_flags==SS_ONSTACK (as this was the only
3209 * way that worked) - this fix preserves that older
3212 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
3215 if (ss_flags == SS_DISABLE) {
3220 if (ss_size < MINSIGSTKSZ)
3224 current->sas_ss_sp = (unsigned long) ss_sp;
3225 current->sas_ss_size = ss_size;
3231 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
3233 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
3234 __put_user(oss.ss_size, &uoss->ss_size) |
3235 __put_user(oss.ss_flags, &uoss->ss_flags);
3241 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3243 return do_sigaltstack(uss, uoss, current_user_stack_pointer());
3246 int restore_altstack(const stack_t __user *uss)
3248 int err = do_sigaltstack(uss, NULL, current_user_stack_pointer());
3249 /* squash all but EFAULT for now */
3250 return err == -EFAULT ? err : 0;
3253 int __save_altstack(stack_t __user *uss, unsigned long sp)
3255 struct task_struct *t = current;
3256 return __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3257 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3258 __put_user(t->sas_ss_size, &uss->ss_size);
3261 #ifdef CONFIG_COMPAT
3262 COMPAT_SYSCALL_DEFINE2(sigaltstack,
3263 const compat_stack_t __user *, uss_ptr,
3264 compat_stack_t __user *, uoss_ptr)
3271 compat_stack_t uss32;
3273 memset(&uss, 0, sizeof(stack_t));
3274 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3276 uss.ss_sp = compat_ptr(uss32.ss_sp);
3277 uss.ss_flags = uss32.ss_flags;
3278 uss.ss_size = uss32.ss_size;
3282 ret = do_sigaltstack((stack_t __force __user *) (uss_ptr ? &uss : NULL),
3283 (stack_t __force __user *) &uoss,
3284 compat_user_stack_pointer());
3286 if (ret >= 0 && uoss_ptr) {
3287 if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) ||
3288 __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) ||
3289 __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) ||
3290 __put_user(uoss.ss_size, &uoss_ptr->ss_size))
3296 int compat_restore_altstack(const compat_stack_t __user *uss)
3298 int err = compat_sys_sigaltstack(uss, NULL);
3299 /* squash all but -EFAULT for now */
3300 return err == -EFAULT ? err : 0;
3303 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3305 struct task_struct *t = current;
3306 return __put_user(ptr_to_compat((void __user *)t->sas_ss_sp), &uss->ss_sp) |
3307 __put_user(sas_ss_flags(sp), &uss->ss_flags) |
3308 __put_user(t->sas_ss_size, &uss->ss_size);
3312 #ifdef __ARCH_WANT_SYS_SIGPENDING
3315 * sys_sigpending - examine pending signals
3316 * @set: where mask of pending signal is returned
3318 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
3320 return sys_rt_sigpending((sigset_t __user *)set, sizeof(old_sigset_t));
3325 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
3327 * sys_sigprocmask - examine and change blocked signals
3328 * @how: whether to add, remove, or set signals
3329 * @nset: signals to add or remove (if non-null)
3330 * @oset: previous value of signal mask if non-null
3332 * Some platforms have their own version with special arguments;
3333 * others support only sys_rt_sigprocmask.
3336 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3337 old_sigset_t __user *, oset)
3339 old_sigset_t old_set, new_set;
3340 sigset_t new_blocked;
3342 old_set = current->blocked.sig[0];
3345 if (copy_from_user(&new_set, nset, sizeof(*nset)))
3348 new_blocked = current->blocked;
3352 sigaddsetmask(&new_blocked, new_set);
3355 sigdelsetmask(&new_blocked, new_set);
3358 new_blocked.sig[0] = new_set;
3364 set_current_blocked(&new_blocked);
3368 if (copy_to_user(oset, &old_set, sizeof(*oset)))
3374 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3376 #ifndef CONFIG_ODD_RT_SIGACTION
3378 * sys_rt_sigaction - alter an action taken by a process
3379 * @sig: signal to be sent
3380 * @act: new sigaction
3381 * @oact: used to save the previous sigaction
3382 * @sigsetsize: size of sigset_t type
3384 SYSCALL_DEFINE4(rt_sigaction, int, sig,
3385 const struct sigaction __user *, act,
3386 struct sigaction __user *, oact,
3389 struct k_sigaction new_sa, old_sa;
3392 /* XXX: Don't preclude handling different sized sigset_t's. */
3393 if (sigsetsize != sizeof(sigset_t))
3397 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3401 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3404 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3410 #ifdef CONFIG_COMPAT
3411 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3412 const struct compat_sigaction __user *, act,
3413 struct compat_sigaction __user *, oact,
3414 compat_size_t, sigsetsize)
3416 struct k_sigaction new_ka, old_ka;
3417 compat_sigset_t mask;
3418 #ifdef __ARCH_HAS_SA_RESTORER
3419 compat_uptr_t restorer;
3423 /* XXX: Don't preclude handling different sized sigset_t's. */
3424 if (sigsetsize != sizeof(compat_sigset_t))
3428 compat_uptr_t handler;
3429 ret = get_user(handler, &act->sa_handler);
3430 new_ka.sa.sa_handler = compat_ptr(handler);
3431 #ifdef __ARCH_HAS_SA_RESTORER
3432 ret |= get_user(restorer, &act->sa_restorer);
3433 new_ka.sa.sa_restorer = compat_ptr(restorer);
3435 ret |= copy_from_user(&mask, &act->sa_mask, sizeof(mask));
3436 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
3439 sigset_from_compat(&new_ka.sa.sa_mask, &mask);
3442 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3444 sigset_to_compat(&mask, &old_ka.sa.sa_mask);
3445 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
3447 ret |= copy_to_user(&oact->sa_mask, &mask, sizeof(mask));
3448 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3449 #ifdef __ARCH_HAS_SA_RESTORER
3450 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3451 &oact->sa_restorer);
3457 #endif /* !CONFIG_ODD_RT_SIGACTION */
3459 #ifdef CONFIG_OLD_SIGACTION
3460 SYSCALL_DEFINE3(sigaction, int, sig,
3461 const struct old_sigaction __user *, act,
3462 struct old_sigaction __user *, oact)
3464 struct k_sigaction new_ka, old_ka;
3469 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3470 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3471 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3472 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3473 __get_user(mask, &act->sa_mask))
3475 #ifdef __ARCH_HAS_KA_RESTORER
3476 new_ka.ka_restorer = NULL;
3478 siginitset(&new_ka.sa.sa_mask, mask);
3481 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3484 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3485 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3486 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3487 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3488 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3495 #ifdef CONFIG_COMPAT_OLD_SIGACTION
3496 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3497 const struct compat_old_sigaction __user *, act,
3498 struct compat_old_sigaction __user *, oact)
3500 struct k_sigaction new_ka, old_ka;
3502 compat_old_sigset_t mask;
3503 compat_uptr_t handler, restorer;
3506 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3507 __get_user(handler, &act->sa_handler) ||
3508 __get_user(restorer, &act->sa_restorer) ||
3509 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3510 __get_user(mask, &act->sa_mask))
3513 #ifdef __ARCH_HAS_KA_RESTORER
3514 new_ka.ka_restorer = NULL;
3516 new_ka.sa.sa_handler = compat_ptr(handler);
3517 new_ka.sa.sa_restorer = compat_ptr(restorer);
3518 siginitset(&new_ka.sa.sa_mask, mask);
3521 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3524 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3525 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3526 &oact->sa_handler) ||
3527 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3528 &oact->sa_restorer) ||
3529 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3530 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3537 #ifdef CONFIG_SGETMASK_SYSCALL
3540 * For backwards compatibility. Functionality superseded by sigprocmask.
3542 SYSCALL_DEFINE0(sgetmask)
3545 return current->blocked.sig[0];
3548 SYSCALL_DEFINE1(ssetmask, int, newmask)
3550 int old = current->blocked.sig[0];
3553 siginitset(&newset, newmask);
3554 set_current_blocked(&newset);
3558 #endif /* CONFIG_SGETMASK_SYSCALL */
3560 #ifdef __ARCH_WANT_SYS_SIGNAL
3562 * For backwards compatibility. Functionality superseded by sigaction.
3564 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
3566 struct k_sigaction new_sa, old_sa;
3569 new_sa.sa.sa_handler = handler;
3570 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3571 sigemptyset(&new_sa.sa.sa_mask);
3573 ret = do_sigaction(sig, &new_sa, &old_sa);
3575 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3577 #endif /* __ARCH_WANT_SYS_SIGNAL */
3579 #ifdef __ARCH_WANT_SYS_PAUSE
3581 SYSCALL_DEFINE0(pause)
3583 while (!signal_pending(current)) {
3584 __set_current_state(TASK_INTERRUPTIBLE);
3587 return -ERESTARTNOHAND;
3592 static int sigsuspend(sigset_t *set)
3594 current->saved_sigmask = current->blocked;
3595 set_current_blocked(set);
3597 __set_current_state(TASK_INTERRUPTIBLE);
3599 set_restore_sigmask();
3600 return -ERESTARTNOHAND;
3604 * sys_rt_sigsuspend - replace the signal mask for a value with the
3605 * @unewset value until a signal is received
3606 * @unewset: new signal mask value
3607 * @sigsetsize: size of sigset_t type
3609 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3613 /* XXX: Don't preclude handling different sized sigset_t's. */
3614 if (sigsetsize != sizeof(sigset_t))
3617 if (copy_from_user(&newset, unewset, sizeof(newset)))
3619 return sigsuspend(&newset);
3622 #ifdef CONFIG_COMPAT
3623 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3627 compat_sigset_t newset32;
3629 /* XXX: Don't preclude handling different sized sigset_t's. */
3630 if (sigsetsize != sizeof(sigset_t))
3633 if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t)))
3635 sigset_from_compat(&newset, &newset32);
3636 return sigsuspend(&newset);
3638 /* on little-endian bitmaps don't care about granularity */
3639 return sys_rt_sigsuspend((sigset_t __user *)unewset, sigsetsize);
3644 #ifdef CONFIG_OLD_SIGSUSPEND
3645 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3648 siginitset(&blocked, mask);
3649 return sigsuspend(&blocked);
3652 #ifdef CONFIG_OLD_SIGSUSPEND3
3653 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3656 siginitset(&blocked, mask);
3657 return sigsuspend(&blocked);
3661 __weak const char *arch_vma_name(struct vm_area_struct *vma)
3666 void __init signals_init(void)
3668 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
3671 #ifdef CONFIG_KGDB_KDB
3672 #include <linux/kdb.h>
3674 * kdb_send_sig_info - Allows kdb to send signals without exposing
3675 * signal internals. This function checks if the required locks are
3676 * available before calling the main signal code, to avoid kdb
3680 kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
3682 static struct task_struct *kdb_prev_t;
3684 if (!spin_trylock(&t->sighand->siglock)) {
3685 kdb_printf("Can't do kill command now.\n"
3686 "The sigmask lock is held somewhere else in "
3687 "kernel, try again later\n");
3690 spin_unlock(&t->sighand->siglock);
3691 new_t = kdb_prev_t != t;
3693 if (t->state != TASK_RUNNING && new_t) {
3694 kdb_printf("Process is not RUNNING, sending a signal from "
3695 "kdb risks deadlock\n"
3696 "on the run queue locks. "
3697 "The signal has _not_ been sent.\n"
3698 "Reissue the kill command if you want to risk "
3702 sig = info->si_signo;
3703 if (send_sig_info(sig, info, t))
3704 kdb_printf("Fail to deliver Signal %d to process %d.\n",
3707 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3709 #endif /* CONFIG_KGDB_KDB */