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/mm.h>
17 #include <linux/sched/user.h>
18 #include <linux/sched/debug.h>
19 #include <linux/sched/task.h>
20 #include <linux/sched/task_stack.h>
21 #include <linux/sched/cputime.h>
23 #include <linux/tty.h>
24 #include <linux/binfmts.h>
25 #include <linux/coredump.h>
26 #include <linux/security.h>
27 #include <linux/syscalls.h>
28 #include <linux/ptrace.h>
29 #include <linux/signal.h>
30 #include <linux/signalfd.h>
31 #include <linux/ratelimit.h>
32 #include <linux/tracehook.h>
33 #include <linux/capability.h>
34 #include <linux/freezer.h>
35 #include <linux/pid_namespace.h>
36 #include <linux/nsproxy.h>
37 #include <linux/user_namespace.h>
38 #include <linux/uprobes.h>
39 #include <linux/compat.h>
40 #include <linux/cn_proc.h>
41 #include <linux/compiler.h>
42 #include <linux/posix-timers.h>
43 #include <linux/livepatch.h>
45 #define CREATE_TRACE_POINTS
46 #include <trace/events/signal.h>
48 #include <asm/param.h>
49 #include <linux/uaccess.h>
50 #include <asm/unistd.h>
51 #include <asm/siginfo.h>
52 #include <asm/cacheflush.h>
53 #include "audit.h" /* audit_signal_info() */
56 * SLAB caches for signal bits.
59 static struct kmem_cache *sigqueue_cachep;
61 int print_fatal_signals __read_mostly;
63 static void __user *sig_handler(struct task_struct *t, int sig)
65 return t->sighand->action[sig - 1].sa.sa_handler;
68 static int sig_handler_ignored(void __user *handler, int sig)
70 /* Is it explicitly or implicitly ignored? */
71 return handler == SIG_IGN ||
72 (handler == SIG_DFL && sig_kernel_ignore(sig));
75 static int sig_task_ignored(struct task_struct *t, int sig, bool force)
79 handler = sig_handler(t, sig);
81 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
82 handler == SIG_DFL && !(force && sig_kernel_only(sig)))
85 return sig_handler_ignored(handler, sig);
88 static int sig_ignored(struct task_struct *t, int sig, bool force)
91 * Blocked signals are never ignored, since the
92 * signal handler may change by the time it is
95 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
99 * Tracers may want to know about even ignored signal unless it
100 * is SIGKILL which can't be reported anyway but can be ignored
101 * by SIGNAL_UNKILLABLE task.
103 if (t->ptrace && sig != SIGKILL)
106 return sig_task_ignored(t, sig, force);
110 * Re-calculate pending state from the set of locally pending
111 * signals, globally pending signals, and blocked signals.
113 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
118 switch (_NSIG_WORDS) {
120 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
121 ready |= signal->sig[i] &~ blocked->sig[i];
124 case 4: ready = signal->sig[3] &~ blocked->sig[3];
125 ready |= signal->sig[2] &~ blocked->sig[2];
126 ready |= signal->sig[1] &~ blocked->sig[1];
127 ready |= signal->sig[0] &~ blocked->sig[0];
130 case 2: ready = signal->sig[1] &~ blocked->sig[1];
131 ready |= signal->sig[0] &~ blocked->sig[0];
134 case 1: ready = signal->sig[0] &~ blocked->sig[0];
139 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
141 static int recalc_sigpending_tsk(struct task_struct *t)
143 if ((t->jobctl & JOBCTL_PENDING_MASK) ||
144 PENDING(&t->pending, &t->blocked) ||
145 PENDING(&t->signal->shared_pending, &t->blocked)) {
146 set_tsk_thread_flag(t, TIF_SIGPENDING);
150 * We must never clear the flag in another thread, or in current
151 * when it's possible the current syscall is returning -ERESTART*.
152 * So we don't clear it here, and only callers who know they should do.
158 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
159 * This is superfluous when called on current, the wakeup is a harmless no-op.
161 void recalc_sigpending_and_wake(struct task_struct *t)
163 if (recalc_sigpending_tsk(t))
164 signal_wake_up(t, 0);
167 void recalc_sigpending(void)
169 if (!recalc_sigpending_tsk(current) && !freezing(current) &&
170 !klp_patch_pending(current))
171 clear_thread_flag(TIF_SIGPENDING);
175 /* Given the mask, find the first available signal that should be serviced. */
177 #define SYNCHRONOUS_MASK \
178 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
179 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
181 int next_signal(struct sigpending *pending, sigset_t *mask)
183 unsigned long i, *s, *m, x;
186 s = pending->signal.sig;
190 * Handle the first word specially: it contains the
191 * synchronous signals that need to be dequeued first.
195 if (x & SYNCHRONOUS_MASK)
196 x &= SYNCHRONOUS_MASK;
201 switch (_NSIG_WORDS) {
203 for (i = 1; i < _NSIG_WORDS; ++i) {
207 sig = ffz(~x) + i*_NSIG_BPW + 1;
216 sig = ffz(~x) + _NSIG_BPW + 1;
227 static inline void print_dropped_signal(int sig)
229 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
231 if (!print_fatal_signals)
234 if (!__ratelimit(&ratelimit_state))
237 pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
238 current->comm, current->pid, sig);
242 * task_set_jobctl_pending - set jobctl pending bits
244 * @mask: pending bits to set
246 * Clear @mask from @task->jobctl. @mask must be subset of
247 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
248 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
249 * cleared. If @task is already being killed or exiting, this function
253 * Must be called with @task->sighand->siglock held.
256 * %true if @mask is set, %false if made noop because @task was dying.
258 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
260 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
261 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
262 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
264 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
267 if (mask & JOBCTL_STOP_SIGMASK)
268 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
270 task->jobctl |= mask;
275 * task_clear_jobctl_trapping - clear jobctl trapping bit
278 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
279 * Clear it and wake up the ptracer. Note that we don't need any further
280 * locking. @task->siglock guarantees that @task->parent points to the
284 * Must be called with @task->sighand->siglock held.
286 void task_clear_jobctl_trapping(struct task_struct *task)
288 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
289 task->jobctl &= ~JOBCTL_TRAPPING;
290 smp_mb(); /* advised by wake_up_bit() */
291 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
296 * task_clear_jobctl_pending - clear jobctl pending bits
298 * @mask: pending bits to clear
300 * Clear @mask from @task->jobctl. @mask must be subset of
301 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
302 * STOP bits are cleared together.
304 * If clearing of @mask leaves no stop or trap pending, this function calls
305 * task_clear_jobctl_trapping().
308 * Must be called with @task->sighand->siglock held.
310 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
312 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
314 if (mask & JOBCTL_STOP_PENDING)
315 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
317 task->jobctl &= ~mask;
319 if (!(task->jobctl & JOBCTL_PENDING_MASK))
320 task_clear_jobctl_trapping(task);
324 * task_participate_group_stop - participate in a group stop
325 * @task: task participating in a group stop
327 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
328 * Group stop states are cleared and the group stop count is consumed if
329 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
330 * stop, the appropriate %SIGNAL_* flags are set.
333 * Must be called with @task->sighand->siglock held.
336 * %true if group stop completion should be notified to the parent, %false
339 static bool task_participate_group_stop(struct task_struct *task)
341 struct signal_struct *sig = task->signal;
342 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
344 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
346 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
351 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
352 sig->group_stop_count--;
355 * Tell the caller to notify completion iff we are entering into a
356 * fresh group stop. Read comment in do_signal_stop() for details.
358 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
359 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
366 * allocate a new signal queue record
367 * - this may be called without locks if and only if t == current, otherwise an
368 * appropriate lock must be held to stop the target task from exiting
370 static struct sigqueue *
371 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
373 struct sigqueue *q = NULL;
374 struct user_struct *user;
377 * Protect access to @t credentials. This can go away when all
378 * callers hold rcu read lock.
381 user = get_uid(__task_cred(t)->user);
382 atomic_inc(&user->sigpending);
385 if (override_rlimit ||
386 atomic_read(&user->sigpending) <=
387 task_rlimit(t, RLIMIT_SIGPENDING)) {
388 q = kmem_cache_alloc(sigqueue_cachep, flags);
390 print_dropped_signal(sig);
393 if (unlikely(q == NULL)) {
394 atomic_dec(&user->sigpending);
397 INIT_LIST_HEAD(&q->list);
405 static void __sigqueue_free(struct sigqueue *q)
407 if (q->flags & SIGQUEUE_PREALLOC)
409 atomic_dec(&q->user->sigpending);
411 kmem_cache_free(sigqueue_cachep, q);
414 void flush_sigqueue(struct sigpending *queue)
418 sigemptyset(&queue->signal);
419 while (!list_empty(&queue->list)) {
420 q = list_entry(queue->list.next, struct sigqueue , list);
421 list_del_init(&q->list);
427 * Flush all pending signals for this kthread.
429 void flush_signals(struct task_struct *t)
433 spin_lock_irqsave(&t->sighand->siglock, flags);
434 clear_tsk_thread_flag(t, TIF_SIGPENDING);
435 flush_sigqueue(&t->pending);
436 flush_sigqueue(&t->signal->shared_pending);
437 spin_unlock_irqrestore(&t->sighand->siglock, flags);
440 #ifdef CONFIG_POSIX_TIMERS
441 static void __flush_itimer_signals(struct sigpending *pending)
443 sigset_t signal, retain;
444 struct sigqueue *q, *n;
446 signal = pending->signal;
447 sigemptyset(&retain);
449 list_for_each_entry_safe(q, n, &pending->list, list) {
450 int sig = q->info.si_signo;
452 if (likely(q->info.si_code != SI_TIMER)) {
453 sigaddset(&retain, sig);
455 sigdelset(&signal, sig);
456 list_del_init(&q->list);
461 sigorsets(&pending->signal, &signal, &retain);
464 void flush_itimer_signals(void)
466 struct task_struct *tsk = current;
469 spin_lock_irqsave(&tsk->sighand->siglock, flags);
470 __flush_itimer_signals(&tsk->pending);
471 __flush_itimer_signals(&tsk->signal->shared_pending);
472 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
476 void ignore_signals(struct task_struct *t)
480 for (i = 0; i < _NSIG; ++i)
481 t->sighand->action[i].sa.sa_handler = SIG_IGN;
487 * Flush all handlers for a task.
491 flush_signal_handlers(struct task_struct *t, int force_default)
494 struct k_sigaction *ka = &t->sighand->action[0];
495 for (i = _NSIG ; i != 0 ; i--) {
496 if (force_default || ka->sa.sa_handler != SIG_IGN)
497 ka->sa.sa_handler = SIG_DFL;
499 #ifdef __ARCH_HAS_SA_RESTORER
500 ka->sa.sa_restorer = NULL;
502 sigemptyset(&ka->sa.sa_mask);
507 int unhandled_signal(struct task_struct *tsk, int sig)
509 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
510 if (is_global_init(tsk))
512 if (handler != SIG_IGN && handler != SIG_DFL)
514 /* if ptraced, let the tracer determine */
518 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info,
521 struct sigqueue *q, *first = NULL;
524 * Collect the siginfo appropriate to this signal. Check if
525 * there is another siginfo for the same signal.
527 list_for_each_entry(q, &list->list, list) {
528 if (q->info.si_signo == sig) {
535 sigdelset(&list->signal, sig);
539 list_del_init(&first->list);
540 copy_siginfo(info, &first->info);
543 (first->flags & SIGQUEUE_PREALLOC) &&
544 (info->si_code == SI_TIMER) &&
545 (info->si_sys_private);
547 __sigqueue_free(first);
550 * Ok, it wasn't in the queue. This must be
551 * a fast-pathed signal or we must have been
552 * out of queue space. So zero out the info.
555 info->si_signo = sig;
557 info->si_code = SI_USER;
563 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
564 siginfo_t *info, bool *resched_timer)
566 int sig = next_signal(pending, mask);
569 collect_signal(sig, pending, info, resched_timer);
574 * Dequeue a signal and return the element to the caller, which is
575 * expected to free it.
577 * All callers have to hold the siglock.
579 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
581 bool resched_timer = false;
584 /* We only dequeue private signals from ourselves, we don't let
585 * signalfd steal them
587 signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
589 signr = __dequeue_signal(&tsk->signal->shared_pending,
590 mask, info, &resched_timer);
591 #ifdef CONFIG_POSIX_TIMERS
595 * itimers are process shared and we restart periodic
596 * itimers in the signal delivery path to prevent DoS
597 * attacks in the high resolution timer case. This is
598 * compliant with the old way of self-restarting
599 * itimers, as the SIGALRM is a legacy signal and only
600 * queued once. Changing the restart behaviour to
601 * restart the timer in the signal dequeue path is
602 * reducing the timer noise on heavy loaded !highres
605 if (unlikely(signr == SIGALRM)) {
606 struct hrtimer *tmr = &tsk->signal->real_timer;
608 if (!hrtimer_is_queued(tmr) &&
609 tsk->signal->it_real_incr != 0) {
610 hrtimer_forward(tmr, tmr->base->get_time(),
611 tsk->signal->it_real_incr);
612 hrtimer_restart(tmr);
622 if (unlikely(sig_kernel_stop(signr))) {
624 * Set a marker that we have dequeued a stop signal. Our
625 * caller might release the siglock and then the pending
626 * stop signal it is about to process is no longer in the
627 * pending bitmasks, but must still be cleared by a SIGCONT
628 * (and overruled by a SIGKILL). So those cases clear this
629 * shared flag after we've set it. Note that this flag may
630 * remain set after the signal we return is ignored or
631 * handled. That doesn't matter because its only purpose
632 * is to alert stop-signal processing code when another
633 * processor has come along and cleared the flag.
635 current->jobctl |= JOBCTL_STOP_DEQUEUED;
637 #ifdef CONFIG_POSIX_TIMERS
640 * Release the siglock to ensure proper locking order
641 * of timer locks outside of siglocks. Note, we leave
642 * irqs disabled here, since the posix-timers code is
643 * about to disable them again anyway.
645 spin_unlock(&tsk->sighand->siglock);
646 posixtimer_rearm(info);
647 spin_lock(&tsk->sighand->siglock);
649 /* Don't expose the si_sys_private value to userspace */
650 info->si_sys_private = 0;
657 * Tell a process that it has a new active signal..
659 * NOTE! we rely on the previous spin_lock to
660 * lock interrupts for us! We can only be called with
661 * "siglock" held, and the local interrupt must
662 * have been disabled when that got acquired!
664 * No need to set need_resched since signal event passing
665 * goes through ->blocked
667 void signal_wake_up_state(struct task_struct *t, unsigned int state)
669 set_tsk_thread_flag(t, TIF_SIGPENDING);
671 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
672 * case. We don't check t->state here because there is a race with it
673 * executing another processor and just now entering stopped state.
674 * By using wake_up_state, we ensure the process will wake up and
675 * handle its death signal.
677 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
682 * Remove signals in mask from the pending set and queue.
683 * Returns 1 if any signals were found.
685 * All callers must be holding the siglock.
687 static int flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
689 struct sigqueue *q, *n;
692 sigandsets(&m, mask, &s->signal);
693 if (sigisemptyset(&m))
696 sigandnsets(&s->signal, &s->signal, mask);
697 list_for_each_entry_safe(q, n, &s->list, list) {
698 if (sigismember(mask, q->info.si_signo)) {
699 list_del_init(&q->list);
706 static inline int is_si_special(const struct siginfo *info)
708 return info <= SEND_SIG_FORCED;
711 static inline bool si_fromuser(const struct siginfo *info)
713 return info == SEND_SIG_NOINFO ||
714 (!is_si_special(info) && SI_FROMUSER(info));
718 * called with RCU read lock from check_kill_permission()
720 static int kill_ok_by_cred(struct task_struct *t)
722 const struct cred *cred = current_cred();
723 const struct cred *tcred = __task_cred(t);
725 if (uid_eq(cred->euid, tcred->suid) ||
726 uid_eq(cred->euid, tcred->uid) ||
727 uid_eq(cred->uid, tcred->suid) ||
728 uid_eq(cred->uid, tcred->uid))
731 if (ns_capable(tcred->user_ns, CAP_KILL))
738 * Bad permissions for sending the signal
739 * - the caller must hold the RCU read lock
741 static int check_kill_permission(int sig, struct siginfo *info,
742 struct task_struct *t)
747 if (!valid_signal(sig))
750 if (!si_fromuser(info))
753 error = audit_signal_info(sig, t); /* Let audit system see the signal */
757 if (!same_thread_group(current, t) &&
758 !kill_ok_by_cred(t)) {
761 sid = task_session(t);
763 * We don't return the error if sid == NULL. The
764 * task was unhashed, the caller must notice this.
766 if (!sid || sid == task_session(current))
773 return security_task_kill(t, info, sig, NULL);
777 * ptrace_trap_notify - schedule trap to notify ptracer
778 * @t: tracee wanting to notify tracer
780 * This function schedules sticky ptrace trap which is cleared on the next
781 * TRAP_STOP to notify ptracer of an event. @t must have been seized by
784 * If @t is running, STOP trap will be taken. If trapped for STOP and
785 * ptracer is listening for events, tracee is woken up so that it can
786 * re-trap for the new event. If trapped otherwise, STOP trap will be
787 * eventually taken without returning to userland after the existing traps
788 * are finished by PTRACE_CONT.
791 * Must be called with @task->sighand->siglock held.
793 static void ptrace_trap_notify(struct task_struct *t)
795 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
796 assert_spin_locked(&t->sighand->siglock);
798 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
799 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
803 * Handle magic process-wide effects of stop/continue signals. Unlike
804 * the signal actions, these happen immediately at signal-generation
805 * time regardless of blocking, ignoring, or handling. This does the
806 * actual continuing for SIGCONT, but not the actual stopping for stop
807 * signals. The process stop is done as a signal action for SIG_DFL.
809 * Returns true if the signal should be actually delivered, otherwise
810 * it should be dropped.
812 static bool prepare_signal(int sig, struct task_struct *p, bool force)
814 struct signal_struct *signal = p->signal;
815 struct task_struct *t;
818 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
819 if (!(signal->flags & SIGNAL_GROUP_EXIT))
820 return sig == SIGKILL;
822 * The process is in the middle of dying, nothing to do.
824 } else if (sig_kernel_stop(sig)) {
826 * This is a stop signal. Remove SIGCONT from all queues.
828 siginitset(&flush, sigmask(SIGCONT));
829 flush_sigqueue_mask(&flush, &signal->shared_pending);
830 for_each_thread(p, t)
831 flush_sigqueue_mask(&flush, &t->pending);
832 } else if (sig == SIGCONT) {
835 * Remove all stop signals from all queues, wake all threads.
837 siginitset(&flush, SIG_KERNEL_STOP_MASK);
838 flush_sigqueue_mask(&flush, &signal->shared_pending);
839 for_each_thread(p, t) {
840 flush_sigqueue_mask(&flush, &t->pending);
841 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
842 if (likely(!(t->ptrace & PT_SEIZED)))
843 wake_up_state(t, __TASK_STOPPED);
845 ptrace_trap_notify(t);
849 * Notify the parent with CLD_CONTINUED if we were stopped.
851 * If we were in the middle of a group stop, we pretend it
852 * was already finished, and then continued. Since SIGCHLD
853 * doesn't queue we report only CLD_STOPPED, as if the next
854 * CLD_CONTINUED was dropped.
857 if (signal->flags & SIGNAL_STOP_STOPPED)
858 why |= SIGNAL_CLD_CONTINUED;
859 else if (signal->group_stop_count)
860 why |= SIGNAL_CLD_STOPPED;
864 * The first thread which returns from do_signal_stop()
865 * will take ->siglock, notice SIGNAL_CLD_MASK, and
866 * notify its parent. See get_signal_to_deliver().
868 signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
869 signal->group_stop_count = 0;
870 signal->group_exit_code = 0;
874 return !sig_ignored(p, sig, force);
878 * Test if P wants to take SIG. After we've checked all threads with this,
879 * it's equivalent to finding no threads not blocking SIG. Any threads not
880 * blocking SIG were ruled out because they are not running and already
881 * have pending signals. Such threads will dequeue from the shared queue
882 * as soon as they're available, so putting the signal on the shared queue
883 * will be equivalent to sending it to one such thread.
885 static inline int wants_signal(int sig, struct task_struct *p)
887 if (sigismember(&p->blocked, sig))
889 if (p->flags & PF_EXITING)
893 if (task_is_stopped_or_traced(p))
895 return task_curr(p) || !signal_pending(p);
898 static void complete_signal(int sig, struct task_struct *p, int group)
900 struct signal_struct *signal = p->signal;
901 struct task_struct *t;
904 * Now find a thread we can wake up to take the signal off the queue.
906 * If the main thread wants the signal, it gets first crack.
907 * Probably the least surprising to the average bear.
909 if (wants_signal(sig, p))
911 else if (!group || thread_group_empty(p))
913 * There is just one thread and it does not need to be woken.
914 * It will dequeue unblocked signals before it runs again.
919 * Otherwise try to find a suitable thread.
921 t = signal->curr_target;
922 while (!wants_signal(sig, t)) {
924 if (t == signal->curr_target)
926 * No thread needs to be woken.
927 * Any eligible threads will see
928 * the signal in the queue soon.
932 signal->curr_target = t;
936 * Found a killable thread. If the signal will be fatal,
937 * then start taking the whole group down immediately.
939 if (sig_fatal(p, sig) &&
940 !(signal->flags & SIGNAL_GROUP_EXIT) &&
941 !sigismember(&t->real_blocked, sig) &&
942 (sig == SIGKILL || !p->ptrace)) {
944 * This signal will be fatal to the whole group.
946 if (!sig_kernel_coredump(sig)) {
948 * Start a group exit and wake everybody up.
949 * This way we don't have other threads
950 * running and doing things after a slower
951 * thread has the fatal signal pending.
953 signal->flags = SIGNAL_GROUP_EXIT;
954 signal->group_exit_code = sig;
955 signal->group_stop_count = 0;
958 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
959 sigaddset(&t->pending.signal, SIGKILL);
960 signal_wake_up(t, 1);
961 } while_each_thread(p, t);
967 * The signal is already in the shared-pending queue.
968 * Tell the chosen thread to wake up and dequeue it.
970 signal_wake_up(t, sig == SIGKILL);
974 static inline int legacy_queue(struct sigpending *signals, int sig)
976 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
979 #ifdef CONFIG_USER_NS
980 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
982 if (current_user_ns() == task_cred_xxx(t, user_ns))
985 if (SI_FROMKERNEL(info))
989 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
990 make_kuid(current_user_ns(), info->si_uid));
994 static inline void userns_fixup_signal_uid(struct siginfo *info, struct task_struct *t)
1000 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
1001 int group, int from_ancestor_ns)
1003 struct sigpending *pending;
1005 int override_rlimit;
1006 int ret = 0, result;
1008 assert_spin_locked(&t->sighand->siglock);
1010 result = TRACE_SIGNAL_IGNORED;
1011 if (!prepare_signal(sig, t,
1012 from_ancestor_ns || (info == SEND_SIG_FORCED)))
1015 pending = group ? &t->signal->shared_pending : &t->pending;
1017 * Short-circuit ignored signals and support queuing
1018 * exactly one non-rt signal, so that we can get more
1019 * detailed information about the cause of the signal.
1021 result = TRACE_SIGNAL_ALREADY_PENDING;
1022 if (legacy_queue(pending, sig))
1025 result = TRACE_SIGNAL_DELIVERED;
1027 * fast-pathed signals for kernel-internal things like SIGSTOP
1030 if (info == SEND_SIG_FORCED)
1034 * Real-time signals must be queued if sent by sigqueue, or
1035 * some other real-time mechanism. It is implementation
1036 * defined whether kill() does so. We attempt to do so, on
1037 * the principle of least surprise, but since kill is not
1038 * allowed to fail with EAGAIN when low on memory we just
1039 * make sure at least one signal gets delivered and don't
1040 * pass on the info struct.
1043 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1045 override_rlimit = 0;
1047 q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit);
1049 list_add_tail(&q->list, &pending->list);
1050 switch ((unsigned long) info) {
1051 case (unsigned long) SEND_SIG_NOINFO:
1052 clear_siginfo(&q->info);
1053 q->info.si_signo = sig;
1054 q->info.si_errno = 0;
1055 q->info.si_code = SI_USER;
1056 q->info.si_pid = task_tgid_nr_ns(current,
1057 task_active_pid_ns(t));
1058 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1060 case (unsigned long) SEND_SIG_PRIV:
1061 clear_siginfo(&q->info);
1062 q->info.si_signo = sig;
1063 q->info.si_errno = 0;
1064 q->info.si_code = SI_KERNEL;
1069 copy_siginfo(&q->info, info);
1070 if (from_ancestor_ns)
1075 userns_fixup_signal_uid(&q->info, t);
1077 } else if (!is_si_special(info)) {
1078 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1080 * Queue overflow, abort. We may abort if the
1081 * signal was rt and sent by user using something
1082 * other than kill().
1084 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1089 * This is a silent loss of information. We still
1090 * send the signal, but the *info bits are lost.
1092 result = TRACE_SIGNAL_LOSE_INFO;
1097 signalfd_notify(t, sig);
1098 sigaddset(&pending->signal, sig);
1099 complete_signal(sig, t, group);
1101 trace_signal_generate(sig, info, t, group, result);
1105 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
1108 int from_ancestor_ns = 0;
1110 #ifdef CONFIG_PID_NS
1111 from_ancestor_ns = si_fromuser(info) &&
1112 !task_pid_nr_ns(current, task_active_pid_ns(t));
1115 return __send_signal(sig, info, t, group, from_ancestor_ns);
1118 static void print_fatal_signal(int signr)
1120 struct pt_regs *regs = signal_pt_regs();
1121 pr_info("potentially unexpected fatal signal %d.\n", signr);
1123 #if defined(__i386__) && !defined(__arch_um__)
1124 pr_info("code at %08lx: ", regs->ip);
1127 for (i = 0; i < 16; i++) {
1130 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1132 pr_cont("%02x ", insn);
1142 static int __init setup_print_fatal_signals(char *str)
1144 get_option (&str, &print_fatal_signals);
1149 __setup("print-fatal-signals=", setup_print_fatal_signals);
1152 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1154 return send_signal(sig, info, p, 1);
1158 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1160 return send_signal(sig, info, t, 0);
1163 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1166 unsigned long flags;
1169 if (lock_task_sighand(p, &flags)) {
1170 ret = send_signal(sig, info, p, group);
1171 unlock_task_sighand(p, &flags);
1178 * Force a signal that the process can't ignore: if necessary
1179 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1181 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1182 * since we do not want to have a signal handler that was blocked
1183 * be invoked when user space had explicitly blocked it.
1185 * We don't want to have recursive SIGSEGV's etc, for example,
1186 * that is why we also clear SIGNAL_UNKILLABLE.
1189 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1191 unsigned long int flags;
1192 int ret, blocked, ignored;
1193 struct k_sigaction *action;
1195 spin_lock_irqsave(&t->sighand->siglock, flags);
1196 action = &t->sighand->action[sig-1];
1197 ignored = action->sa.sa_handler == SIG_IGN;
1198 blocked = sigismember(&t->blocked, sig);
1199 if (blocked || ignored) {
1200 action->sa.sa_handler = SIG_DFL;
1202 sigdelset(&t->blocked, sig);
1203 recalc_sigpending_and_wake(t);
1207 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
1208 * debugging to leave init killable.
1210 if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
1211 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1212 ret = specific_send_sig_info(sig, info, t);
1213 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1219 * Nuke all other threads in the group.
1221 int zap_other_threads(struct task_struct *p)
1223 struct task_struct *t = p;
1226 p->signal->group_stop_count = 0;
1228 while_each_thread(p, t) {
1229 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1232 /* Don't bother with already dead threads */
1235 sigaddset(&t->pending.signal, SIGKILL);
1236 signal_wake_up(t, 1);
1242 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1243 unsigned long *flags)
1245 struct sighand_struct *sighand;
1249 * Disable interrupts early to avoid deadlocks.
1250 * See rcu_read_unlock() comment header for details.
1252 local_irq_save(*flags);
1254 sighand = rcu_dereference(tsk->sighand);
1255 if (unlikely(sighand == NULL)) {
1257 local_irq_restore(*flags);
1261 * This sighand can be already freed and even reused, but
1262 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1263 * initializes ->siglock: this slab can't go away, it has
1264 * the same object type, ->siglock can't be reinitialized.
1266 * We need to ensure that tsk->sighand is still the same
1267 * after we take the lock, we can race with de_thread() or
1268 * __exit_signal(). In the latter case the next iteration
1269 * must see ->sighand == NULL.
1271 spin_lock(&sighand->siglock);
1272 if (likely(sighand == tsk->sighand)) {
1276 spin_unlock(&sighand->siglock);
1278 local_irq_restore(*flags);
1285 * send signal info to all the members of a group
1287 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1292 ret = check_kill_permission(sig, info, p);
1296 ret = do_send_sig_info(sig, info, p, true);
1302 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1303 * control characters do (^C, ^Z etc)
1304 * - the caller must hold at least a readlock on tasklist_lock
1306 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1308 struct task_struct *p = NULL;
1309 int retval, success;
1313 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1314 int err = group_send_sig_info(sig, info, p);
1317 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1318 return success ? 0 : retval;
1321 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1324 struct task_struct *p;
1328 p = pid_task(pid, PIDTYPE_PID);
1330 error = group_send_sig_info(sig, info, p);
1332 if (likely(!p || error != -ESRCH))
1336 * The task was unhashed in between, try again. If it
1337 * is dead, pid_task() will return NULL, if we race with
1338 * de_thread() it will find the new leader.
1343 static int kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1347 error = kill_pid_info(sig, info, find_vpid(pid));
1352 static int kill_as_cred_perm(const struct cred *cred,
1353 struct task_struct *target)
1355 const struct cred *pcred = __task_cred(target);
1356 if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) &&
1357 !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid))
1362 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1363 int kill_pid_info_as_cred(int sig, struct siginfo *info, struct pid *pid,
1364 const struct cred *cred)
1367 struct task_struct *p;
1368 unsigned long flags;
1370 if (!valid_signal(sig))
1374 p = pid_task(pid, PIDTYPE_PID);
1379 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1383 ret = security_task_kill(p, info, sig, cred);
1388 if (lock_task_sighand(p, &flags)) {
1389 ret = __send_signal(sig, info, p, 1, 0);
1390 unlock_task_sighand(p, &flags);
1398 EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1401 * kill_something_info() interprets pid in interesting ways just like kill(2).
1403 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1404 * is probably wrong. Should make it like BSD or SYSV.
1407 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1413 ret = kill_pid_info(sig, info, find_vpid(pid));
1418 /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */
1422 read_lock(&tasklist_lock);
1424 ret = __kill_pgrp_info(sig, info,
1425 pid ? find_vpid(-pid) : task_pgrp(current));
1427 int retval = 0, count = 0;
1428 struct task_struct * p;
1430 for_each_process(p) {
1431 if (task_pid_vnr(p) > 1 &&
1432 !same_thread_group(p, current)) {
1433 int err = group_send_sig_info(sig, info, p);
1439 ret = count ? retval : -ESRCH;
1441 read_unlock(&tasklist_lock);
1447 * These are for backward compatibility with the rest of the kernel source.
1450 int send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1453 * Make sure legacy kernel users don't send in bad values
1454 * (normal paths check this in check_kill_permission).
1456 if (!valid_signal(sig))
1459 return do_send_sig_info(sig, info, p, false);
1462 #define __si_special(priv) \
1463 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1466 send_sig(int sig, struct task_struct *p, int priv)
1468 return send_sig_info(sig, __si_special(priv), p);
1472 force_sig(int sig, struct task_struct *p)
1474 force_sig_info(sig, SEND_SIG_PRIV, p);
1478 * When things go south during signal handling, we
1479 * will force a SIGSEGV. And if the signal that caused
1480 * the problem was already a SIGSEGV, we'll want to
1481 * make sure we don't even try to deliver the signal..
1484 force_sigsegv(int sig, struct task_struct *p)
1486 if (sig == SIGSEGV) {
1487 unsigned long flags;
1488 spin_lock_irqsave(&p->sighand->siglock, flags);
1489 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1490 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1492 force_sig(SIGSEGV, p);
1496 int force_sig_fault(int sig, int code, void __user *addr
1497 ___ARCH_SI_TRAPNO(int trapno)
1498 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1499 , struct task_struct *t)
1501 struct siginfo info;
1503 clear_siginfo(&info);
1504 info.si_signo = sig;
1506 info.si_code = code;
1507 info.si_addr = addr;
1508 #ifdef __ARCH_SI_TRAPNO
1509 info.si_trapno = trapno;
1513 info.si_flags = flags;
1516 return force_sig_info(info.si_signo, &info, t);
1519 int send_sig_fault(int sig, int code, void __user *addr
1520 ___ARCH_SI_TRAPNO(int trapno)
1521 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1522 , struct task_struct *t)
1524 struct siginfo info;
1526 clear_siginfo(&info);
1527 info.si_signo = sig;
1529 info.si_code = code;
1530 info.si_addr = addr;
1531 #ifdef __ARCH_SI_TRAPNO
1532 info.si_trapno = trapno;
1536 info.si_flags = flags;
1539 return send_sig_info(info.si_signo, &info, t);
1542 int force_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1544 struct siginfo info;
1546 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1547 clear_siginfo(&info);
1548 info.si_signo = SIGBUS;
1550 info.si_code = code;
1551 info.si_addr = addr;
1552 info.si_addr_lsb = lsb;
1553 return force_sig_info(info.si_signo, &info, t);
1556 int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1558 struct siginfo info;
1560 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1561 clear_siginfo(&info);
1562 info.si_signo = SIGBUS;
1564 info.si_code = code;
1565 info.si_addr = addr;
1566 info.si_addr_lsb = lsb;
1567 return send_sig_info(info.si_signo, &info, t);
1569 EXPORT_SYMBOL(send_sig_mceerr);
1571 int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
1573 struct siginfo info;
1575 clear_siginfo(&info);
1576 info.si_signo = SIGSEGV;
1578 info.si_code = SEGV_BNDERR;
1579 info.si_addr = addr;
1580 info.si_lower = lower;
1581 info.si_upper = upper;
1582 return force_sig_info(info.si_signo, &info, current);
1586 int force_sig_pkuerr(void __user *addr, u32 pkey)
1588 struct siginfo info;
1590 clear_siginfo(&info);
1591 info.si_signo = SIGSEGV;
1593 info.si_code = SEGV_PKUERR;
1594 info.si_addr = addr;
1595 info.si_pkey = pkey;
1596 return force_sig_info(info.si_signo, &info, current);
1600 /* For the crazy architectures that include trap information in
1601 * the errno field, instead of an actual errno value.
1603 int force_sig_ptrace_errno_trap(int errno, void __user *addr)
1605 struct siginfo info;
1607 clear_siginfo(&info);
1608 info.si_signo = SIGTRAP;
1609 info.si_errno = errno;
1610 info.si_code = TRAP_HWBKPT;
1611 info.si_addr = addr;
1612 return force_sig_info(info.si_signo, &info, current);
1615 int kill_pgrp(struct pid *pid, int sig, int priv)
1619 read_lock(&tasklist_lock);
1620 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1621 read_unlock(&tasklist_lock);
1625 EXPORT_SYMBOL(kill_pgrp);
1627 int kill_pid(struct pid *pid, int sig, int priv)
1629 return kill_pid_info(sig, __si_special(priv), pid);
1631 EXPORT_SYMBOL(kill_pid);
1634 * These functions support sending signals using preallocated sigqueue
1635 * structures. This is needed "because realtime applications cannot
1636 * afford to lose notifications of asynchronous events, like timer
1637 * expirations or I/O completions". In the case of POSIX Timers
1638 * we allocate the sigqueue structure from the timer_create. If this
1639 * allocation fails we are able to report the failure to the application
1640 * with an EAGAIN error.
1642 struct sigqueue *sigqueue_alloc(void)
1644 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1647 q->flags |= SIGQUEUE_PREALLOC;
1652 void sigqueue_free(struct sigqueue *q)
1654 unsigned long flags;
1655 spinlock_t *lock = ¤t->sighand->siglock;
1657 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1659 * We must hold ->siglock while testing q->list
1660 * to serialize with collect_signal() or with
1661 * __exit_signal()->flush_sigqueue().
1663 spin_lock_irqsave(lock, flags);
1664 q->flags &= ~SIGQUEUE_PREALLOC;
1666 * If it is queued it will be freed when dequeued,
1667 * like the "regular" sigqueue.
1669 if (!list_empty(&q->list))
1671 spin_unlock_irqrestore(lock, flags);
1677 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1679 int sig = q->info.si_signo;
1680 struct sigpending *pending;
1681 unsigned long flags;
1684 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1687 if (!likely(lock_task_sighand(t, &flags)))
1690 ret = 1; /* the signal is ignored */
1691 result = TRACE_SIGNAL_IGNORED;
1692 if (!prepare_signal(sig, t, false))
1696 if (unlikely(!list_empty(&q->list))) {
1698 * If an SI_TIMER entry is already queue just increment
1699 * the overrun count.
1701 BUG_ON(q->info.si_code != SI_TIMER);
1702 q->info.si_overrun++;
1703 result = TRACE_SIGNAL_ALREADY_PENDING;
1706 q->info.si_overrun = 0;
1708 signalfd_notify(t, sig);
1709 pending = group ? &t->signal->shared_pending : &t->pending;
1710 list_add_tail(&q->list, &pending->list);
1711 sigaddset(&pending->signal, sig);
1712 complete_signal(sig, t, group);
1713 result = TRACE_SIGNAL_DELIVERED;
1715 trace_signal_generate(sig, &q->info, t, group, result);
1716 unlock_task_sighand(t, &flags);
1722 * Let a parent know about the death of a child.
1723 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1725 * Returns true if our parent ignored us and so we've switched to
1728 bool do_notify_parent(struct task_struct *tsk, int sig)
1730 struct siginfo info;
1731 unsigned long flags;
1732 struct sighand_struct *psig;
1733 bool autoreap = false;
1738 /* do_notify_parent_cldstop should have been called instead. */
1739 BUG_ON(task_is_stopped_or_traced(tsk));
1741 BUG_ON(!tsk->ptrace &&
1742 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1744 if (sig != SIGCHLD) {
1746 * This is only possible if parent == real_parent.
1747 * Check if it has changed security domain.
1749 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1753 clear_siginfo(&info);
1754 info.si_signo = sig;
1757 * We are under tasklist_lock here so our parent is tied to
1758 * us and cannot change.
1760 * task_active_pid_ns will always return the same pid namespace
1761 * until a task passes through release_task.
1763 * write_lock() currently calls preempt_disable() which is the
1764 * same as rcu_read_lock(), but according to Oleg, this is not
1765 * correct to rely on this
1768 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1769 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1773 task_cputime(tsk, &utime, &stime);
1774 info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
1775 info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
1777 info.si_status = tsk->exit_code & 0x7f;
1778 if (tsk->exit_code & 0x80)
1779 info.si_code = CLD_DUMPED;
1780 else if (tsk->exit_code & 0x7f)
1781 info.si_code = CLD_KILLED;
1783 info.si_code = CLD_EXITED;
1784 info.si_status = tsk->exit_code >> 8;
1787 psig = tsk->parent->sighand;
1788 spin_lock_irqsave(&psig->siglock, flags);
1789 if (!tsk->ptrace && sig == SIGCHLD &&
1790 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1791 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1793 * We are exiting and our parent doesn't care. POSIX.1
1794 * defines special semantics for setting SIGCHLD to SIG_IGN
1795 * or setting the SA_NOCLDWAIT flag: we should be reaped
1796 * automatically and not left for our parent's wait4 call.
1797 * Rather than having the parent do it as a magic kind of
1798 * signal handler, we just set this to tell do_exit that we
1799 * can be cleaned up without becoming a zombie. Note that
1800 * we still call __wake_up_parent in this case, because a
1801 * blocked sys_wait4 might now return -ECHILD.
1803 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1804 * is implementation-defined: we do (if you don't want
1805 * it, just use SIG_IGN instead).
1808 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1811 if (valid_signal(sig) && sig)
1812 __group_send_sig_info(sig, &info, tsk->parent);
1813 __wake_up_parent(tsk, tsk->parent);
1814 spin_unlock_irqrestore(&psig->siglock, flags);
1820 * do_notify_parent_cldstop - notify parent of stopped/continued state change
1821 * @tsk: task reporting the state change
1822 * @for_ptracer: the notification is for ptracer
1823 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1825 * Notify @tsk's parent that the stopped/continued state has changed. If
1826 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1827 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1830 * Must be called with tasklist_lock at least read locked.
1832 static void do_notify_parent_cldstop(struct task_struct *tsk,
1833 bool for_ptracer, int why)
1835 struct siginfo info;
1836 unsigned long flags;
1837 struct task_struct *parent;
1838 struct sighand_struct *sighand;
1842 parent = tsk->parent;
1844 tsk = tsk->group_leader;
1845 parent = tsk->real_parent;
1848 clear_siginfo(&info);
1849 info.si_signo = SIGCHLD;
1852 * see comment in do_notify_parent() about the following 4 lines
1855 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1856 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1859 task_cputime(tsk, &utime, &stime);
1860 info.si_utime = nsec_to_clock_t(utime);
1861 info.si_stime = nsec_to_clock_t(stime);
1866 info.si_status = SIGCONT;
1869 info.si_status = tsk->signal->group_exit_code & 0x7f;
1872 info.si_status = tsk->exit_code & 0x7f;
1878 sighand = parent->sighand;
1879 spin_lock_irqsave(&sighand->siglock, flags);
1880 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1881 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1882 __group_send_sig_info(SIGCHLD, &info, parent);
1884 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1886 __wake_up_parent(tsk, parent);
1887 spin_unlock_irqrestore(&sighand->siglock, flags);
1890 static inline int may_ptrace_stop(void)
1892 if (!likely(current->ptrace))
1895 * Are we in the middle of do_coredump?
1896 * If so and our tracer is also part of the coredump stopping
1897 * is a deadlock situation, and pointless because our tracer
1898 * is dead so don't allow us to stop.
1899 * If SIGKILL was already sent before the caller unlocked
1900 * ->siglock we must see ->core_state != NULL. Otherwise it
1901 * is safe to enter schedule().
1903 * This is almost outdated, a task with the pending SIGKILL can't
1904 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1905 * after SIGKILL was already dequeued.
1907 if (unlikely(current->mm->core_state) &&
1908 unlikely(current->mm == current->parent->mm))
1915 * Return non-zero if there is a SIGKILL that should be waking us up.
1916 * Called with the siglock held.
1918 static int sigkill_pending(struct task_struct *tsk)
1920 return sigismember(&tsk->pending.signal, SIGKILL) ||
1921 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1925 * This must be called with current->sighand->siglock held.
1927 * This should be the path for all ptrace stops.
1928 * We always set current->last_siginfo while stopped here.
1929 * That makes it a way to test a stopped process for
1930 * being ptrace-stopped vs being job-control-stopped.
1932 * If we actually decide not to stop at all because the tracer
1933 * is gone, we keep current->exit_code unless clear_code.
1935 static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t *info)
1936 __releases(¤t->sighand->siglock)
1937 __acquires(¤t->sighand->siglock)
1939 bool gstop_done = false;
1941 if (arch_ptrace_stop_needed(exit_code, info)) {
1943 * The arch code has something special to do before a
1944 * ptrace stop. This is allowed to block, e.g. for faults
1945 * on user stack pages. We can't keep the siglock while
1946 * calling arch_ptrace_stop, so we must release it now.
1947 * To preserve proper semantics, we must do this before
1948 * any signal bookkeeping like checking group_stop_count.
1949 * Meanwhile, a SIGKILL could come in before we retake the
1950 * siglock. That must prevent us from sleeping in TASK_TRACED.
1951 * So after regaining the lock, we must check for SIGKILL.
1953 spin_unlock_irq(¤t->sighand->siglock);
1954 arch_ptrace_stop(exit_code, info);
1955 spin_lock_irq(¤t->sighand->siglock);
1956 if (sigkill_pending(current))
1960 set_special_state(TASK_TRACED);
1963 * We're committing to trapping. TRACED should be visible before
1964 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
1965 * Also, transition to TRACED and updates to ->jobctl should be
1966 * atomic with respect to siglock and should be done after the arch
1967 * hook as siglock is released and regrabbed across it.
1972 * [L] wait_on_bit(JOBCTL_TRAPPING) [S] set_special_state(TRACED)
1974 * set_current_state() smp_wmb();
1976 * wait_task_stopped()
1977 * task_stopped_code()
1978 * [L] task_is_traced() [S] task_clear_jobctl_trapping();
1982 current->last_siginfo = info;
1983 current->exit_code = exit_code;
1986 * If @why is CLD_STOPPED, we're trapping to participate in a group
1987 * stop. Do the bookkeeping. Note that if SIGCONT was delievered
1988 * across siglock relocks since INTERRUPT was scheduled, PENDING
1989 * could be clear now. We act as if SIGCONT is received after
1990 * TASK_TRACED is entered - ignore it.
1992 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
1993 gstop_done = task_participate_group_stop(current);
1995 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
1996 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
1997 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
1998 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
2000 /* entering a trap, clear TRAPPING */
2001 task_clear_jobctl_trapping(current);
2003 spin_unlock_irq(¤t->sighand->siglock);
2004 read_lock(&tasklist_lock);
2005 if (may_ptrace_stop()) {
2007 * Notify parents of the stop.
2009 * While ptraced, there are two parents - the ptracer and
2010 * the real_parent of the group_leader. The ptracer should
2011 * know about every stop while the real parent is only
2012 * interested in the completion of group stop. The states
2013 * for the two don't interact with each other. Notify
2014 * separately unless they're gonna be duplicates.
2016 do_notify_parent_cldstop(current, true, why);
2017 if (gstop_done && ptrace_reparented(current))
2018 do_notify_parent_cldstop(current, false, why);
2021 * Don't want to allow preemption here, because
2022 * sys_ptrace() needs this task to be inactive.
2024 * XXX: implement read_unlock_no_resched().
2027 read_unlock(&tasklist_lock);
2028 preempt_enable_no_resched();
2029 freezable_schedule();
2032 * By the time we got the lock, our tracer went away.
2033 * Don't drop the lock yet, another tracer may come.
2035 * If @gstop_done, the ptracer went away between group stop
2036 * completion and here. During detach, it would have set
2037 * JOBCTL_STOP_PENDING on us and we'll re-enter
2038 * TASK_STOPPED in do_signal_stop() on return, so notifying
2039 * the real parent of the group stop completion is enough.
2042 do_notify_parent_cldstop(current, false, why);
2044 /* tasklist protects us from ptrace_freeze_traced() */
2045 __set_current_state(TASK_RUNNING);
2047 current->exit_code = 0;
2048 read_unlock(&tasklist_lock);
2052 * We are back. Now reacquire the siglock before touching
2053 * last_siginfo, so that we are sure to have synchronized with
2054 * any signal-sending on another CPU that wants to examine it.
2056 spin_lock_irq(¤t->sighand->siglock);
2057 current->last_siginfo = NULL;
2059 /* LISTENING can be set only during STOP traps, clear it */
2060 current->jobctl &= ~JOBCTL_LISTENING;
2063 * Queued signals ignored us while we were stopped for tracing.
2064 * So check for any that we should take before resuming user mode.
2065 * This sets TIF_SIGPENDING, but never clears it.
2067 recalc_sigpending_tsk(current);
2070 static void ptrace_do_notify(int signr, int exit_code, int why)
2074 clear_siginfo(&info);
2075 info.si_signo = signr;
2076 info.si_code = exit_code;
2077 info.si_pid = task_pid_vnr(current);
2078 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2080 /* Let the debugger run. */
2081 ptrace_stop(exit_code, why, 1, &info);
2084 void ptrace_notify(int exit_code)
2086 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2087 if (unlikely(current->task_works))
2090 spin_lock_irq(¤t->sighand->siglock);
2091 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
2092 spin_unlock_irq(¤t->sighand->siglock);
2096 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
2097 * @signr: signr causing group stop if initiating
2099 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
2100 * and participate in it. If already set, participate in the existing
2101 * group stop. If participated in a group stop (and thus slept), %true is
2102 * returned with siglock released.
2104 * If ptraced, this function doesn't handle stop itself. Instead,
2105 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
2106 * untouched. The caller must ensure that INTERRUPT trap handling takes
2107 * places afterwards.
2110 * Must be called with @current->sighand->siglock held, which is released
2114 * %false if group stop is already cancelled or ptrace trap is scheduled.
2115 * %true if participated in group stop.
2117 static bool do_signal_stop(int signr)
2118 __releases(¤t->sighand->siglock)
2120 struct signal_struct *sig = current->signal;
2122 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2123 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2124 struct task_struct *t;
2126 /* signr will be recorded in task->jobctl for retries */
2127 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2129 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2130 unlikely(signal_group_exit(sig)))
2133 * There is no group stop already in progress. We must
2136 * While ptraced, a task may be resumed while group stop is
2137 * still in effect and then receive a stop signal and
2138 * initiate another group stop. This deviates from the
2139 * usual behavior as two consecutive stop signals can't
2140 * cause two group stops when !ptraced. That is why we
2141 * also check !task_is_stopped(t) below.
2143 * The condition can be distinguished by testing whether
2144 * SIGNAL_STOP_STOPPED is already set. Don't generate
2145 * group_exit_code in such case.
2147 * This is not necessary for SIGNAL_STOP_CONTINUED because
2148 * an intervening stop signal is required to cause two
2149 * continued events regardless of ptrace.
2151 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2152 sig->group_exit_code = signr;
2154 sig->group_stop_count = 0;
2156 if (task_set_jobctl_pending(current, signr | gstop))
2157 sig->group_stop_count++;
2160 while_each_thread(current, t) {
2162 * Setting state to TASK_STOPPED for a group
2163 * stop is always done with the siglock held,
2164 * so this check has no races.
2166 if (!task_is_stopped(t) &&
2167 task_set_jobctl_pending(t, signr | gstop)) {
2168 sig->group_stop_count++;
2169 if (likely(!(t->ptrace & PT_SEIZED)))
2170 signal_wake_up(t, 0);
2172 ptrace_trap_notify(t);
2177 if (likely(!current->ptrace)) {
2181 * If there are no other threads in the group, or if there
2182 * is a group stop in progress and we are the last to stop,
2183 * report to the parent.
2185 if (task_participate_group_stop(current))
2186 notify = CLD_STOPPED;
2188 set_special_state(TASK_STOPPED);
2189 spin_unlock_irq(¤t->sighand->siglock);
2192 * Notify the parent of the group stop completion. Because
2193 * we're not holding either the siglock or tasklist_lock
2194 * here, ptracer may attach inbetween; however, this is for
2195 * group stop and should always be delivered to the real
2196 * parent of the group leader. The new ptracer will get
2197 * its notification when this task transitions into
2201 read_lock(&tasklist_lock);
2202 do_notify_parent_cldstop(current, false, notify);
2203 read_unlock(&tasklist_lock);
2206 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2207 freezable_schedule();
2211 * While ptraced, group stop is handled by STOP trap.
2212 * Schedule it and let the caller deal with it.
2214 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2220 * do_jobctl_trap - take care of ptrace jobctl traps
2222 * When PT_SEIZED, it's used for both group stop and explicit
2223 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
2224 * accompanying siginfo. If stopped, lower eight bits of exit_code contain
2225 * the stop signal; otherwise, %SIGTRAP.
2227 * When !PT_SEIZED, it's used only for group stop trap with stop signal
2228 * number as exit_code and no siginfo.
2231 * Must be called with @current->sighand->siglock held, which may be
2232 * released and re-acquired before returning with intervening sleep.
2234 static void do_jobctl_trap(void)
2236 struct signal_struct *signal = current->signal;
2237 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2239 if (current->ptrace & PT_SEIZED) {
2240 if (!signal->group_stop_count &&
2241 !(signal->flags & SIGNAL_STOP_STOPPED))
2243 WARN_ON_ONCE(!signr);
2244 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2247 WARN_ON_ONCE(!signr);
2248 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2249 current->exit_code = 0;
2253 static int ptrace_signal(int signr, siginfo_t *info)
2256 * We do not check sig_kernel_stop(signr) but set this marker
2257 * unconditionally because we do not know whether debugger will
2258 * change signr. This flag has no meaning unless we are going
2259 * to stop after return from ptrace_stop(). In this case it will
2260 * be checked in do_signal_stop(), we should only stop if it was
2261 * not cleared by SIGCONT while we were sleeping. See also the
2262 * comment in dequeue_signal().
2264 current->jobctl |= JOBCTL_STOP_DEQUEUED;
2265 ptrace_stop(signr, CLD_TRAPPED, 0, info);
2267 /* We're back. Did the debugger cancel the sig? */
2268 signr = current->exit_code;
2272 current->exit_code = 0;
2275 * Update the siginfo structure if the signal has
2276 * changed. If the debugger wanted something
2277 * specific in the siginfo structure then it should
2278 * have updated *info via PTRACE_SETSIGINFO.
2280 if (signr != info->si_signo) {
2281 clear_siginfo(info);
2282 info->si_signo = signr;
2284 info->si_code = SI_USER;
2286 info->si_pid = task_pid_vnr(current->parent);
2287 info->si_uid = from_kuid_munged(current_user_ns(),
2288 task_uid(current->parent));
2292 /* If the (new) signal is now blocked, requeue it. */
2293 if (sigismember(¤t->blocked, signr)) {
2294 specific_send_sig_info(signr, info, current);
2301 int get_signal(struct ksignal *ksig)
2303 struct sighand_struct *sighand = current->sighand;
2304 struct signal_struct *signal = current->signal;
2307 if (unlikely(current->task_works))
2310 if (unlikely(uprobe_deny_signal()))
2314 * Do this once, we can't return to user-mode if freezing() == T.
2315 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2316 * thus do not need another check after return.
2321 spin_lock_irq(&sighand->siglock);
2323 * Every stopped thread goes here after wakeup. Check to see if
2324 * we should notify the parent, prepare_signal(SIGCONT) encodes
2325 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2327 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2330 if (signal->flags & SIGNAL_CLD_CONTINUED)
2331 why = CLD_CONTINUED;
2335 signal->flags &= ~SIGNAL_CLD_MASK;
2337 spin_unlock_irq(&sighand->siglock);
2340 * Notify the parent that we're continuing. This event is
2341 * always per-process and doesn't make whole lot of sense
2342 * for ptracers, who shouldn't consume the state via
2343 * wait(2) either, but, for backward compatibility, notify
2344 * the ptracer of the group leader too unless it's gonna be
2347 read_lock(&tasklist_lock);
2348 do_notify_parent_cldstop(current, false, why);
2350 if (ptrace_reparented(current->group_leader))
2351 do_notify_parent_cldstop(current->group_leader,
2353 read_unlock(&tasklist_lock);
2359 struct k_sigaction *ka;
2361 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2365 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2367 spin_unlock_irq(&sighand->siglock);
2371 signr = dequeue_signal(current, ¤t->blocked, &ksig->info);
2374 break; /* will return 0 */
2376 if (unlikely(current->ptrace) && signr != SIGKILL) {
2377 signr = ptrace_signal(signr, &ksig->info);
2382 ka = &sighand->action[signr-1];
2384 /* Trace actually delivered signals. */
2385 trace_signal_deliver(signr, &ksig->info, ka);
2387 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
2389 if (ka->sa.sa_handler != SIG_DFL) {
2390 /* Run the handler. */
2393 if (ka->sa.sa_flags & SA_ONESHOT)
2394 ka->sa.sa_handler = SIG_DFL;
2396 break; /* will return non-zero "signr" value */
2400 * Now we are doing the default action for this signal.
2402 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2406 * Global init gets no signals it doesn't want.
2407 * Container-init gets no signals it doesn't want from same
2410 * Note that if global/container-init sees a sig_kernel_only()
2411 * signal here, the signal must have been generated internally
2412 * or must have come from an ancestor namespace. In either
2413 * case, the signal cannot be dropped.
2415 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2416 !sig_kernel_only(signr))
2419 if (sig_kernel_stop(signr)) {
2421 * The default action is to stop all threads in
2422 * the thread group. The job control signals
2423 * do nothing in an orphaned pgrp, but SIGSTOP
2424 * always works. Note that siglock needs to be
2425 * dropped during the call to is_orphaned_pgrp()
2426 * because of lock ordering with tasklist_lock.
2427 * This allows an intervening SIGCONT to be posted.
2428 * We need to check for that and bail out if necessary.
2430 if (signr != SIGSTOP) {
2431 spin_unlock_irq(&sighand->siglock);
2433 /* signals can be posted during this window */
2435 if (is_current_pgrp_orphaned())
2438 spin_lock_irq(&sighand->siglock);
2441 if (likely(do_signal_stop(ksig->info.si_signo))) {
2442 /* It released the siglock. */
2447 * We didn't actually stop, due to a race
2448 * with SIGCONT or something like that.
2453 spin_unlock_irq(&sighand->siglock);
2456 * Anything else is fatal, maybe with a core dump.
2458 current->flags |= PF_SIGNALED;
2460 if (sig_kernel_coredump(signr)) {
2461 if (print_fatal_signals)
2462 print_fatal_signal(ksig->info.si_signo);
2463 proc_coredump_connector(current);
2465 * If it was able to dump core, this kills all
2466 * other threads in the group and synchronizes with
2467 * their demise. If we lost the race with another
2468 * thread getting here, it set group_exit_code
2469 * first and our do_group_exit call below will use
2470 * that value and ignore the one we pass it.
2472 do_coredump(&ksig->info);
2476 * Death signals, no core dump.
2478 do_group_exit(ksig->info.si_signo);
2481 spin_unlock_irq(&sighand->siglock);
2484 return ksig->sig > 0;
2488 * signal_delivered -
2489 * @ksig: kernel signal struct
2490 * @stepping: nonzero if debugger single-step or block-step in use
2492 * This function should be called when a signal has successfully been
2493 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2494 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2495 * is set in @ksig->ka.sa.sa_flags. Tracing is notified.
2497 static void signal_delivered(struct ksignal *ksig, int stepping)
2501 /* A signal was successfully delivered, and the
2502 saved sigmask was stored on the signal frame,
2503 and will be restored by sigreturn. So we can
2504 simply clear the restore sigmask flag. */
2505 clear_restore_sigmask();
2507 sigorsets(&blocked, ¤t->blocked, &ksig->ka.sa.sa_mask);
2508 if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2509 sigaddset(&blocked, ksig->sig);
2510 set_current_blocked(&blocked);
2511 tracehook_signal_handler(stepping);
2514 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2517 force_sigsegv(ksig->sig, current);
2519 signal_delivered(ksig, stepping);
2523 * It could be that complete_signal() picked us to notify about the
2524 * group-wide signal. Other threads should be notified now to take
2525 * the shared signals in @which since we will not.
2527 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2530 struct task_struct *t;
2532 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2533 if (sigisemptyset(&retarget))
2537 while_each_thread(tsk, t) {
2538 if (t->flags & PF_EXITING)
2541 if (!has_pending_signals(&retarget, &t->blocked))
2543 /* Remove the signals this thread can handle. */
2544 sigandsets(&retarget, &retarget, &t->blocked);
2546 if (!signal_pending(t))
2547 signal_wake_up(t, 0);
2549 if (sigisemptyset(&retarget))
2554 void exit_signals(struct task_struct *tsk)
2560 * @tsk is about to have PF_EXITING set - lock out users which
2561 * expect stable threadgroup.
2563 cgroup_threadgroup_change_begin(tsk);
2565 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2566 tsk->flags |= PF_EXITING;
2567 cgroup_threadgroup_change_end(tsk);
2571 spin_lock_irq(&tsk->sighand->siglock);
2573 * From now this task is not visible for group-wide signals,
2574 * see wants_signal(), do_signal_stop().
2576 tsk->flags |= PF_EXITING;
2578 cgroup_threadgroup_change_end(tsk);
2580 if (!signal_pending(tsk))
2583 unblocked = tsk->blocked;
2584 signotset(&unblocked);
2585 retarget_shared_pending(tsk, &unblocked);
2587 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2588 task_participate_group_stop(tsk))
2589 group_stop = CLD_STOPPED;
2591 spin_unlock_irq(&tsk->sighand->siglock);
2594 * If group stop has completed, deliver the notification. This
2595 * should always go to the real parent of the group leader.
2597 if (unlikely(group_stop)) {
2598 read_lock(&tasklist_lock);
2599 do_notify_parent_cldstop(tsk, false, group_stop);
2600 read_unlock(&tasklist_lock);
2604 EXPORT_SYMBOL(recalc_sigpending);
2605 EXPORT_SYMBOL_GPL(dequeue_signal);
2606 EXPORT_SYMBOL(flush_signals);
2607 EXPORT_SYMBOL(force_sig);
2608 EXPORT_SYMBOL(send_sig);
2609 EXPORT_SYMBOL(send_sig_info);
2610 EXPORT_SYMBOL(sigprocmask);
2613 * System call entry points.
2617 * sys_restart_syscall - restart a system call
2619 SYSCALL_DEFINE0(restart_syscall)
2621 struct restart_block *restart = ¤t->restart_block;
2622 return restart->fn(restart);
2625 long do_no_restart_syscall(struct restart_block *param)
2630 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2632 if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2633 sigset_t newblocked;
2634 /* A set of now blocked but previously unblocked signals. */
2635 sigandnsets(&newblocked, newset, ¤t->blocked);
2636 retarget_shared_pending(tsk, &newblocked);
2638 tsk->blocked = *newset;
2639 recalc_sigpending();
2643 * set_current_blocked - change current->blocked mask
2646 * It is wrong to change ->blocked directly, this helper should be used
2647 * to ensure the process can't miss a shared signal we are going to block.
2649 void set_current_blocked(sigset_t *newset)
2651 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2652 __set_current_blocked(newset);
2655 void __set_current_blocked(const sigset_t *newset)
2657 struct task_struct *tsk = current;
2660 * In case the signal mask hasn't changed, there is nothing we need
2661 * to do. The current->blocked shouldn't be modified by other task.
2663 if (sigequalsets(&tsk->blocked, newset))
2666 spin_lock_irq(&tsk->sighand->siglock);
2667 __set_task_blocked(tsk, newset);
2668 spin_unlock_irq(&tsk->sighand->siglock);
2672 * This is also useful for kernel threads that want to temporarily
2673 * (or permanently) block certain signals.
2675 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2676 * interface happily blocks "unblockable" signals like SIGKILL
2679 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2681 struct task_struct *tsk = current;
2684 /* Lockless, only current can change ->blocked, never from irq */
2686 *oldset = tsk->blocked;
2690 sigorsets(&newset, &tsk->blocked, set);
2693 sigandnsets(&newset, &tsk->blocked, set);
2702 __set_current_blocked(&newset);
2707 * sys_rt_sigprocmask - change the list of currently blocked signals
2708 * @how: whether to add, remove, or set signals
2709 * @nset: stores pending signals
2710 * @oset: previous value of signal mask if non-null
2711 * @sigsetsize: size of sigset_t type
2713 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2714 sigset_t __user *, oset, size_t, sigsetsize)
2716 sigset_t old_set, new_set;
2719 /* XXX: Don't preclude handling different sized sigset_t's. */
2720 if (sigsetsize != sizeof(sigset_t))
2723 old_set = current->blocked;
2726 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2728 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2730 error = sigprocmask(how, &new_set, NULL);
2736 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2743 #ifdef CONFIG_COMPAT
2744 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2745 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2747 sigset_t old_set = current->blocked;
2749 /* XXX: Don't preclude handling different sized sigset_t's. */
2750 if (sigsetsize != sizeof(sigset_t))
2756 if (get_compat_sigset(&new_set, nset))
2758 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2760 error = sigprocmask(how, &new_set, NULL);
2764 return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
2768 static int do_sigpending(sigset_t *set)
2770 spin_lock_irq(¤t->sighand->siglock);
2771 sigorsets(set, ¤t->pending.signal,
2772 ¤t->signal->shared_pending.signal);
2773 spin_unlock_irq(¤t->sighand->siglock);
2775 /* Outside the lock because only this thread touches it. */
2776 sigandsets(set, ¤t->blocked, set);
2781 * sys_rt_sigpending - examine a pending signal that has been raised
2783 * @uset: stores pending signals
2784 * @sigsetsize: size of sigset_t type or larger
2786 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2791 if (sigsetsize > sizeof(*uset))
2794 err = do_sigpending(&set);
2795 if (!err && copy_to_user(uset, &set, sigsetsize))
2800 #ifdef CONFIG_COMPAT
2801 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2802 compat_size_t, sigsetsize)
2807 if (sigsetsize > sizeof(*uset))
2810 err = do_sigpending(&set);
2812 err = put_compat_sigset(uset, &set, sigsetsize);
2817 enum siginfo_layout siginfo_layout(int sig, int si_code)
2819 enum siginfo_layout layout = SIL_KILL;
2820 if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
2821 static const struct {
2822 unsigned char limit, layout;
2824 [SIGILL] = { NSIGILL, SIL_FAULT },
2825 [SIGFPE] = { NSIGFPE, SIL_FAULT },
2826 [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
2827 [SIGBUS] = { NSIGBUS, SIL_FAULT },
2828 [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
2829 #if defined(SIGEMT) && defined(NSIGEMT)
2830 [SIGEMT] = { NSIGEMT, SIL_FAULT },
2832 [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
2833 [SIGPOLL] = { NSIGPOLL, SIL_POLL },
2834 [SIGSYS] = { NSIGSYS, SIL_SYS },
2836 if ((sig < ARRAY_SIZE(filter)) && (si_code <= filter[sig].limit)) {
2837 layout = filter[sig].layout;
2838 /* Handle the exceptions */
2839 if ((sig == SIGBUS) &&
2840 (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
2841 layout = SIL_FAULT_MCEERR;
2842 else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
2843 layout = SIL_FAULT_BNDERR;
2845 else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
2846 layout = SIL_FAULT_PKUERR;
2849 else if (si_code <= NSIGPOLL)
2852 if (si_code == SI_TIMER)
2854 else if (si_code == SI_SIGIO)
2856 else if (si_code < 0)
2862 int copy_siginfo_to_user(siginfo_t __user *to, const siginfo_t *from)
2864 if (copy_to_user(to, from , sizeof(struct siginfo)))
2869 #ifdef CONFIG_COMPAT
2870 int copy_siginfo_to_user32(struct compat_siginfo __user *to,
2871 const struct siginfo *from)
2872 #if defined(CONFIG_X86_X32_ABI) || defined(CONFIG_IA32_EMULATION)
2874 return __copy_siginfo_to_user32(to, from, in_x32_syscall());
2876 int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
2877 const struct siginfo *from, bool x32_ABI)
2880 struct compat_siginfo new;
2881 memset(&new, 0, sizeof(new));
2883 new.si_signo = from->si_signo;
2884 new.si_errno = from->si_errno;
2885 new.si_code = from->si_code;
2886 switch(siginfo_layout(from->si_signo, from->si_code)) {
2888 new.si_pid = from->si_pid;
2889 new.si_uid = from->si_uid;
2892 new.si_tid = from->si_tid;
2893 new.si_overrun = from->si_overrun;
2894 new.si_int = from->si_int;
2897 new.si_band = from->si_band;
2898 new.si_fd = from->si_fd;
2901 new.si_addr = ptr_to_compat(from->si_addr);
2902 #ifdef __ARCH_SI_TRAPNO
2903 new.si_trapno = from->si_trapno;
2906 case SIL_FAULT_MCEERR:
2907 new.si_addr = ptr_to_compat(from->si_addr);
2908 #ifdef __ARCH_SI_TRAPNO
2909 new.si_trapno = from->si_trapno;
2911 new.si_addr_lsb = from->si_addr_lsb;
2913 case SIL_FAULT_BNDERR:
2914 new.si_addr = ptr_to_compat(from->si_addr);
2915 #ifdef __ARCH_SI_TRAPNO
2916 new.si_trapno = from->si_trapno;
2918 new.si_lower = ptr_to_compat(from->si_lower);
2919 new.si_upper = ptr_to_compat(from->si_upper);
2921 case SIL_FAULT_PKUERR:
2922 new.si_addr = ptr_to_compat(from->si_addr);
2923 #ifdef __ARCH_SI_TRAPNO
2924 new.si_trapno = from->si_trapno;
2926 new.si_pkey = from->si_pkey;
2929 new.si_pid = from->si_pid;
2930 new.si_uid = from->si_uid;
2931 new.si_status = from->si_status;
2932 #ifdef CONFIG_X86_X32_ABI
2934 new._sifields._sigchld_x32._utime = from->si_utime;
2935 new._sifields._sigchld_x32._stime = from->si_stime;
2939 new.si_utime = from->si_utime;
2940 new.si_stime = from->si_stime;
2944 new.si_pid = from->si_pid;
2945 new.si_uid = from->si_uid;
2946 new.si_int = from->si_int;
2949 new.si_call_addr = ptr_to_compat(from->si_call_addr);
2950 new.si_syscall = from->si_syscall;
2951 new.si_arch = from->si_arch;
2955 if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
2961 int copy_siginfo_from_user32(struct siginfo *to,
2962 const struct compat_siginfo __user *ufrom)
2964 struct compat_siginfo from;
2966 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
2970 to->si_signo = from.si_signo;
2971 to->si_errno = from.si_errno;
2972 to->si_code = from.si_code;
2973 switch(siginfo_layout(from.si_signo, from.si_code)) {
2975 to->si_pid = from.si_pid;
2976 to->si_uid = from.si_uid;
2979 to->si_tid = from.si_tid;
2980 to->si_overrun = from.si_overrun;
2981 to->si_int = from.si_int;
2984 to->si_band = from.si_band;
2985 to->si_fd = from.si_fd;
2988 to->si_addr = compat_ptr(from.si_addr);
2989 #ifdef __ARCH_SI_TRAPNO
2990 to->si_trapno = from.si_trapno;
2993 case SIL_FAULT_MCEERR:
2994 to->si_addr = compat_ptr(from.si_addr);
2995 #ifdef __ARCH_SI_TRAPNO
2996 to->si_trapno = from.si_trapno;
2998 to->si_addr_lsb = from.si_addr_lsb;
3000 case SIL_FAULT_BNDERR:
3001 to->si_addr = compat_ptr(from.si_addr);
3002 #ifdef __ARCH_SI_TRAPNO
3003 to->si_trapno = from.si_trapno;
3005 to->si_lower = compat_ptr(from.si_lower);
3006 to->si_upper = compat_ptr(from.si_upper);
3008 case SIL_FAULT_PKUERR:
3009 to->si_addr = compat_ptr(from.si_addr);
3010 #ifdef __ARCH_SI_TRAPNO
3011 to->si_trapno = from.si_trapno;
3013 to->si_pkey = from.si_pkey;
3016 to->si_pid = from.si_pid;
3017 to->si_uid = from.si_uid;
3018 to->si_status = from.si_status;
3019 #ifdef CONFIG_X86_X32_ABI
3020 if (in_x32_syscall()) {
3021 to->si_utime = from._sifields._sigchld_x32._utime;
3022 to->si_stime = from._sifields._sigchld_x32._stime;
3026 to->si_utime = from.si_utime;
3027 to->si_stime = from.si_stime;
3031 to->si_pid = from.si_pid;
3032 to->si_uid = from.si_uid;
3033 to->si_int = from.si_int;
3036 to->si_call_addr = compat_ptr(from.si_call_addr);
3037 to->si_syscall = from.si_syscall;
3038 to->si_arch = from.si_arch;
3043 #endif /* CONFIG_COMPAT */
3046 * do_sigtimedwait - wait for queued signals specified in @which
3047 * @which: queued signals to wait for
3048 * @info: if non-null, the signal's siginfo is returned here
3049 * @ts: upper bound on process time suspension
3051 static int do_sigtimedwait(const sigset_t *which, siginfo_t *info,
3052 const struct timespec *ts)
3054 ktime_t *to = NULL, timeout = KTIME_MAX;
3055 struct task_struct *tsk = current;
3056 sigset_t mask = *which;
3060 if (!timespec_valid(ts))
3062 timeout = timespec_to_ktime(*ts);
3067 * Invert the set of allowed signals to get those we want to block.
3069 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
3072 spin_lock_irq(&tsk->sighand->siglock);
3073 sig = dequeue_signal(tsk, &mask, info);
3074 if (!sig && timeout) {
3076 * None ready, temporarily unblock those we're interested
3077 * while we are sleeping in so that we'll be awakened when
3078 * they arrive. Unblocking is always fine, we can avoid
3079 * set_current_blocked().
3081 tsk->real_blocked = tsk->blocked;
3082 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
3083 recalc_sigpending();
3084 spin_unlock_irq(&tsk->sighand->siglock);
3086 __set_current_state(TASK_INTERRUPTIBLE);
3087 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
3089 spin_lock_irq(&tsk->sighand->siglock);
3090 __set_task_blocked(tsk, &tsk->real_blocked);
3091 sigemptyset(&tsk->real_blocked);
3092 sig = dequeue_signal(tsk, &mask, info);
3094 spin_unlock_irq(&tsk->sighand->siglock);
3098 return ret ? -EINTR : -EAGAIN;
3102 * sys_rt_sigtimedwait - synchronously wait for queued signals specified
3104 * @uthese: queued signals to wait for
3105 * @uinfo: if non-null, the signal's siginfo is returned here
3106 * @uts: upper bound on process time suspension
3107 * @sigsetsize: size of sigset_t type
3109 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
3110 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
3118 /* XXX: Don't preclude handling different sized sigset_t's. */
3119 if (sigsetsize != sizeof(sigset_t))
3122 if (copy_from_user(&these, uthese, sizeof(these)))
3126 if (copy_from_user(&ts, uts, sizeof(ts)))
3130 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3132 if (ret > 0 && uinfo) {
3133 if (copy_siginfo_to_user(uinfo, &info))
3140 #ifdef CONFIG_COMPAT
3141 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait, compat_sigset_t __user *, uthese,
3142 struct compat_siginfo __user *, uinfo,
3143 struct compat_timespec __user *, uts, compat_size_t, sigsetsize)
3150 if (sigsetsize != sizeof(sigset_t))
3153 if (get_compat_sigset(&s, uthese))
3157 if (compat_get_timespec(&t, uts))
3161 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3163 if (ret > 0 && uinfo) {
3164 if (copy_siginfo_to_user32(uinfo, &info))
3173 * sys_kill - send a signal to a process
3174 * @pid: the PID of the process
3175 * @sig: signal to be sent
3177 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
3179 struct siginfo info;
3181 clear_siginfo(&info);
3182 info.si_signo = sig;
3184 info.si_code = SI_USER;
3185 info.si_pid = task_tgid_vnr(current);
3186 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
3188 return kill_something_info(sig, &info, pid);
3192 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
3194 struct task_struct *p;
3198 p = find_task_by_vpid(pid);
3199 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
3200 error = check_kill_permission(sig, info, p);
3202 * The null signal is a permissions and process existence
3203 * probe. No signal is actually delivered.
3205 if (!error && sig) {
3206 error = do_send_sig_info(sig, info, p, false);
3208 * If lock_task_sighand() failed we pretend the task
3209 * dies after receiving the signal. The window is tiny,
3210 * and the signal is private anyway.
3212 if (unlikely(error == -ESRCH))
3221 static int do_tkill(pid_t tgid, pid_t pid, int sig)
3223 struct siginfo info;
3225 clear_siginfo(&info);
3226 info.si_signo = sig;
3228 info.si_code = SI_TKILL;
3229 info.si_pid = task_tgid_vnr(current);
3230 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
3232 return do_send_specific(tgid, pid, sig, &info);
3236 * sys_tgkill - send signal to one specific thread
3237 * @tgid: the thread group ID of the thread
3238 * @pid: the PID of the thread
3239 * @sig: signal to be sent
3241 * This syscall also checks the @tgid and returns -ESRCH even if the PID
3242 * exists but it's not belonging to the target process anymore. This
3243 * method solves the problem of threads exiting and PIDs getting reused.
3245 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3247 /* This is only valid for single tasks */
3248 if (pid <= 0 || tgid <= 0)
3251 return do_tkill(tgid, pid, sig);
3255 * sys_tkill - send signal to one specific task
3256 * @pid: the PID of the task
3257 * @sig: signal to be sent
3259 * Send a signal to only one task, even if it's a CLONE_THREAD task.
3261 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
3263 /* This is only valid for single tasks */
3267 return do_tkill(0, pid, sig);
3270 static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t *info)
3272 /* Not even root can pretend to send signals from the kernel.
3273 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3275 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3276 (task_pid_vnr(current) != pid))
3279 info->si_signo = sig;
3281 /* POSIX.1b doesn't mention process groups. */
3282 return kill_proc_info(sig, info, pid);
3286 * sys_rt_sigqueueinfo - send signal information to a signal
3287 * @pid: the PID of the thread
3288 * @sig: signal to be sent
3289 * @uinfo: signal info to be sent
3291 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3292 siginfo_t __user *, uinfo)
3295 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3297 return do_rt_sigqueueinfo(pid, sig, &info);
3300 #ifdef CONFIG_COMPAT
3301 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
3304 struct compat_siginfo __user *, uinfo)
3307 int ret = copy_siginfo_from_user32(&info, uinfo);
3310 return do_rt_sigqueueinfo(pid, sig, &info);
3314 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
3316 /* This is only valid for single tasks */
3317 if (pid <= 0 || tgid <= 0)
3320 /* Not even root can pretend to send signals from the kernel.
3321 * Nor can they impersonate a kill()/tgkill(), which adds source info.
3323 if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3324 (task_pid_vnr(current) != pid))
3327 info->si_signo = sig;
3329 return do_send_specific(tgid, pid, sig, info);
3332 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
3333 siginfo_t __user *, uinfo)
3337 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
3340 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3343 #ifdef CONFIG_COMPAT
3344 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
3348 struct compat_siginfo __user *, uinfo)
3352 if (copy_siginfo_from_user32(&info, uinfo))
3354 return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
3359 * For kthreads only, must not be used if cloned with CLONE_SIGHAND
3361 void kernel_sigaction(int sig, __sighandler_t action)
3363 spin_lock_irq(¤t->sighand->siglock);
3364 current->sighand->action[sig - 1].sa.sa_handler = action;
3365 if (action == SIG_IGN) {
3369 sigaddset(&mask, sig);
3371 flush_sigqueue_mask(&mask, ¤t->signal->shared_pending);
3372 flush_sigqueue_mask(&mask, ¤t->pending);
3373 recalc_sigpending();
3375 spin_unlock_irq(¤t->sighand->siglock);
3377 EXPORT_SYMBOL(kernel_sigaction);
3379 void __weak sigaction_compat_abi(struct k_sigaction *act,
3380 struct k_sigaction *oact)
3384 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
3386 struct task_struct *p = current, *t;
3387 struct k_sigaction *k;
3390 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
3393 k = &p->sighand->action[sig-1];
3395 spin_lock_irq(&p->sighand->siglock);
3399 sigaction_compat_abi(act, oact);
3402 sigdelsetmask(&act->sa.sa_mask,
3403 sigmask(SIGKILL) | sigmask(SIGSTOP));
3407 * "Setting a signal action to SIG_IGN for a signal that is
3408 * pending shall cause the pending signal to be discarded,
3409 * whether or not it is blocked."
3411 * "Setting a signal action to SIG_DFL for a signal that is
3412 * pending and whose default action is to ignore the signal
3413 * (for example, SIGCHLD), shall cause the pending signal to
3414 * be discarded, whether or not it is blocked"
3416 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
3418 sigaddset(&mask, sig);
3419 flush_sigqueue_mask(&mask, &p->signal->shared_pending);
3420 for_each_thread(p, t)
3421 flush_sigqueue_mask(&mask, &t->pending);
3425 spin_unlock_irq(&p->sighand->siglock);
3430 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp)
3432 struct task_struct *t = current;
3435 memset(oss, 0, sizeof(stack_t));
3436 oss->ss_sp = (void __user *) t->sas_ss_sp;
3437 oss->ss_size = t->sas_ss_size;
3438 oss->ss_flags = sas_ss_flags(sp) |
3439 (current->sas_ss_flags & SS_FLAG_BITS);
3443 void __user *ss_sp = ss->ss_sp;
3444 size_t ss_size = ss->ss_size;
3445 unsigned ss_flags = ss->ss_flags;
3448 if (unlikely(on_sig_stack(sp)))
3451 ss_mode = ss_flags & ~SS_FLAG_BITS;
3452 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
3456 if (ss_mode == SS_DISABLE) {
3460 if (unlikely(ss_size < MINSIGSTKSZ))
3464 t->sas_ss_sp = (unsigned long) ss_sp;
3465 t->sas_ss_size = ss_size;
3466 t->sas_ss_flags = ss_flags;
3471 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
3475 if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
3477 err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
3478 current_user_stack_pointer());
3479 if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
3484 int restore_altstack(const stack_t __user *uss)
3487 if (copy_from_user(&new, uss, sizeof(stack_t)))
3489 (void)do_sigaltstack(&new, NULL, current_user_stack_pointer());
3490 /* squash all but EFAULT for now */
3494 int __save_altstack(stack_t __user *uss, unsigned long sp)
3496 struct task_struct *t = current;
3497 int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
3498 __put_user(t->sas_ss_flags, &uss->ss_flags) |
3499 __put_user(t->sas_ss_size, &uss->ss_size);
3502 if (t->sas_ss_flags & SS_AUTODISARM)
3507 #ifdef CONFIG_COMPAT
3508 static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
3509 compat_stack_t __user *uoss_ptr)
3515 compat_stack_t uss32;
3516 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
3518 uss.ss_sp = compat_ptr(uss32.ss_sp);
3519 uss.ss_flags = uss32.ss_flags;
3520 uss.ss_size = uss32.ss_size;
3522 ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
3523 compat_user_stack_pointer());
3524 if (ret >= 0 && uoss_ptr) {
3526 memset(&old, 0, sizeof(old));
3527 old.ss_sp = ptr_to_compat(uoss.ss_sp);
3528 old.ss_flags = uoss.ss_flags;
3529 old.ss_size = uoss.ss_size;
3530 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
3536 COMPAT_SYSCALL_DEFINE2(sigaltstack,
3537 const compat_stack_t __user *, uss_ptr,
3538 compat_stack_t __user *, uoss_ptr)
3540 return do_compat_sigaltstack(uss_ptr, uoss_ptr);
3543 int compat_restore_altstack(const compat_stack_t __user *uss)
3545 int err = do_compat_sigaltstack(uss, NULL);
3546 /* squash all but -EFAULT for now */
3547 return err == -EFAULT ? err : 0;
3550 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
3553 struct task_struct *t = current;
3554 err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
3556 __put_user(t->sas_ss_flags, &uss->ss_flags) |
3557 __put_user(t->sas_ss_size, &uss->ss_size);
3560 if (t->sas_ss_flags & SS_AUTODISARM)
3566 #ifdef __ARCH_WANT_SYS_SIGPENDING
3569 * sys_sigpending - examine pending signals
3570 * @uset: where mask of pending signal is returned
3572 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
3577 if (sizeof(old_sigset_t) > sizeof(*uset))
3580 err = do_sigpending(&set);
3581 if (!err && copy_to_user(uset, &set, sizeof(old_sigset_t)))
3586 #ifdef CONFIG_COMPAT
3587 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
3590 int err = do_sigpending(&set);
3592 err = put_user(set.sig[0], set32);
3599 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
3601 * sys_sigprocmask - examine and change blocked signals
3602 * @how: whether to add, remove, or set signals
3603 * @nset: signals to add or remove (if non-null)
3604 * @oset: previous value of signal mask if non-null
3606 * Some platforms have their own version with special arguments;
3607 * others support only sys_rt_sigprocmask.
3610 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
3611 old_sigset_t __user *, oset)
3613 old_sigset_t old_set, new_set;
3614 sigset_t new_blocked;
3616 old_set = current->blocked.sig[0];
3619 if (copy_from_user(&new_set, nset, sizeof(*nset)))
3622 new_blocked = current->blocked;
3626 sigaddsetmask(&new_blocked, new_set);
3629 sigdelsetmask(&new_blocked, new_set);
3632 new_blocked.sig[0] = new_set;
3638 set_current_blocked(&new_blocked);
3642 if (copy_to_user(oset, &old_set, sizeof(*oset)))
3648 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
3650 #ifndef CONFIG_ODD_RT_SIGACTION
3652 * sys_rt_sigaction - alter an action taken by a process
3653 * @sig: signal to be sent
3654 * @act: new sigaction
3655 * @oact: used to save the previous sigaction
3656 * @sigsetsize: size of sigset_t type
3658 SYSCALL_DEFINE4(rt_sigaction, int, sig,
3659 const struct sigaction __user *, act,
3660 struct sigaction __user *, oact,
3663 struct k_sigaction new_sa, old_sa;
3666 /* XXX: Don't preclude handling different sized sigset_t's. */
3667 if (sigsetsize != sizeof(sigset_t))
3671 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
3675 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
3678 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
3684 #ifdef CONFIG_COMPAT
3685 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
3686 const struct compat_sigaction __user *, act,
3687 struct compat_sigaction __user *, oact,
3688 compat_size_t, sigsetsize)
3690 struct k_sigaction new_ka, old_ka;
3691 #ifdef __ARCH_HAS_SA_RESTORER
3692 compat_uptr_t restorer;
3696 /* XXX: Don't preclude handling different sized sigset_t's. */
3697 if (sigsetsize != sizeof(compat_sigset_t))
3701 compat_uptr_t handler;
3702 ret = get_user(handler, &act->sa_handler);
3703 new_ka.sa.sa_handler = compat_ptr(handler);
3704 #ifdef __ARCH_HAS_SA_RESTORER
3705 ret |= get_user(restorer, &act->sa_restorer);
3706 new_ka.sa.sa_restorer = compat_ptr(restorer);
3708 ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
3709 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
3714 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3716 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler),
3718 ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
3719 sizeof(oact->sa_mask));
3720 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
3721 #ifdef __ARCH_HAS_SA_RESTORER
3722 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3723 &oact->sa_restorer);
3729 #endif /* !CONFIG_ODD_RT_SIGACTION */
3731 #ifdef CONFIG_OLD_SIGACTION
3732 SYSCALL_DEFINE3(sigaction, int, sig,
3733 const struct old_sigaction __user *, act,
3734 struct old_sigaction __user *, oact)
3736 struct k_sigaction new_ka, old_ka;
3741 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3742 __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
3743 __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
3744 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3745 __get_user(mask, &act->sa_mask))
3747 #ifdef __ARCH_HAS_KA_RESTORER
3748 new_ka.ka_restorer = NULL;
3750 siginitset(&new_ka.sa.sa_mask, mask);
3753 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3756 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3757 __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
3758 __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
3759 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3760 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3767 #ifdef CONFIG_COMPAT_OLD_SIGACTION
3768 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
3769 const struct compat_old_sigaction __user *, act,
3770 struct compat_old_sigaction __user *, oact)
3772 struct k_sigaction new_ka, old_ka;
3774 compat_old_sigset_t mask;
3775 compat_uptr_t handler, restorer;
3778 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
3779 __get_user(handler, &act->sa_handler) ||
3780 __get_user(restorer, &act->sa_restorer) ||
3781 __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
3782 __get_user(mask, &act->sa_mask))
3785 #ifdef __ARCH_HAS_KA_RESTORER
3786 new_ka.ka_restorer = NULL;
3788 new_ka.sa.sa_handler = compat_ptr(handler);
3789 new_ka.sa.sa_restorer = compat_ptr(restorer);
3790 siginitset(&new_ka.sa.sa_mask, mask);
3793 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
3796 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
3797 __put_user(ptr_to_compat(old_ka.sa.sa_handler),
3798 &oact->sa_handler) ||
3799 __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
3800 &oact->sa_restorer) ||
3801 __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
3802 __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
3809 #ifdef CONFIG_SGETMASK_SYSCALL
3812 * For backwards compatibility. Functionality superseded by sigprocmask.
3814 SYSCALL_DEFINE0(sgetmask)
3817 return current->blocked.sig[0];
3820 SYSCALL_DEFINE1(ssetmask, int, newmask)
3822 int old = current->blocked.sig[0];
3825 siginitset(&newset, newmask);
3826 set_current_blocked(&newset);
3830 #endif /* CONFIG_SGETMASK_SYSCALL */
3832 #ifdef __ARCH_WANT_SYS_SIGNAL
3834 * For backwards compatibility. Functionality superseded by sigaction.
3836 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
3838 struct k_sigaction new_sa, old_sa;
3841 new_sa.sa.sa_handler = handler;
3842 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
3843 sigemptyset(&new_sa.sa.sa_mask);
3845 ret = do_sigaction(sig, &new_sa, &old_sa);
3847 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
3849 #endif /* __ARCH_WANT_SYS_SIGNAL */
3851 #ifdef __ARCH_WANT_SYS_PAUSE
3853 SYSCALL_DEFINE0(pause)
3855 while (!signal_pending(current)) {
3856 __set_current_state(TASK_INTERRUPTIBLE);
3859 return -ERESTARTNOHAND;
3864 static int sigsuspend(sigset_t *set)
3866 current->saved_sigmask = current->blocked;
3867 set_current_blocked(set);
3869 while (!signal_pending(current)) {
3870 __set_current_state(TASK_INTERRUPTIBLE);
3873 set_restore_sigmask();
3874 return -ERESTARTNOHAND;
3878 * sys_rt_sigsuspend - replace the signal mask for a value with the
3879 * @unewset value until a signal is received
3880 * @unewset: new signal mask value
3881 * @sigsetsize: size of sigset_t type
3883 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
3887 /* XXX: Don't preclude handling different sized sigset_t's. */
3888 if (sigsetsize != sizeof(sigset_t))
3891 if (copy_from_user(&newset, unewset, sizeof(newset)))
3893 return sigsuspend(&newset);
3896 #ifdef CONFIG_COMPAT
3897 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
3901 /* XXX: Don't preclude handling different sized sigset_t's. */
3902 if (sigsetsize != sizeof(sigset_t))
3905 if (get_compat_sigset(&newset, unewset))
3907 return sigsuspend(&newset);
3911 #ifdef CONFIG_OLD_SIGSUSPEND
3912 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
3915 siginitset(&blocked, mask);
3916 return sigsuspend(&blocked);
3919 #ifdef CONFIG_OLD_SIGSUSPEND3
3920 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
3923 siginitset(&blocked, mask);
3924 return sigsuspend(&blocked);
3928 __weak const char *arch_vma_name(struct vm_area_struct *vma)
3933 void __init signals_init(void)
3935 /* If this check fails, the __ARCH_SI_PREAMBLE_SIZE value is wrong! */
3936 BUILD_BUG_ON(__ARCH_SI_PREAMBLE_SIZE
3937 != offsetof(struct siginfo, _sifields._pad));
3938 BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
3940 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
3943 #ifdef CONFIG_KGDB_KDB
3944 #include <linux/kdb.h>
3946 * kdb_send_sig - Allows kdb to send signals without exposing
3947 * signal internals. This function checks if the required locks are
3948 * available before calling the main signal code, to avoid kdb
3951 void kdb_send_sig(struct task_struct *t, int sig)
3953 static struct task_struct *kdb_prev_t;
3955 if (!spin_trylock(&t->sighand->siglock)) {
3956 kdb_printf("Can't do kill command now.\n"
3957 "The sigmask lock is held somewhere else in "
3958 "kernel, try again later\n");
3961 new_t = kdb_prev_t != t;
3963 if (t->state != TASK_RUNNING && new_t) {
3964 spin_unlock(&t->sighand->siglock);
3965 kdb_printf("Process is not RUNNING, sending a signal from "
3966 "kdb risks deadlock\n"
3967 "on the run queue locks. "
3968 "The signal has _not_ been sent.\n"
3969 "Reissue the kill command if you want to risk "
3973 ret = send_signal(sig, SEND_SIG_PRIV, t, false);
3974 spin_unlock(&t->sighand->siglock);
3976 kdb_printf("Fail to deliver Signal %d to process %d.\n",
3979 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
3981 #endif /* CONFIG_KGDB_KDB */