1/*
2 * linux/kernel/signal.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 *
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
7 *
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
11 */
12
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>
22#include <linux/file.h>
23#include <linux/fs.h>
24#include <linux/proc_fs.h>
25#include <linux/tty.h>
26#include <linux/binfmts.h>
27#include <linux/coredump.h>
28#include <linux/security.h>
29#include <linux/syscalls.h>
30#include <linux/ptrace.h>
31#include <linux/signal.h>
32#include <linux/signalfd.h>
33#include <linux/ratelimit.h>
34#include <linux/tracehook.h>
35#include <linux/capability.h>
36#include <linux/freezer.h>
37#include <linux/pid_namespace.h>
38#include <linux/nsproxy.h>
39#include <linux/user_namespace.h>
40#include <linux/uprobes.h>
41#include <linux/compat.h>
42#include <linux/cn_proc.h>
43#include <linux/compiler.h>
44#include <linux/posix-timers.h>
45#include <linux/livepatch.h>
46
47#define CREATE_TRACE_POINTS
48#include <trace/events/signal.h>
49
50#include <asm/param.h>
51#include <linux/uaccess.h>
52#include <asm/unistd.h>
53#include <asm/siginfo.h>
54#include <asm/cacheflush.h>
55#include "audit.h" /* audit_signal_info() */
56
57/*
58 * SLAB caches for signal bits.
59 */
60
61static struct kmem_cache *sigqueue_cachep;
62
63int print_fatal_signals __read_mostly;
64
65static void __user *sig_handler(struct task_struct *t, int sig)
66{
67 return t->sighand->action[sig - 1].sa.sa_handler;
68}
69
70static inline bool sig_handler_ignored(void __user *handler, int sig)
71{
72 /* Is it explicitly or implicitly ignored? */
73 return handler == SIG_IGN ||
74 (handler == SIG_DFL && sig_kernel_ignore(sig));
75}
76
77static bool sig_task_ignored(struct task_struct *t, int sig, bool force)
78{
79 void __user *handler;
80
81 handler = sig_handler(t, sig);
82
83 /* SIGKILL and SIGSTOP may not be sent to the global init */
84 if (unlikely(is_global_init(t) && sig_kernel_only(sig)))
85 return true;
86
87 if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
88 handler == SIG_DFL && !(force && sig_kernel_only(sig)))
89 return true;
90
91 return sig_handler_ignored(handler, sig);
92}
93
94static bool sig_ignored(struct task_struct *t, int sig, bool force)
95{
96 /*
97 * Blocked signals are never ignored, since the
98 * signal handler may change by the time it is
99 * unblocked.
100 */
101 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
102 return false;
103
104 /*
105 * Tracers may want to know about even ignored signal unless it
106 * is SIGKILL which can't be reported anyway but can be ignored
107 * by SIGNAL_UNKILLABLE task.
108 */
109 if (t->ptrace && sig != SIGKILL)
110 return false;
111
112 return sig_task_ignored(t, sig, force);
113}
114
115/*
116 * Re-calculate pending state from the set of locally pending
117 * signals, globally pending signals, and blocked signals.
118 */
119static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked)
120{
121 unsigned long ready;
122 long i;
123
124 switch (_NSIG_WORDS) {
125 default:
126 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
127 ready |= signal->sig[i] &~ blocked->sig[i];
128 break;
129
130 case 4: ready = signal->sig[3] &~ blocked->sig[3];
131 ready |= signal->sig[2] &~ blocked->sig[2];
132 ready |= signal->sig[1] &~ blocked->sig[1];
133 ready |= signal->sig[0] &~ blocked->sig[0];
134 break;
135
136 case 2: ready = signal->sig[1] &~ blocked->sig[1];
137 ready |= signal->sig[0] &~ blocked->sig[0];
138 break;
139
140 case 1: ready = signal->sig[0] &~ blocked->sig[0];
141 }
142 return ready != 0;
143}
144
145#define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
146
147static bool recalc_sigpending_tsk(struct task_struct *t)
148{
149 if ((t->jobctl & JOBCTL_PENDING_MASK) ||
150 PENDING(&t->pending, &t->blocked) ||
151 PENDING(&t->signal->shared_pending, &t->blocked)) {
152 set_tsk_thread_flag(t, TIF_SIGPENDING);
153 return true;
154 }
155
156 /*
157 * We must never clear the flag in another thread, or in current
158 * when it's possible the current syscall is returning -ERESTART*.
159 * So we don't clear it here, and only callers who know they should do.
160 */
161 return false;
162}
163
164/*
165 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
166 * This is superfluous when called on current, the wakeup is a harmless no-op.
167 */
168void recalc_sigpending_and_wake(struct task_struct *t)
169{
170 if (recalc_sigpending_tsk(t))
171 signal_wake_up(t, 0);
172}
173
174void recalc_sigpending(void)
175{
176 if (!recalc_sigpending_tsk(current) && !freezing(current) &&
177 !klp_patch_pending(current))
178 clear_thread_flag(TIF_SIGPENDING);
179
180}
181EXPORT_SYMBOL(recalc_sigpending);
182
183void calculate_sigpending(void)
184{
185 /* Have any signals or users of TIF_SIGPENDING been delayed
186 * until after fork?
187 */
188 spin_lock_irq(&current->sighand->siglock);
189 set_tsk_thread_flag(current, TIF_SIGPENDING);
190 recalc_sigpending();
191 spin_unlock_irq(&current->sighand->siglock);
192}
193
194/* Given the mask, find the first available signal that should be serviced. */
195
196#define SYNCHRONOUS_MASK \
197 (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
198 sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
199
200int next_signal(struct sigpending *pending, sigset_t *mask)
201{
202 unsigned long i, *s, *m, x;
203 int sig = 0;
204
205 s = pending->signal.sig;
206 m = mask->sig;
207
208 /*
209 * Handle the first word specially: it contains the
210 * synchronous signals that need to be dequeued first.
211 */
212 x = *s &~ *m;
213 if (x) {
214 if (x & SYNCHRONOUS_MASK)
215 x &= SYNCHRONOUS_MASK;
216 sig = ffz(~x) + 1;
217 return sig;
218 }
219
220 switch (_NSIG_WORDS) {
221 default:
222 for (i = 1; i < _NSIG_WORDS; ++i) {
223 x = *++s &~ *++m;
224 if (!x)
225 continue;
226 sig = ffz(~x) + i*_NSIG_BPW + 1;
227 break;
228 }
229 break;
230
231 case 2:
232 x = s[1] &~ m[1];
233 if (!x)
234 break;
235 sig = ffz(~x) + _NSIG_BPW + 1;
236 break;
237
238 case 1:
239 /* Nothing to do */
240 break;
241 }
242
243 return sig;
244}
245
246static inline void print_dropped_signal(int sig)
247{
248 static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
249
250 if (!print_fatal_signals)
251 return;
252
253 if (!__ratelimit(&ratelimit_state))
254 return;
255
256 pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
257 current->comm, current->pid, sig);
258}
259
260/**
261 * task_set_jobctl_pending - set jobctl pending bits
262 * @task: target task
263 * @mask: pending bits to set
264 *
265 * Clear @mask from @task->jobctl. @mask must be subset of
266 * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
267 * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is
268 * cleared. If @task is already being killed or exiting, this function
269 * becomes noop.
270 *
271 * CONTEXT:
272 * Must be called with @task->sighand->siglock held.
273 *
274 * RETURNS:
275 * %true if @mask is set, %false if made noop because @task was dying.
276 */
277bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
278{
279 BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
280 JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
281 BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
282
283 if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
284 return false;
285
286 if (mask & JOBCTL_STOP_SIGMASK)
287 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
288
289 task->jobctl |= mask;
290 return true;
291}
292
293/**
294 * task_clear_jobctl_trapping - clear jobctl trapping bit
295 * @task: target task
296 *
297 * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
298 * Clear it and wake up the ptracer. Note that we don't need any further
299 * locking. @task->siglock guarantees that @task->parent points to the
300 * ptracer.
301 *
302 * CONTEXT:
303 * Must be called with @task->sighand->siglock held.
304 */
305void task_clear_jobctl_trapping(struct task_struct *task)
306{
307 if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
308 task->jobctl &= ~JOBCTL_TRAPPING;
309 smp_mb(); /* advised by wake_up_bit() */
310 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
311 }
312}
313
314/**
315 * task_clear_jobctl_pending - clear jobctl pending bits
316 * @task: target task
317 * @mask: pending bits to clear
318 *
319 * Clear @mask from @task->jobctl. @mask must be subset of
320 * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other
321 * STOP bits are cleared together.
322 *
323 * If clearing of @mask leaves no stop or trap pending, this function calls
324 * task_clear_jobctl_trapping().
325 *
326 * CONTEXT:
327 * Must be called with @task->sighand->siglock held.
328 */
329void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
330{
331 BUG_ON(mask & ~JOBCTL_PENDING_MASK);
332
333 if (mask & JOBCTL_STOP_PENDING)
334 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
335
336 task->jobctl &= ~mask;
337
338 if (!(task->jobctl & JOBCTL_PENDING_MASK))
339 task_clear_jobctl_trapping(task);
340}
341
342/**
343 * task_participate_group_stop - participate in a group stop
344 * @task: task participating in a group stop
345 *
346 * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
347 * Group stop states are cleared and the group stop count is consumed if
348 * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group
349 * stop, the appropriate %SIGNAL_* flags are set.
350 *
351 * CONTEXT:
352 * Must be called with @task->sighand->siglock held.
353 *
354 * RETURNS:
355 * %true if group stop completion should be notified to the parent, %false
356 * otherwise.
357 */
358static bool task_participate_group_stop(struct task_struct *task)
359{
360 struct signal_struct *sig = task->signal;
361 bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
362
363 WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
364
365 task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
366
367 if (!consume)
368 return false;
369
370 if (!WARN_ON_ONCE(sig->group_stop_count == 0))
371 sig->group_stop_count--;
372
373 /*
374 * Tell the caller to notify completion iff we are entering into a
375 * fresh group stop. Read comment in do_signal_stop() for details.
376 */
377 if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
378 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
379 return true;
380 }
381 return false;
382}
383
384void task_join_group_stop(struct task_struct *task)
385{
386 /* Have the new thread join an on-going signal group stop */
387 unsigned long jobctl = current->jobctl;
388 if (jobctl & JOBCTL_STOP_PENDING) {
389 struct signal_struct *sig = current->signal;
390 unsigned long signr = jobctl & JOBCTL_STOP_SIGMASK;
391 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
392 if (task_set_jobctl_pending(task, signr | gstop)) {
393 sig->group_stop_count++;
394 }
395 }
396}
397
398/*
399 * allocate a new signal queue record
400 * - this may be called without locks if and only if t == current, otherwise an
401 * appropriate lock must be held to stop the target task from exiting
402 */
403static struct sigqueue *
404__sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
405{
406 struct sigqueue *q = NULL;
407 struct user_struct *user;
408
409 /*
410 * Protect access to @t credentials. This can go away when all
411 * callers hold rcu read lock.
412 */
413 rcu_read_lock();
414 user = get_uid(__task_cred(t)->user);
415 atomic_inc(&user->sigpending);
416 rcu_read_unlock();
417
418 if (override_rlimit ||
419 atomic_read(&user->sigpending) <=
420 task_rlimit(t, RLIMIT_SIGPENDING)) {
421 q = kmem_cache_alloc(sigqueue_cachep, flags);
422 } else {
423 print_dropped_signal(sig);
424 }
425
426 if (unlikely(q == NULL)) {
427 atomic_dec(&user->sigpending);
428 free_uid(user);
429 } else {
430 INIT_LIST_HEAD(&q->list);
431 q->flags = 0;
432 q->user = user;
433 }
434
435 return q;
436}
437
438static void __sigqueue_free(struct sigqueue *q)
439{
440 if (q->flags & SIGQUEUE_PREALLOC)
441 return;
442 atomic_dec(&q->user->sigpending);
443 free_uid(q->user);
444 kmem_cache_free(sigqueue_cachep, q);
445}
446
447void flush_sigqueue(struct sigpending *queue)
448{
449 struct sigqueue *q;
450
451 sigemptyset(&queue->signal);
452 while (!list_empty(&queue->list)) {
453 q = list_entry(queue->list.next, struct sigqueue , list);
454 list_del_init(&q->list);
455 __sigqueue_free(q);
456 }
457}
458
459/*
460 * Flush all pending signals for this kthread.
461 */
462void flush_signals(struct task_struct *t)
463{
464 unsigned long flags;
465
466 spin_lock_irqsave(&t->sighand->siglock, flags);
467 clear_tsk_thread_flag(t, TIF_SIGPENDING);
468 flush_sigqueue(&t->pending);
469 flush_sigqueue(&t->signal->shared_pending);
470 spin_unlock_irqrestore(&t->sighand->siglock, flags);
471}
472EXPORT_SYMBOL(flush_signals);
473
474#ifdef CONFIG_POSIX_TIMERS
475static void __flush_itimer_signals(struct sigpending *pending)
476{
477 sigset_t signal, retain;
478 struct sigqueue *q, *n;
479
480 signal = pending->signal;
481 sigemptyset(&retain);
482
483 list_for_each_entry_safe(q, n, &pending->list, list) {
484 int sig = q->info.si_signo;
485
486 if (likely(q->info.si_code != SI_TIMER)) {
487 sigaddset(&retain, sig);
488 } else {
489 sigdelset(&signal, sig);
490 list_del_init(&q->list);
491 __sigqueue_free(q);
492 }
493 }
494
495 sigorsets(&pending->signal, &signal, &retain);
496}
497
498void flush_itimer_signals(void)
499{
500 struct task_struct *tsk = current;
501 unsigned long flags;
502
503 spin_lock_irqsave(&tsk->sighand->siglock, flags);
504 __flush_itimer_signals(&tsk->pending);
505 __flush_itimer_signals(&tsk->signal->shared_pending);
506 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
507}
508#endif
509
510void ignore_signals(struct task_struct *t)
511{
512 int i;
513
514 for (i = 0; i < _NSIG; ++i)
515 t->sighand->action[i].sa.sa_handler = SIG_IGN;
516
517 flush_signals(t);
518}
519
520/*
521 * Flush all handlers for a task.
522 */
523
524void
525flush_signal_handlers(struct task_struct *t, int force_default)
526{
527 int i;
528 struct k_sigaction *ka = &t->sighand->action[0];
529 for (i = _NSIG ; i != 0 ; i--) {
530 if (force_default || ka->sa.sa_handler != SIG_IGN)
531 ka->sa.sa_handler = SIG_DFL;
532 ka->sa.sa_flags = 0;
533#ifdef __ARCH_HAS_SA_RESTORER
534 ka->sa.sa_restorer = NULL;
535#endif
536 sigemptyset(&ka->sa.sa_mask);
537 ka++;
538 }
539}
540
541bool unhandled_signal(struct task_struct *tsk, int sig)
542{
543 void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
544 if (is_global_init(tsk))
545 return true;
546
547 if (handler != SIG_IGN && handler != SIG_DFL)
548 return false;
549
550 /* if ptraced, let the tracer determine */
551 return !tsk->ptrace;
552}
553
554static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *info,
555 bool *resched_timer)
556{
557 struct sigqueue *q, *first = NULL;
558
559 /*
560 * Collect the siginfo appropriate to this signal. Check if
561 * there is another siginfo for the same signal.
562 */
563 list_for_each_entry(q, &list->list, list) {
564 if (q->info.si_signo == sig) {
565 if (first)
566 goto still_pending;
567 first = q;
568 }
569 }
570
571 sigdelset(&list->signal, sig);
572
573 if (first) {
574still_pending:
575 list_del_init(&first->list);
576 copy_siginfo(info, &first->info);
577
578 *resched_timer =
579 (first->flags & SIGQUEUE_PREALLOC) &&
580 (info->si_code == SI_TIMER) &&
581 (info->si_sys_private);
582
583 __sigqueue_free(first);
584 } else {
585 /*
586 * Ok, it wasn't in the queue. This must be
587 * a fast-pathed signal or we must have been
588 * out of queue space. So zero out the info.
589 */
590 clear_siginfo(info);
591 info->si_signo = sig;
592 info->si_errno = 0;
593 info->si_code = SI_USER;
594 info->si_pid = 0;
595 info->si_uid = 0;
596 }
597}
598
599static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
600 kernel_siginfo_t *info, bool *resched_timer)
601{
602 int sig = next_signal(pending, mask);
603
604 if (sig)
605 collect_signal(sig, pending, info, resched_timer);
606 return sig;
607}
608
609/*
610 * Dequeue a signal and return the element to the caller, which is
611 * expected to free it.
612 *
613 * All callers have to hold the siglock.
614 */
615int dequeue_signal(struct task_struct *tsk, sigset_t *mask, kernel_siginfo_t *info)
616{
617 bool resched_timer = false;
618 int signr;
619
620 /* We only dequeue private signals from ourselves, we don't let
621 * signalfd steal them
622 */
623 signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
624 if (!signr) {
625 signr = __dequeue_signal(&tsk->signal->shared_pending,
626 mask, info, &resched_timer);
627#ifdef CONFIG_POSIX_TIMERS
628 /*
629 * itimer signal ?
630 *
631 * itimers are process shared and we restart periodic
632 * itimers in the signal delivery path to prevent DoS
633 * attacks in the high resolution timer case. This is
634 * compliant with the old way of self-restarting
635 * itimers, as the SIGALRM is a legacy signal and only
636 * queued once. Changing the restart behaviour to
637 * restart the timer in the signal dequeue path is
638 * reducing the timer noise on heavy loaded !highres
639 * systems too.
640 */
641 if (unlikely(signr == SIGALRM)) {
642 struct hrtimer *tmr = &tsk->signal->real_timer;
643
644 if (!hrtimer_is_queued(tmr) &&
645 tsk->signal->it_real_incr != 0) {
646 hrtimer_forward(tmr, tmr->base->get_time(),
647 tsk->signal->it_real_incr);
648 hrtimer_restart(tmr);
649 }
650 }
651#endif
652 }
653
654 recalc_sigpending();
655 if (!signr)
656 return 0;
657
658 if (unlikely(sig_kernel_stop(signr))) {
659 /*
660 * Set a marker that we have dequeued a stop signal. Our
661 * caller might release the siglock and then the pending
662 * stop signal it is about to process is no longer in the
663 * pending bitmasks, but must still be cleared by a SIGCONT
664 * (and overruled by a SIGKILL). So those cases clear this
665 * shared flag after we've set it. Note that this flag may
666 * remain set after the signal we return is ignored or
667 * handled. That doesn't matter because its only purpose
668 * is to alert stop-signal processing code when another
669 * processor has come along and cleared the flag.
670 */
671 current->jobctl |= JOBCTL_STOP_DEQUEUED;
672 }
673#ifdef CONFIG_POSIX_TIMERS
674 if (resched_timer) {
675 /*
676 * Release the siglock to ensure proper locking order
677 * of timer locks outside of siglocks. Note, we leave
678 * irqs disabled here, since the posix-timers code is
679 * about to disable them again anyway.
680 */
681 spin_unlock(&tsk->sighand->siglock);
682 posixtimer_rearm(info);
683 spin_lock(&tsk->sighand->siglock);
684
685 /* Don't expose the si_sys_private value to userspace */
686 info->si_sys_private = 0;
687 }
688#endif
689 return signr;
690}
691EXPORT_SYMBOL_GPL(dequeue_signal);
692
693static int dequeue_synchronous_signal(kernel_siginfo_t *info)
694{
695 struct task_struct *tsk = current;
696 struct sigpending *pending = &tsk->pending;
697 struct sigqueue *q, *sync = NULL;
698
699 /*
700 * Might a synchronous signal be in the queue?
701 */
702 if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK))
703 return 0;
704
705 /*
706 * Return the first synchronous signal in the queue.
707 */
708 list_for_each_entry(q, &pending->list, list) {
709 /* Synchronous signals have a postive si_code */
710 if ((q->info.si_code > SI_USER) &&
711 (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) {
712 sync = q;
713 goto next;
714 }
715 }
716 return 0;
717next:
718 /*
719 * Check if there is another siginfo for the same signal.
720 */
721 list_for_each_entry_continue(q, &pending->list, list) {
722 if (q->info.si_signo == sync->info.si_signo)
723 goto still_pending;
724 }
725
726 sigdelset(&pending->signal, sync->info.si_signo);
727 recalc_sigpending();
728still_pending:
729 list_del_init(&sync->list);
730 copy_siginfo(info, &sync->info);
731 __sigqueue_free(sync);
732 return info->si_signo;
733}
734
735/*
736 * Tell a process that it has a new active signal..
737 *
738 * NOTE! we rely on the previous spin_lock to
739 * lock interrupts for us! We can only be called with
740 * "siglock" held, and the local interrupt must
741 * have been disabled when that got acquired!
742 *
743 * No need to set need_resched since signal event passing
744 * goes through ->blocked
745 */
746void signal_wake_up_state(struct task_struct *t, unsigned int state)
747{
748 set_tsk_thread_flag(t, TIF_SIGPENDING);
749 /*
750 * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
751 * case. We don't check t->state here because there is a race with it
752 * executing another processor and just now entering stopped state.
753 * By using wake_up_state, we ensure the process will wake up and
754 * handle its death signal.
755 */
756 if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
757 kick_process(t);
758}
759
760/*
761 * Remove signals in mask from the pending set and queue.
762 * Returns 1 if any signals were found.
763 *
764 * All callers must be holding the siglock.
765 */
766static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
767{
768 struct sigqueue *q, *n;
769 sigset_t m;
770
771 sigandsets(&m, mask, &s->signal);
772 if (sigisemptyset(&m))
773 return;
774
775 sigandnsets(&s->signal, &s->signal, mask);
776 list_for_each_entry_safe(q, n, &s->list, list) {
777 if (sigismember(mask, q->info.si_signo)) {
778 list_del_init(&q->list);
779 __sigqueue_free(q);
780 }
781 }
782}
783
784static inline int is_si_special(const struct kernel_siginfo *info)
785{
786 return info <= SEND_SIG_PRIV;
787}
788
789static inline bool si_fromuser(const struct kernel_siginfo *info)
790{
791 return info == SEND_SIG_NOINFO ||
792 (!is_si_special(info) && SI_FROMUSER(info));
793}
794
795/*
796 * called with RCU read lock from check_kill_permission()
797 */
798static bool kill_ok_by_cred(struct task_struct *t)
799{
800 const struct cred *cred = current_cred();
801 const struct cred *tcred = __task_cred(t);
802
803 return uid_eq(cred->euid, tcred->suid) ||
804 uid_eq(cred->euid, tcred->uid) ||
805 uid_eq(cred->uid, tcred->suid) ||
806 uid_eq(cred->uid, tcred->uid) ||
807 ns_capable(tcred->user_ns, CAP_KILL);
808}
809
810/*
811 * Bad permissions for sending the signal
812 * - the caller must hold the RCU read lock
813 */
814static int check_kill_permission(int sig, struct kernel_siginfo *info,
815 struct task_struct *t)
816{
817 struct pid *sid;
818 int error;
819
820 if (!valid_signal(sig))
821 return -EINVAL;
822
823 if (!si_fromuser(info))
824 return 0;
825
826 error = audit_signal_info(sig, t); /* Let audit system see the signal */
827 if (error)
828 return error;
829
830 if (!same_thread_group(current, t) &&
831 !kill_ok_by_cred(t)) {
832 switch (sig) {
833 case SIGCONT:
834 sid = task_session(t);
835 /*
836 * We don't return the error if sid == NULL. The
837 * task was unhashed, the caller must notice this.
838 */
839 if (!sid || sid == task_session(current))
840 break;
841 default:
842 return -EPERM;
843 }
844 }
845
846 return security_task_kill(t, info, sig, NULL);
847}
848
849/**
850 * ptrace_trap_notify - schedule trap to notify ptracer
851 * @t: tracee wanting to notify tracer
852 *
853 * This function schedules sticky ptrace trap which is cleared on the next
854 * TRAP_STOP to notify ptracer of an event. @t must have been seized by
855 * ptracer.
856 *
857 * If @t is running, STOP trap will be taken. If trapped for STOP and
858 * ptracer is listening for events, tracee is woken up so that it can
859 * re-trap for the new event. If trapped otherwise, STOP trap will be
860 * eventually taken without returning to userland after the existing traps
861 * are finished by PTRACE_CONT.
862 *
863 * CONTEXT:
864 * Must be called with @task->sighand->siglock held.
865 */
866static void ptrace_trap_notify(struct task_struct *t)
867{
868 WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
869 assert_spin_locked(&t->sighand->siglock);
870
871 task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
872 ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
873}
874
875/*
876 * Handle magic process-wide effects of stop/continue signals. Unlike
877 * the signal actions, these happen immediately at signal-generation
878 * time regardless of blocking, ignoring, or handling. This does the
879 * actual continuing for SIGCONT, but not the actual stopping for stop
880 * signals. The process stop is done as a signal action for SIG_DFL.
881 *
882 * Returns true if the signal should be actually delivered, otherwise
883 * it should be dropped.
884 */
885static bool prepare_signal(int sig, struct task_struct *p, bool force)
886{
887 struct signal_struct *signal = p->signal;
888 struct task_struct *t;
889 sigset_t flush;
890
891 if (signal->flags & (SIGNAL_GROUP_EXIT | SIGNAL_GROUP_COREDUMP)) {
892 if (!(signal->flags & SIGNAL_GROUP_EXIT))
893 return sig == SIGKILL;
894 /*
895 * The process is in the middle of dying, nothing to do.
896 */
897 } else if (sig_kernel_stop(sig)) {
898 /*
899 * This is a stop signal. Remove SIGCONT from all queues.
900 */
901 siginitset(&flush, sigmask(SIGCONT));
902 flush_sigqueue_mask(&flush, &signal->shared_pending);
903 for_each_thread(p, t)
904 flush_sigqueue_mask(&flush, &t->pending);
905 } else if (sig == SIGCONT) {
906 unsigned int why;
907 /*
908 * Remove all stop signals from all queues, wake all threads.
909 */
910 siginitset(&flush, SIG_KERNEL_STOP_MASK);
911 flush_sigqueue_mask(&flush, &signal->shared_pending);
912 for_each_thread(p, t) {
913 flush_sigqueue_mask(&flush, &t->pending);
914 task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
915 if (likely(!(t->ptrace & PT_SEIZED)))
916 wake_up_state(t, __TASK_STOPPED);
917 else
918 ptrace_trap_notify(t);
919 }
920
921 /*
922 * Notify the parent with CLD_CONTINUED if we were stopped.
923 *
924 * If we were in the middle of a group stop, we pretend it
925 * was already finished, and then continued. Since SIGCHLD
926 * doesn't queue we report only CLD_STOPPED, as if the next
927 * CLD_CONTINUED was dropped.
928 */
929 why = 0;
930 if (signal->flags & SIGNAL_STOP_STOPPED)
931 why |= SIGNAL_CLD_CONTINUED;
932 else if (signal->group_stop_count)
933 why |= SIGNAL_CLD_STOPPED;
934
935 if (why) {
936 /*
937 * The first thread which returns from do_signal_stop()
938 * will take ->siglock, notice SIGNAL_CLD_MASK, and
939 * notify its parent. See get_signal().
940 */
941 signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
942 signal->group_stop_count = 0;
943 signal->group_exit_code = 0;
944 }
945 }
946
947 return !sig_ignored(p, sig, force);
948}
949
950/*
951 * Test if P wants to take SIG. After we've checked all threads with this,
952 * it's equivalent to finding no threads not blocking SIG. Any threads not
953 * blocking SIG were ruled out because they are not running and already
954 * have pending signals. Such threads will dequeue from the shared queue
955 * as soon as they're available, so putting the signal on the shared queue
956 * will be equivalent to sending it to one such thread.
957 */
958static inline bool wants_signal(int sig, struct task_struct *p)
959{
960 if (sigismember(&p->blocked, sig))
961 return false;
962
963 if (p->flags & PF_EXITING)
964 return false;
965
966 if (sig == SIGKILL)
967 return true;
968
969 if (task_is_stopped_or_traced(p))
970 return false;
971
972 return task_curr(p) || !signal_pending(p);
973}
974
975static void complete_signal(int sig, struct task_struct *p, enum pid_type type)
976{
977 struct signal_struct *signal = p->signal;
978 struct task_struct *t;
979
980 /*
981 * Now find a thread we can wake up to take the signal off the queue.
982 *
983 * If the main thread wants the signal, it gets first crack.
984 * Probably the least surprising to the average bear.
985 */
986 if (wants_signal(sig, p))
987 t = p;
988 else if ((type == PIDTYPE_PID) || thread_group_empty(p))
989 /*
990 * There is just one thread and it does not need to be woken.
991 * It will dequeue unblocked signals before it runs again.
992 */
993 return;
994 else {
995 /*
996 * Otherwise try to find a suitable thread.
997 */
998 t = signal->curr_target;
999 while (!wants_signal(sig, t)) {
1000 t = next_thread(t);
1001 if (t == signal->curr_target)
1002 /*
1003 * No thread needs to be woken.
1004 * Any eligible threads will see
1005 * the signal in the queue soon.
1006 */
1007 return;
1008 }
1009 signal->curr_target = t;
1010 }
1011
1012 /*
1013 * Found a killable thread. If the signal will be fatal,
1014 * then start taking the whole group down immediately.
1015 */
1016 if (sig_fatal(p, sig) &&
1017 !(signal->flags & SIGNAL_GROUP_EXIT) &&
1018 !sigismember(&t->real_blocked, sig) &&
1019 (sig == SIGKILL || !p->ptrace)) {
1020 /*
1021 * This signal will be fatal to the whole group.
1022 */
1023 if (!sig_kernel_coredump(sig)) {
1024 /*
1025 * Start a group exit and wake everybody up.
1026 * This way we don't have other threads
1027 * running and doing things after a slower
1028 * thread has the fatal signal pending.
1029 */
1030 signal->flags = SIGNAL_GROUP_EXIT;
1031 signal->group_exit_code = sig;
1032 signal->group_stop_count = 0;
1033 t = p;
1034 do {
1035 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1036 sigaddset(&t->pending.signal, SIGKILL);
1037 signal_wake_up(t, 1);
1038 } while_each_thread(p, t);
1039 return;
1040 }
1041 }
1042
1043 /*
1044 * The signal is already in the shared-pending queue.
1045 * Tell the chosen thread to wake up and dequeue it.
1046 */
1047 signal_wake_up(t, sig == SIGKILL);
1048 return;
1049}
1050
1051static inline bool legacy_queue(struct sigpending *signals, int sig)
1052{
1053 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1054}
1055
1056#ifdef CONFIG_USER_NS
1057static inline void userns_fixup_signal_uid(struct kernel_siginfo *info, struct task_struct *t)
1058{
1059 if (current_user_ns() == task_cred_xxx(t, user_ns))
1060 return;
1061
1062 if (SI_FROMKERNEL(info))
1063 return;
1064
1065 rcu_read_lock();
1066 info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns),
1067 make_kuid(current_user_ns(), info->si_uid));
1068 rcu_read_unlock();
1069}
1070#else
1071static inline void userns_fixup_signal_uid(struct kernel_siginfo *info, struct task_struct *t)
1072{
1073 return;
1074}
1075#endif
1076
1077static int __send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
1078 enum pid_type type, int from_ancestor_ns)
1079{
1080 struct sigpending *pending;
1081 struct sigqueue *q;
1082 int override_rlimit;
1083 int ret = 0, result;
1084
1085 assert_spin_locked(&t->sighand->siglock);
1086
1087 result = TRACE_SIGNAL_IGNORED;
1088 if (!prepare_signal(sig, t,
1089 from_ancestor_ns || (info == SEND_SIG_PRIV)))
1090 goto ret;
1091
1092 pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1093 /*
1094 * Short-circuit ignored signals and support queuing
1095 * exactly one non-rt signal, so that we can get more
1096 * detailed information about the cause of the signal.
1097 */
1098 result = TRACE_SIGNAL_ALREADY_PENDING;
1099 if (legacy_queue(pending, sig))
1100 goto ret;
1101
1102 result = TRACE_SIGNAL_DELIVERED;
1103 /*
1104 * Skip useless siginfo allocation for SIGKILL and kernel threads.
1105 */
1106 if ((sig == SIGKILL) || (t->flags & PF_KTHREAD))
1107 goto out_set;
1108
1109 /*
1110 * Real-time signals must be queued if sent by sigqueue, or
1111 * some other real-time mechanism. It is implementation
1112 * defined whether kill() does so. We attempt to do so, on
1113 * the principle of least surprise, but since kill is not
1114 * allowed to fail with EAGAIN when low on memory we just
1115 * make sure at least one signal gets delivered and don't
1116 * pass on the info struct.
1117 */
1118 if (sig < SIGRTMIN)
1119 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1120 else
1121 override_rlimit = 0;
1122
1123 q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit);
1124 if (q) {
1125 list_add_tail(&q->list, &pending->list);
1126 switch ((unsigned long) info) {
1127 case (unsigned long) SEND_SIG_NOINFO:
1128 clear_siginfo(&q->info);
1129 q->info.si_signo = sig;
1130 q->info.si_errno = 0;
1131 q->info.si_code = SI_USER;
1132 q->info.si_pid = task_tgid_nr_ns(current,
1133 task_active_pid_ns(t));
1134 q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
1135 break;
1136 case (unsigned long) SEND_SIG_PRIV:
1137 clear_siginfo(&q->info);
1138 q->info.si_signo = sig;
1139 q->info.si_errno = 0;
1140 q->info.si_code = SI_KERNEL;
1141 q->info.si_pid = 0;
1142 q->info.si_uid = 0;
1143 break;
1144 default:
1145 copy_siginfo(&q->info, info);
1146 if (from_ancestor_ns)
1147 q->info.si_pid = 0;
1148 break;
1149 }
1150
1151 userns_fixup_signal_uid(&q->info, t);
1152
1153 } else if (!is_si_special(info)) {
1154 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
1155 /*
1156 * Queue overflow, abort. We may abort if the
1157 * signal was rt and sent by user using something
1158 * other than kill().
1159 */
1160 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1161 ret = -EAGAIN;
1162 goto ret;
1163 } else {
1164 /*
1165 * This is a silent loss of information. We still
1166 * send the signal, but the *info bits are lost.
1167 */
1168 result = TRACE_SIGNAL_LOSE_INFO;
1169 }
1170 }
1171
1172out_set:
1173 signalfd_notify(t, sig);
1174 sigaddset(&pending->signal, sig);
1175
1176 /* Let multiprocess signals appear after on-going forks */
1177 if (type > PIDTYPE_TGID) {
1178 struct multiprocess_signals *delayed;
1179 hlist_for_each_entry(delayed, &t->signal->multiprocess, node) {
1180 sigset_t *signal = &delayed->signal;
1181 /* Can't queue both a stop and a continue signal */
1182 if (sig == SIGCONT)
1183 sigdelsetmask(signal, SIG_KERNEL_STOP_MASK);
1184 else if (sig_kernel_stop(sig))
1185 sigdelset(signal, SIGCONT);
1186 sigaddset(signal, sig);
1187 }
1188 }
1189
1190 complete_signal(sig, t, type);
1191ret:
1192 trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
1193 return ret;
1194}
1195
1196static int send_signal(int sig, struct kernel_siginfo *info, struct task_struct *t,
1197 enum pid_type type)
1198{
1199 int from_ancestor_ns = 0;
1200
1201#ifdef CONFIG_PID_NS
1202 from_ancestor_ns = si_fromuser(info) &&
1203 !task_pid_nr_ns(current, task_active_pid_ns(t));
1204#endif
1205
1206 return __send_signal(sig, info, t, type, from_ancestor_ns);
1207}
1208
1209static void print_fatal_signal(int signr)
1210{
1211 struct pt_regs *regs = signal_pt_regs();
1212 pr_info("potentially unexpected fatal signal %d.\n", signr);
1213
1214#if defined(__i386__) && !defined(__arch_um__)
1215 pr_info("code at %08lx: ", regs->ip);
1216 {
1217 int i;
1218 for (i = 0; i < 16; i++) {
1219 unsigned char insn;
1220
1221 if (get_user(insn, (unsigned char *)(regs->ip + i)))
1222 break;
1223 pr_cont("%02x ", insn);
1224 }
1225 }
1226 pr_cont("\n");
1227#endif
1228 preempt_disable();
1229 show_regs(regs);
1230 preempt_enable();
1231}
1232
1233static int __init setup_print_fatal_signals(char *str)
1234{
1235 get_option (&str, &print_fatal_signals);
1236
1237 return 1;
1238}
1239
1240__setup("print-fatal-signals=", setup_print_fatal_signals);
1241
1242int
1243__group_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1244{
1245 return send_signal(sig, info, p, PIDTYPE_TGID);
1246}
1247
1248int do_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p,
1249 enum pid_type type)
1250{
1251 unsigned long flags;
1252 int ret = -ESRCH;
1253
1254 if (lock_task_sighand(p, &flags)) {
1255 ret = send_signal(sig, info, p, type);
1256 unlock_task_sighand(p, &flags);
1257 }
1258
1259 return ret;
1260}
1261
1262/*
1263 * Force a signal that the process can't ignore: if necessary
1264 * we unblock the signal and change any SIG_IGN to SIG_DFL.
1265 *
1266 * Note: If we unblock the signal, we always reset it to SIG_DFL,
1267 * since we do not want to have a signal handler that was blocked
1268 * be invoked when user space had explicitly blocked it.
1269 *
1270 * We don't want to have recursive SIGSEGV's etc, for example,
1271 * that is why we also clear SIGNAL_UNKILLABLE.
1272 */
1273int
1274force_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *t)
1275{
1276 unsigned long int flags;
1277 int ret, blocked, ignored;
1278 struct k_sigaction *action;
1279
1280 spin_lock_irqsave(&t->sighand->siglock, flags);
1281 action = &t->sighand->action[sig-1];
1282 ignored = action->sa.sa_handler == SIG_IGN;
1283 blocked = sigismember(&t->blocked, sig);
1284 if (blocked || ignored) {
1285 action->sa.sa_handler = SIG_DFL;
1286 if (blocked) {
1287 sigdelset(&t->blocked, sig);
1288 recalc_sigpending_and_wake(t);
1289 }
1290 }
1291 /*
1292 * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
1293 * debugging to leave init killable.
1294 */
1295 if (action->sa.sa_handler == SIG_DFL && !t->ptrace)
1296 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1297 ret = send_signal(sig, info, t, PIDTYPE_PID);
1298 spin_unlock_irqrestore(&t->sighand->siglock, flags);
1299
1300 return ret;
1301}
1302
1303/*
1304 * Nuke all other threads in the group.
1305 */
1306int zap_other_threads(struct task_struct *p)
1307{
1308 struct task_struct *t = p;
1309 int count = 0;
1310
1311 p->signal->group_stop_count = 0;
1312
1313 while_each_thread(p, t) {
1314 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1315 count++;
1316
1317 /* Don't bother with already dead threads */
1318 if (t->exit_state)
1319 continue;
1320 sigaddset(&t->pending.signal, SIGKILL);
1321 signal_wake_up(t, 1);
1322 }
1323
1324 return count;
1325}
1326
1327struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1328 unsigned long *flags)
1329{
1330 struct sighand_struct *sighand;
1331
1332 rcu_read_lock();
1333 for (;;) {
1334 sighand = rcu_dereference(tsk->sighand);
1335 if (unlikely(sighand == NULL))
1336 break;
1337
1338 /*
1339 * This sighand can be already freed and even reused, but
1340 * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1341 * initializes ->siglock: this slab can't go away, it has
1342 * the same object type, ->siglock can't be reinitialized.
1343 *
1344 * We need to ensure that tsk->sighand is still the same
1345 * after we take the lock, we can race with de_thread() or
1346 * __exit_signal(). In the latter case the next iteration
1347 * must see ->sighand == NULL.
1348 */
1349 spin_lock_irqsave(&sighand->siglock, *flags);
1350 if (likely(sighand == tsk->sighand))
1351 break;
1352 spin_unlock_irqrestore(&sighand->siglock, *flags);
1353 }
1354 rcu_read_unlock();
1355
1356 return sighand;
1357}
1358
1359/*
1360 * send signal info to all the members of a group
1361 */
1362int group_send_sig_info(int sig, struct kernel_siginfo *info,
1363 struct task_struct *p, enum pid_type type)
1364{
1365 int ret;
1366
1367 rcu_read_lock();
1368 ret = check_kill_permission(sig, info, p);
1369 rcu_read_unlock();
1370
1371 if (!ret && sig)
1372 ret = do_send_sig_info(sig, info, p, type);
1373
1374 return ret;
1375}
1376
1377/*
1378 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1379 * control characters do (^C, ^Z etc)
1380 * - the caller must hold at least a readlock on tasklist_lock
1381 */
1382int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp)
1383{
1384 struct task_struct *p = NULL;
1385 int retval, success;
1386
1387 success = 0;
1388 retval = -ESRCH;
1389 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1390 int err = group_send_sig_info(sig, info, p, PIDTYPE_PGID);
1391 success |= !err;
1392 retval = err;
1393 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1394 return success ? 0 : retval;
1395}
1396
1397int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid)
1398{
1399 int error = -ESRCH;
1400 struct task_struct *p;
1401
1402 for (;;) {
1403 rcu_read_lock();
1404 p = pid_task(pid, PIDTYPE_PID);
1405 if (p)
1406 error = group_send_sig_info(sig, info, p, PIDTYPE_TGID);
1407 rcu_read_unlock();
1408 if (likely(!p || error != -ESRCH))
1409 return error;
1410
1411 /*
1412 * The task was unhashed in between, try again. If it
1413 * is dead, pid_task() will return NULL, if we race with
1414 * de_thread() it will find the new leader.
1415 */
1416 }
1417}
1418
1419static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid)
1420{
1421 int error;
1422 rcu_read_lock();
1423 error = kill_pid_info(sig, info, find_vpid(pid));
1424 rcu_read_unlock();
1425 return error;
1426}
1427
1428static inline bool kill_as_cred_perm(const struct cred *cred,
1429 struct task_struct *target)
1430{
1431 const struct cred *pcred = __task_cred(target);
1432
1433 return uid_eq(cred->euid, pcred->suid) ||
1434 uid_eq(cred->euid, pcred->uid) ||
1435 uid_eq(cred->uid, pcred->suid) ||
1436 uid_eq(cred->uid, pcred->uid);
1437}
1438
1439/* like kill_pid_info(), but doesn't use uid/euid of "current" */
1440int kill_pid_info_as_cred(int sig, struct kernel_siginfo *info, struct pid *pid,
1441 const struct cred *cred)
1442{
1443 int ret = -EINVAL;
1444 struct task_struct *p;
1445 unsigned long flags;
1446
1447 if (!valid_signal(sig))
1448 return ret;
1449
1450 rcu_read_lock();
1451 p = pid_task(pid, PIDTYPE_PID);
1452 if (!p) {
1453 ret = -ESRCH;
1454 goto out_unlock;
1455 }
1456 if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) {
1457 ret = -EPERM;
1458 goto out_unlock;
1459 }
1460 ret = security_task_kill(p, info, sig, cred);
1461 if (ret)
1462 goto out_unlock;
1463
1464 if (sig) {
1465 if (lock_task_sighand(p, &flags)) {
1466 ret = __send_signal(sig, info, p, PIDTYPE_TGID, 0);
1467 unlock_task_sighand(p, &flags);
1468 } else
1469 ret = -ESRCH;
1470 }
1471out_unlock:
1472 rcu_read_unlock();
1473 return ret;
1474}
1475EXPORT_SYMBOL_GPL(kill_pid_info_as_cred);
1476
1477/*
1478 * kill_something_info() interprets pid in interesting ways just like kill(2).
1479 *
1480 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1481 * is probably wrong. Should make it like BSD or SYSV.
1482 */
1483
1484static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid)
1485{
1486 int ret;
1487
1488 if (pid > 0) {
1489 rcu_read_lock();
1490 ret = kill_pid_info(sig, info, find_vpid(pid));
1491 rcu_read_unlock();
1492 return ret;
1493 }
1494
1495 /* -INT_MIN is undefined. Exclude this case to avoid a UBSAN warning */
1496 if (pid == INT_MIN)
1497 return -ESRCH;
1498
1499 read_lock(&tasklist_lock);
1500 if (pid != -1) {
1501 ret = __kill_pgrp_info(sig, info,
1502 pid ? find_vpid(-pid) : task_pgrp(current));
1503 } else {
1504 int retval = 0, count = 0;
1505 struct task_struct * p;
1506
1507 for_each_process(p) {
1508 if (task_pid_vnr(p) > 1 &&
1509 !same_thread_group(p, current)) {
1510 int err = group_send_sig_info(sig, info, p,
1511 PIDTYPE_MAX);
1512 ++count;
1513 if (err != -EPERM)
1514 retval = err;
1515 }
1516 }
1517 ret = count ? retval : -ESRCH;
1518 }
1519 read_unlock(&tasklist_lock);
1520
1521 return ret;
1522}
1523
1524/*
1525 * These are for backward compatibility with the rest of the kernel source.
1526 */
1527
1528int send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1529{
1530 /*
1531 * Make sure legacy kernel users don't send in bad values
1532 * (normal paths check this in check_kill_permission).
1533 */
1534 if (!valid_signal(sig))
1535 return -EINVAL;
1536
1537 return do_send_sig_info(sig, info, p, PIDTYPE_PID);
1538}
1539EXPORT_SYMBOL(send_sig_info);
1540
1541#define __si_special(priv) \
1542 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1543
1544int
1545send_sig(int sig, struct task_struct *p, int priv)
1546{
1547 return send_sig_info(sig, __si_special(priv), p);
1548}
1549EXPORT_SYMBOL(send_sig);
1550
1551void force_sig(int sig, struct task_struct *p)
1552{
1553 force_sig_info(sig, SEND_SIG_PRIV, p);
1554}
1555EXPORT_SYMBOL(force_sig);
1556
1557/*
1558 * When things go south during signal handling, we
1559 * will force a SIGSEGV. And if the signal that caused
1560 * the problem was already a SIGSEGV, we'll want to
1561 * make sure we don't even try to deliver the signal..
1562 */
1563void force_sigsegv(int sig, struct task_struct *p)
1564{
1565 if (sig == SIGSEGV) {
1566 unsigned long flags;
1567 spin_lock_irqsave(&p->sighand->siglock, flags);
1568 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1569 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1570 }
1571 force_sig(SIGSEGV, p);
1572}
1573
1574int force_sig_fault(int sig, int code, void __user *addr
1575 ___ARCH_SI_TRAPNO(int trapno)
1576 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1577 , struct task_struct *t)
1578{
1579 struct kernel_siginfo info;
1580
1581 clear_siginfo(&info);
1582 info.si_signo = sig;
1583 info.si_errno = 0;
1584 info.si_code = code;
1585 info.si_addr = addr;
1586#ifdef __ARCH_SI_TRAPNO
1587 info.si_trapno = trapno;
1588#endif
1589#ifdef __ia64__
1590 info.si_imm = imm;
1591 info.si_flags = flags;
1592 info.si_isr = isr;
1593#endif
1594 return force_sig_info(info.si_signo, &info, t);
1595}
1596
1597int send_sig_fault(int sig, int code, void __user *addr
1598 ___ARCH_SI_TRAPNO(int trapno)
1599 ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1600 , struct task_struct *t)
1601{
1602 struct kernel_siginfo info;
1603
1604 clear_siginfo(&info);
1605 info.si_signo = sig;
1606 info.si_errno = 0;
1607 info.si_code = code;
1608 info.si_addr = addr;
1609#ifdef __ARCH_SI_TRAPNO
1610 info.si_trapno = trapno;
1611#endif
1612#ifdef __ia64__
1613 info.si_imm = imm;
1614 info.si_flags = flags;
1615 info.si_isr = isr;
1616#endif
1617 return send_sig_info(info.si_signo, &info, t);
1618}
1619
1620int force_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1621{
1622 struct kernel_siginfo info;
1623
1624 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1625 clear_siginfo(&info);
1626 info.si_signo = SIGBUS;
1627 info.si_errno = 0;
1628 info.si_code = code;
1629 info.si_addr = addr;
1630 info.si_addr_lsb = lsb;
1631 return force_sig_info(info.si_signo, &info, t);
1632}
1633
1634int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1635{
1636 struct kernel_siginfo info;
1637
1638 WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1639 clear_siginfo(&info);
1640 info.si_signo = SIGBUS;
1641 info.si_errno = 0;
1642 info.si_code = code;
1643 info.si_addr = addr;
1644 info.si_addr_lsb = lsb;
1645 return send_sig_info(info.si_signo, &info, t);
1646}
1647EXPORT_SYMBOL(send_sig_mceerr);
1648
1649int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
1650{
1651 struct kernel_siginfo info;
1652
1653 clear_siginfo(&info);
1654 info.si_signo = SIGSEGV;
1655 info.si_errno = 0;
1656 info.si_code = SEGV_BNDERR;
1657 info.si_addr = addr;
1658 info.si_lower = lower;
1659 info.si_upper = upper;
1660 return force_sig_info(info.si_signo, &info, current);
1661}
1662
1663#ifdef SEGV_PKUERR
1664int force_sig_pkuerr(void __user *addr, u32 pkey)
1665{
1666 struct kernel_siginfo info;
1667
1668 clear_siginfo(&info);
1669 info.si_signo = SIGSEGV;
1670 info.si_errno = 0;
1671 info.si_code = SEGV_PKUERR;
1672 info.si_addr = addr;
1673 info.si_pkey = pkey;
1674 return force_sig_info(info.si_signo, &info, current);
1675}
1676#endif
1677
1678/* For the crazy architectures that include trap information in
1679 * the errno field, instead of an actual errno value.
1680 */
1681int force_sig_ptrace_errno_trap(int errno, void __user *addr)
1682{
1683 struct kernel_siginfo info;
1684
1685 clear_siginfo(&info);
1686 info.si_signo = SIGTRAP;
1687 info.si_errno = errno;
1688 info.si_code = TRAP_HWBKPT;
1689 info.si_addr = addr;
1690 return force_sig_info(info.si_signo, &info, current);
1691}
1692
1693int kill_pgrp(struct pid *pid, int sig, int priv)
1694{
1695 int ret;
1696
1697 read_lock(&tasklist_lock);
1698 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1699 read_unlock(&tasklist_lock);
1700
1701 return ret;
1702}
1703EXPORT_SYMBOL(kill_pgrp);
1704
1705int kill_pid(struct pid *pid, int sig, int priv)
1706{
1707 return kill_pid_info(sig, __si_special(priv), pid);
1708}
1709EXPORT_SYMBOL(kill_pid);
1710
1711/*
1712 * These functions support sending signals using preallocated sigqueue
1713 * structures. This is needed "because realtime applications cannot
1714 * afford to lose notifications of asynchronous events, like timer
1715 * expirations or I/O completions". In the case of POSIX Timers
1716 * we allocate the sigqueue structure from the timer_create. If this
1717 * allocation fails we are able to report the failure to the application
1718 * with an EAGAIN error.
1719 */
1720struct sigqueue *sigqueue_alloc(void)
1721{
1722 struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1723
1724 if (q)
1725 q->flags |= SIGQUEUE_PREALLOC;
1726
1727 return q;
1728}
1729
1730void sigqueue_free(struct sigqueue *q)
1731{
1732 unsigned long flags;
1733 spinlock_t *lock = &current->sighand->siglock;
1734
1735 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1736 /*
1737 * We must hold ->siglock while testing q->list
1738 * to serialize with collect_signal() or with
1739 * __exit_signal()->flush_sigqueue().
1740 */
1741 spin_lock_irqsave(lock, flags);
1742 q->flags &= ~SIGQUEUE_PREALLOC;
1743 /*
1744 * If it is queued it will be freed when dequeued,
1745 * like the "regular" sigqueue.
1746 */
1747 if (!list_empty(&q->list))
1748 q = NULL;
1749 spin_unlock_irqrestore(lock, flags);
1750
1751 if (q)
1752 __sigqueue_free(q);
1753}
1754
1755int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)
1756{
1757 int sig = q->info.si_signo;
1758 struct sigpending *pending;
1759 struct task_struct *t;
1760 unsigned long flags;
1761 int ret, result;
1762
1763 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1764
1765 ret = -1;
1766 rcu_read_lock();
1767 t = pid_task(pid, type);
1768 if (!t || !likely(lock_task_sighand(t, &flags)))
1769 goto ret;
1770
1771 ret = 1; /* the signal is ignored */
1772 result = TRACE_SIGNAL_IGNORED;
1773 if (!prepare_signal(sig, t, false))
1774 goto out;
1775
1776 ret = 0;
1777 if (unlikely(!list_empty(&q->list))) {
1778 /*
1779 * If an SI_TIMER entry is already queue just increment
1780 * the overrun count.
1781 */
1782 BUG_ON(q->info.si_code != SI_TIMER);
1783 q->info.si_overrun++;
1784 result = TRACE_SIGNAL_ALREADY_PENDING;
1785 goto out;
1786 }
1787 q->info.si_overrun = 0;
1788
1789 signalfd_notify(t, sig);
1790 pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1791 list_add_tail(&q->list, &pending->list);
1792 sigaddset(&pending->signal, sig);
1793 complete_signal(sig, t, type);
1794 result = TRACE_SIGNAL_DELIVERED;
1795out:
1796 trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
1797 unlock_task_sighand(t, &flags);
1798ret:
1799 rcu_read_unlock();
1800 return ret;
1801}
1802
1803/*
1804 * Let a parent know about the death of a child.
1805 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1806 *
1807 * Returns true if our parent ignored us and so we've switched to
1808 * self-reaping.
1809 */
1810bool do_notify_parent(struct task_struct *tsk, int sig)
1811{
1812 struct kernel_siginfo info;
1813 unsigned long flags;
1814 struct sighand_struct *psig;
1815 bool autoreap = false;
1816 u64 utime, stime;
1817
1818 BUG_ON(sig == -1);
1819
1820 /* do_notify_parent_cldstop should have been called instead. */
1821 BUG_ON(task_is_stopped_or_traced(tsk));
1822
1823 BUG_ON(!tsk->ptrace &&
1824 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1825
1826 if (sig != SIGCHLD) {
1827 /*
1828 * This is only possible if parent == real_parent.
1829 * Check if it has changed security domain.
1830 */
1831 if (tsk->parent_exec_id != tsk->parent->self_exec_id)
1832 sig = SIGCHLD;
1833 }
1834
1835 clear_siginfo(&info);
1836 info.si_signo = sig;
1837 info.si_errno = 0;
1838 /*
1839 * We are under tasklist_lock here so our parent is tied to
1840 * us and cannot change.
1841 *
1842 * task_active_pid_ns will always return the same pid namespace
1843 * until a task passes through release_task.
1844 *
1845 * write_lock() currently calls preempt_disable() which is the
1846 * same as rcu_read_lock(), but according to Oleg, this is not
1847 * correct to rely on this
1848 */
1849 rcu_read_lock();
1850 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
1851 info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
1852 task_uid(tsk));
1853 rcu_read_unlock();
1854
1855 task_cputime(tsk, &utime, &stime);
1856 info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
1857 info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
1858
1859 info.si_status = tsk->exit_code & 0x7f;
1860 if (tsk->exit_code & 0x80)
1861 info.si_code = CLD_DUMPED;
1862 else if (tsk->exit_code & 0x7f)
1863 info.si_code = CLD_KILLED;
1864 else {
1865 info.si_code = CLD_EXITED;
1866 info.si_status = tsk->exit_code >> 8;
1867 }
1868
1869 psig = tsk->parent->sighand;
1870 spin_lock_irqsave(&psig->siglock, flags);
1871 if (!tsk->ptrace && sig == SIGCHLD &&
1872 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1873 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1874 /*
1875 * We are exiting and our parent doesn't care. POSIX.1
1876 * defines special semantics for setting SIGCHLD to SIG_IGN
1877 * or setting the SA_NOCLDWAIT flag: we should be reaped
1878 * automatically and not left for our parent's wait4 call.
1879 * Rather than having the parent do it as a magic kind of
1880 * signal handler, we just set this to tell do_exit that we
1881 * can be cleaned up without becoming a zombie. Note that
1882 * we still call __wake_up_parent in this case, because a
1883 * blocked sys_wait4 might now return -ECHILD.
1884 *
1885 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1886 * is implementation-defined: we do (if you don't want
1887 * it, just use SIG_IGN instead).
1888 */
1889 autoreap = true;
1890 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1891 sig = 0;
1892 }
1893 if (valid_signal(sig) && sig)
1894 __group_send_sig_info(sig, &info, tsk->parent);
1895 __wake_up_parent(tsk, tsk->parent);
1896 spin_unlock_irqrestore(&psig->siglock, flags);
1897
1898 return autoreap;
1899}
1900
1901/**
1902 * do_notify_parent_cldstop - notify parent of stopped/continued state change
1903 * @tsk: task reporting the state change
1904 * @for_ptracer: the notification is for ptracer
1905 * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
1906 *
1907 * Notify @tsk's parent that the stopped/continued state has changed. If
1908 * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
1909 * If %true, @tsk reports to @tsk->parent which should be the ptracer.
1910 *
1911 * CONTEXT:
1912 * Must be called with tasklist_lock at least read locked.
1913 */
1914static void do_notify_parent_cldstop(struct task_struct *tsk,
1915 bool for_ptracer, int why)
1916{
1917 struct kernel_siginfo info;
1918 unsigned long flags;
1919 struct task_struct *parent;
1920 struct sighand_struct *sighand;
1921 u64 utime, stime;
1922
1923 if (for_ptracer) {
1924 parent = tsk->parent;
1925 } else {
1926 tsk = tsk->group_leader;
1927 parent = tsk->real_parent;
1928 }
1929
1930 clear_siginfo(&info);
1931 info.si_signo = SIGCHLD;
1932 info.si_errno = 0;
1933 /*
1934 * see comment in do_notify_parent() about the following 4 lines
1935 */
1936 rcu_read_lock();
1937 info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
1938 info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
1939 rcu_read_unlock();
1940
1941 task_cputime(tsk, &utime, &stime);
1942 info.si_utime = nsec_to_clock_t(utime);
1943 info.si_stime = nsec_to_clock_t(stime);
1944
1945 info.si_code = why;
1946 switch (why) {
1947 case CLD_CONTINUED:
1948 info.si_status = SIGCONT;
1949 break;
1950 case CLD_STOPPED:
1951 info.si_status = tsk->signal->group_exit_code & 0x7f;
1952 break;
1953 case CLD_TRAPPED:
1954 info.si_status = tsk->exit_code & 0x7f;
1955 break;
1956 default:
1957 BUG();
1958 }
1959
1960 sighand = parent->sighand;
1961 spin_lock_irqsave(&sighand->siglock, flags);
1962 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1963 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1964 __group_send_sig_info(SIGCHLD, &info, parent);
1965 /*
1966 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1967 */
1968 __wake_up_parent(tsk, parent);
1969 spin_unlock_irqrestore(&sighand->siglock, flags);
1970}
1971
1972static inline bool may_ptrace_stop(void)
1973{
1974 if (!likely(current->ptrace))
1975 return false;
1976 /*
1977 * Are we in the middle of do_coredump?
1978 * If so and our tracer is also part of the coredump stopping
1979 * is a deadlock situation, and pointless because our tracer
1980 * is dead so don't allow us to stop.
1981 * If SIGKILL was already sent before the caller unlocked
1982 * ->siglock we must see ->core_state != NULL. Otherwise it
1983 * is safe to enter schedule().
1984 *
1985 * This is almost outdated, a task with the pending SIGKILL can't
1986 * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported
1987 * after SIGKILL was already dequeued.
1988 */
1989 if (unlikely(current->mm->core_state) &&
1990 unlikely(current->mm == current->parent->mm))
1991 return false;
1992
1993 return true;
1994}
1995
1996/*
1997 * Return non-zero if there is a SIGKILL that should be waking us up.
1998 * Called with the siglock held.
1999 */
2000static bool sigkill_pending(struct task_struct *tsk)
2001{
2002 return sigismember(&tsk->pending.signal, SIGKILL) ||
2003 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
2004}
2005
2006/*
2007 * This must be called with current->sighand->siglock held.
2008 *
2009 * This should be the path for all ptrace stops.
2010 * We always set current->last_siginfo while stopped here.
2011 * That makes it a way to test a stopped process for
2012 * being ptrace-stopped vs being job-control-stopped.
2013 *
2014 * If we actually decide not to stop at all because the tracer
2015 * is gone, we keep current->exit_code unless clear_code.
2016 */
2017static void ptrace_stop(int exit_code, int why, int clear_code, kernel_siginfo_t *info)
2018 __releases(&current->sighand->siglock)
2019 __acquires(&current->sighand->siglock)
2020{
2021 bool gstop_done = false;
2022
2023 if (arch_ptrace_stop_needed(exit_code, info)) {
2024 /*
2025 * The arch code has something special to do before a
2026 * ptrace stop. This is allowed to block, e.g. for faults
2027 * on user stack pages. We can't keep the siglock while
2028 * calling arch_ptrace_stop, so we must release it now.
2029 * To preserve proper semantics, we must do this before
2030 * any signal bookkeeping like checking group_stop_count.
2031 * Meanwhile, a SIGKILL could come in before we retake the
2032 * siglock. That must prevent us from sleeping in TASK_TRACED.
2033 * So after regaining the lock, we must check for SIGKILL.
2034 */
2035 spin_unlock_irq(&current->sighand->siglock);
2036 arch_ptrace_stop(exit_code, info);
2037 spin_lock_irq(&current->sighand->siglock);
2038 if (sigkill_pending(current))
2039 return;
2040 }
2041
2042 set_special_state(TASK_TRACED);
2043
2044 /*
2045 * We're committing to trapping. TRACED should be visible before
2046 * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
2047 * Also, transition to TRACED and updates to ->jobctl should be
2048 * atomic with respect to siglock and should be done after the arch
2049 * hook as siglock is released and regrabbed across it.
2050 *
2051 * TRACER TRACEE
2052 *
2053 * ptrace_attach()
2054 * [L] wait_on_bit(JOBCTL_TRAPPING) [S] set_special_state(TRACED)
2055 * do_wait()
2056 * set_current_state() smp_wmb();
2057 * ptrace_do_wait()
2058 * wait_task_stopped()
2059 * task_stopped_code()
2060 * [L] task_is_traced() [S] task_clear_jobctl_trapping();
2061 */
2062 smp_wmb();
2063
2064 current->last_siginfo = info;
2065 current->exit_code = exit_code;
2066
2067 /*
2068 * If @why is CLD_STOPPED, we're trapping to participate in a group
2069 * stop. Do the bookkeeping. Note that if SIGCONT was delievered
2070 * across siglock relocks since INTERRUPT was scheduled, PENDING
2071 * could be clear now. We act as if SIGCONT is received after
2072 * TASK_TRACED is entered - ignore it.
2073 */
2074 if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
2075 gstop_done = task_participate_group_stop(current);
2076
2077 /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
2078 task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
2079 if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
2080 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
2081
2082 /* entering a trap, clear TRAPPING */
2083 task_clear_jobctl_trapping(current);
2084
2085 spin_unlock_irq(&current->sighand->siglock);
2086 read_lock(&tasklist_lock);
2087 if (may_ptrace_stop()) {
2088 /*
2089 * Notify parents of the stop.
2090 *
2091 * While ptraced, there are two parents - the ptracer and
2092 * the real_parent of the group_leader. The ptracer should
2093 * know about every stop while the real parent is only
2094 * interested in the completion of group stop. The states
2095 * for the two don't interact with each other. Notify
2096 * separately unless they're gonna be duplicates.
2097 */
2098 do_notify_parent_cldstop(current, true, why);
2099 if (gstop_done && ptrace_reparented(current))
2100 do_notify_parent_cldstop(current, false, why);
2101
2102 /*
2103 * Don't want to allow preemption here, because
2104 * sys_ptrace() needs this task to be inactive.
2105 *
2106 * XXX: implement read_unlock_no_resched().
2107 */
2108 preempt_disable();
2109 read_unlock(&tasklist_lock);
2110 preempt_enable_no_resched();
2111 freezable_schedule();
2112 } else {
2113 /*
2114 * By the time we got the lock, our tracer went away.
2115 * Don't drop the lock yet, another tracer may come.
2116 *
2117 * If @gstop_done, the ptracer went away between group stop
2118 * completion and here. During detach, it would have set
2119 * JOBCTL_STOP_PENDING on us and we'll re-enter
2120 * TASK_STOPPED in do_signal_stop() on return, so notifying
2121 * the real parent of the group stop completion is enough.
2122 */
2123 if (gstop_done)
2124 do_notify_parent_cldstop(current, false, why);
2125
2126 /* tasklist protects us from ptrace_freeze_traced() */
2127 __set_current_state(TASK_RUNNING);
2128 if (clear_code)
2129 current->exit_code = 0;
2130 read_unlock(&tasklist_lock);
2131 }
2132
2133 /*
2134 * We are back. Now reacquire the siglock before touching
2135 * last_siginfo, so that we are sure to have synchronized with
2136 * any signal-sending on another CPU that wants to examine it.
2137 */
2138 spin_lock_irq(&current->sighand->siglock);
2139 current->last_siginfo = NULL;
2140
2141 /* LISTENING can be set only during STOP traps, clear it */
2142 current->jobctl &= ~JOBCTL_LISTENING;
2143
2144 /*
2145 * Queued signals ignored us while we were stopped for tracing.
2146 * So check for any that we should take before resuming user mode.
2147 * This sets TIF_SIGPENDING, but never clears it.
2148 */
2149 recalc_sigpending_tsk(current);
2150}
2151
2152static void ptrace_do_notify(int signr, int exit_code, int why)
2153{
2154 kernel_siginfo_t info;
2155
2156 clear_siginfo(&info);
2157 info.si_signo = signr;
2158 info.si_code = exit_code;
2159 info.si_pid = task_pid_vnr(current);
2160 info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2161
2162 /* Let the debugger run. */
2163 ptrace_stop(exit_code, why, 1, &info);
2164}
2165
2166void ptrace_notify(int exit_code)
2167{
2168 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2169 if (unlikely(current->task_works))
2170 task_work_run();
2171
2172 spin_lock_irq(&current->sighand->siglock);
2173 ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED);
2174 spin_unlock_irq(&current->sighand->siglock);
2175}
2176
2177/**
2178 * do_signal_stop - handle group stop for SIGSTOP and other stop signals
2179 * @signr: signr causing group stop if initiating
2180 *
2181 * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
2182 * and participate in it. If already set, participate in the existing
2183 * group stop. If participated in a group stop (and thus slept), %true is
2184 * returned with siglock released.
2185 *
2186 * If ptraced, this function doesn't handle stop itself. Instead,
2187 * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
2188 * untouched. The caller must ensure that INTERRUPT trap handling takes
2189 * places afterwards.
2190 *
2191 * CONTEXT:
2192 * Must be called with @current->sighand->siglock held, which is released
2193 * on %true return.
2194 *
2195 * RETURNS:
2196 * %false if group stop is already cancelled or ptrace trap is scheduled.
2197 * %true if participated in group stop.
2198 */
2199static bool do_signal_stop(int signr)
2200 __releases(&current->sighand->siglock)
2201{
2202 struct signal_struct *sig = current->signal;
2203
2204 if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2205 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2206 struct task_struct *t;
2207
2208 /* signr will be recorded in task->jobctl for retries */
2209 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2210
2211 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2212 unlikely(signal_group_exit(sig)))
2213 return false;
2214 /*
2215 * There is no group stop already in progress. We must
2216 * initiate one now.
2217 *
2218 * While ptraced, a task may be resumed while group stop is
2219 * still in effect and then receive a stop signal and
2220 * initiate another group stop. This deviates from the
2221 * usual behavior as two consecutive stop signals can't
2222 * cause two group stops when !ptraced. That is why we
2223 * also check !task_is_stopped(t) below.
2224 *
2225 * The condition can be distinguished by testing whether
2226 * SIGNAL_STOP_STOPPED is already set. Don't generate
2227 * group_exit_code in such case.
2228 *
2229 * This is not necessary for SIGNAL_STOP_CONTINUED because
2230 * an intervening stop signal is required to cause two
2231 * continued events regardless of ptrace.
2232 */
2233 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2234 sig->group_exit_code = signr;
2235
2236 sig->group_stop_count = 0;
2237
2238 if (task_set_jobctl_pending(current, signr | gstop))
2239 sig->group_stop_count++;
2240
2241 t = current;
2242 while_each_thread(current, t) {
2243 /*
2244 * Setting state to TASK_STOPPED for a group
2245 * stop is always done with the siglock held,
2246 * so this check has no races.
2247 */
2248 if (!task_is_stopped(t) &&
2249 task_set_jobctl_pending(t, signr | gstop)) {
2250 sig->group_stop_count++;
2251 if (likely(!(t->ptrace & PT_SEIZED)))
2252 signal_wake_up(t, 0);
2253 else
2254 ptrace_trap_notify(t);
2255 }
2256 }
2257 }
2258
2259 if (likely(!current->ptrace)) {
2260 int notify = 0;
2261
2262 /*
2263 * If there are no other threads in the group, or if there
2264 * is a group stop in progress and we are the last to stop,
2265 * report to the parent.
2266 */
2267 if (task_participate_group_stop(current))
2268 notify = CLD_STOPPED;
2269
2270 set_special_state(TASK_STOPPED);
2271 spin_unlock_irq(&current->sighand->siglock);
2272
2273 /*
2274 * Notify the parent of the group stop completion. Because
2275 * we're not holding either the siglock or tasklist_lock
2276 * here, ptracer may attach inbetween; however, this is for
2277 * group stop and should always be delivered to the real
2278 * parent of the group leader. The new ptracer will get
2279 * its notification when this task transitions into
2280 * TASK_TRACED.
2281 */
2282 if (notify) {
2283 read_lock(&tasklist_lock);
2284 do_notify_parent_cldstop(current, false, notify);
2285 read_unlock(&tasklist_lock);
2286 }
2287
2288 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2289 freezable_schedule();
2290 return true;
2291 } else {
2292 /*
2293 * While ptraced, group stop is handled by STOP trap.
2294 * Schedule it and let the caller deal with it.
2295 */
2296 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2297 return false;
2298 }
2299}
2300
2301/**
2302 * do_jobctl_trap - take care of ptrace jobctl traps
2303 *
2304 * When PT_SEIZED, it's used for both group stop and explicit
2305 * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with
2306 * accompanying siginfo. If stopped, lower eight bits of exit_code contain
2307 * the stop signal; otherwise, %SIGTRAP.
2308 *
2309 * When !PT_SEIZED, it's used only for group stop trap with stop signal
2310 * number as exit_code and no siginfo.
2311 *
2312 * CONTEXT:
2313 * Must be called with @current->sighand->siglock held, which may be
2314 * released and re-acquired before returning with intervening sleep.
2315 */
2316static void do_jobctl_trap(void)
2317{
2318 struct signal_struct *signal = current->signal;
2319 int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2320
2321 if (current->ptrace & PT_SEIZED) {
2322 if (!signal->group_stop_count &&
2323 !(signal->flags & SIGNAL_STOP_STOPPED))
2324 signr = SIGTRAP;
2325 WARN_ON_ONCE(!signr);
2326 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2327 CLD_STOPPED);
2328 } else {
2329 WARN_ON_ONCE(!signr);
2330 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2331 current->exit_code = 0;
2332 }
2333}
2334
2335static int ptrace_signal(int signr, kernel_siginfo_t *info)
2336{
2337 /*
2338 * We do not check sig_kernel_stop(signr) but set this marker
2339 * unconditionally because we do not know whether debugger will
2340 * change signr. This flag has no meaning unless we are going
2341 * to stop after return from ptrace_stop(). In this case it will
2342 * be checked in do_signal_stop(), we should only stop if it was
2343 * not cleared by SIGCONT while we were sleeping. See also the
2344 * comment in dequeue_signal().
2345 */
2346 current->jobctl |= JOBCTL_STOP_DEQUEUED;
2347 ptrace_stop(signr, CLD_TRAPPED, 0, info);
2348
2349 /* We're back. Did the debugger cancel the sig? */
2350 signr = current->exit_code;
2351 if (signr == 0)
2352 return signr;
2353
2354 current->exit_code = 0;
2355
2356 /*
2357 * Update the siginfo structure if the signal has
2358 * changed. If the debugger wanted something
2359 * specific in the siginfo structure then it should
2360 * have updated *info via PTRACE_SETSIGINFO.
2361 */
2362 if (signr != info->si_signo) {
2363 clear_siginfo(info);
2364 info->si_signo = signr;
2365 info->si_errno = 0;
2366 info->si_code = SI_USER;
2367 rcu_read_lock();
2368 info->si_pid = task_pid_vnr(current->parent);
2369 info->si_uid = from_kuid_munged(current_user_ns(),
2370 task_uid(current->parent));
2371 rcu_read_unlock();
2372 }
2373
2374 /* If the (new) signal is now blocked, requeue it. */
2375 if (sigismember(&current->blocked, signr)) {
2376 send_signal(signr, info, current, PIDTYPE_PID);
2377 signr = 0;
2378 }
2379
2380 return signr;
2381}
2382
2383bool get_signal(struct ksignal *ksig)
2384{
2385 struct sighand_struct *sighand = current->sighand;
2386 struct signal_struct *signal = current->signal;
2387 int signr;
2388
2389 if (unlikely(current->task_works))
2390 task_work_run();
2391
2392 if (unlikely(uprobe_deny_signal()))
2393 return false;
2394
2395 /*
2396 * Do this once, we can't return to user-mode if freezing() == T.
2397 * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2398 * thus do not need another check after return.
2399 */
2400 try_to_freeze();
2401
2402relock:
2403 spin_lock_irq(&sighand->siglock);
2404 /*
2405 * Every stopped thread goes here after wakeup. Check to see if
2406 * we should notify the parent, prepare_signal(SIGCONT) encodes
2407 * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2408 */
2409 if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2410 int why;
2411
2412 if (signal->flags & SIGNAL_CLD_CONTINUED)
2413 why = CLD_CONTINUED;
2414 else
2415 why = CLD_STOPPED;
2416
2417 signal->flags &= ~SIGNAL_CLD_MASK;
2418
2419 spin_unlock_irq(&sighand->siglock);
2420
2421 /*
2422 * Notify the parent that we're continuing. This event is
2423 * always per-process and doesn't make whole lot of sense
2424 * for ptracers, who shouldn't consume the state via
2425 * wait(2) either, but, for backward compatibility, notify
2426 * the ptracer of the group leader too unless it's gonna be
2427 * a duplicate.
2428 */
2429 read_lock(&tasklist_lock);
2430 do_notify_parent_cldstop(current, false, why);
2431
2432 if (ptrace_reparented(current->group_leader))
2433 do_notify_parent_cldstop(current->group_leader,
2434 true, why);
2435 read_unlock(&tasklist_lock);
2436
2437 goto relock;
2438 }
2439
2440 /* Has this task already been marked for death? */
2441 if (signal_group_exit(signal)) {
2442 ksig->info.si_signo = signr = SIGKILL;
2443 sigdelset(&current->pending.signal, SIGKILL);
2444 recalc_sigpending();
2445 goto fatal;
2446 }
2447
2448 for (;;) {
2449 struct k_sigaction *ka;
2450
2451 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2452 do_signal_stop(0))
2453 goto relock;
2454
2455 if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) {
2456 do_jobctl_trap();
2457 spin_unlock_irq(&sighand->siglock);
2458 goto relock;
2459 }
2460
2461 /*
2462 * Signals generated by the execution of an instruction
2463 * need to be delivered before any other pending signals
2464 * so that the instruction pointer in the signal stack
2465 * frame points to the faulting instruction.
2466 */
2467 signr = dequeue_synchronous_signal(&ksig->info);
2468 if (!signr)
2469 signr = dequeue_signal(current, &current->blocked, &ksig->info);
2470
2471 if (!signr)
2472 break; /* will return 0 */
2473
2474 if (unlikely(current->ptrace) && signr != SIGKILL) {
2475 signr = ptrace_signal(signr, &ksig->info);
2476 if (!signr)
2477 continue;
2478 }
2479
2480 ka = &sighand->action[signr-1];
2481
2482 /* Trace actually delivered signals. */
2483 trace_signal_deliver(signr, &ksig->info, ka);
2484
2485 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
2486 continue;
2487 if (ka->sa.sa_handler != SIG_DFL) {
2488 /* Run the handler. */
2489 ksig->ka = *ka;
2490
2491 if (ka->sa.sa_flags & SA_ONESHOT)
2492 ka->sa.sa_handler = SIG_DFL;
2493
2494 break; /* will return non-zero "signr" value */
2495 }
2496
2497 /*
2498 * Now we are doing the default action for this signal.
2499 */
2500 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2501 continue;
2502
2503 /*
2504 * Global init gets no signals it doesn't want.
2505 * Container-init gets no signals it doesn't want from same
2506 * container.
2507 *
2508 * Note that if global/container-init sees a sig_kernel_only()
2509 * signal here, the signal must have been generated internally
2510 * or must have come from an ancestor namespace. In either
2511 * case, the signal cannot be dropped.
2512 */
2513 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2514 !sig_kernel_only(signr))
2515 continue;
2516
2517 if (sig_kernel_stop(signr)) {
2518 /*
2519 * The default action is to stop all threads in
2520 * the thread group. The job control signals
2521 * do nothing in an orphaned pgrp, but SIGSTOP
2522 * always works. Note that siglock needs to be
2523 * dropped during the call to is_orphaned_pgrp()
2524 * because of lock ordering with tasklist_lock.
2525 * This allows an intervening SIGCONT to be posted.
2526 * We need to check for that and bail out if necessary.
2527 */
2528 if (signr != SIGSTOP) {
2529 spin_unlock_irq(&sighand->siglock);
2530
2531 /* signals can be posted during this window */
2532
2533 if (is_current_pgrp_orphaned())
2534 goto relock;
2535
2536 spin_lock_irq(&sighand->siglock);
2537 }
2538
2539 if (likely(do_signal_stop(ksig->info.si_signo))) {
2540 /* It released the siglock. */
2541 goto relock;
2542 }
2543
2544 /*
2545 * We didn't actually stop, due to a race
2546 * with SIGCONT or something like that.
2547 */
2548 continue;
2549 }
2550
2551 fatal:
2552 spin_unlock_irq(&sighand->siglock);
2553
2554 /*
2555 * Anything else is fatal, maybe with a core dump.
2556 */
2557 current->flags |= PF_SIGNALED;
2558
2559 if (sig_kernel_coredump(signr)) {
2560 if (print_fatal_signals)
2561 print_fatal_signal(ksig->info.si_signo);
2562 proc_coredump_connector(current);
2563 /*
2564 * If it was able to dump core, this kills all
2565 * other threads in the group and synchronizes with
2566 * their demise. If we lost the race with another
2567 * thread getting here, it set group_exit_code
2568 * first and our do_group_exit call below will use
2569 * that value and ignore the one we pass it.
2570 */
2571 do_coredump(&ksig->info);
2572 }
2573
2574 /*
2575 * Death signals, no core dump.
2576 */
2577 do_group_exit(ksig->info.si_signo);
2578 /* NOTREACHED */
2579 }
2580 spin_unlock_irq(&sighand->siglock);
2581
2582 ksig->sig = signr;
2583 return ksig->sig > 0;
2584}
2585
2586/**
2587 * signal_delivered -
2588 * @ksig: kernel signal struct
2589 * @stepping: nonzero if debugger single-step or block-step in use
2590 *
2591 * This function should be called when a signal has successfully been
2592 * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2593 * is always blocked, and the signal itself is blocked unless %SA_NODEFER
2594 * is set in @ksig->ka.sa.sa_flags. Tracing is notified.
2595 */
2596static void signal_delivered(struct ksignal *ksig, int stepping)
2597{
2598 sigset_t blocked;
2599
2600 /* A signal was successfully delivered, and the
2601 saved sigmask was stored on the signal frame,
2602 and will be restored by sigreturn. So we can
2603 simply clear the restore sigmask flag. */
2604 clear_restore_sigmask();
2605
2606 sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2607 if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2608 sigaddset(&blocked, ksig->sig);
2609 set_current_blocked(&blocked);
2610 tracehook_signal_handler(stepping);
2611}
2612
2613void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2614{
2615 if (failed)
2616 force_sigsegv(ksig->sig, current);
2617 else
2618 signal_delivered(ksig, stepping);
2619}
2620
2621/*
2622 * It could be that complete_signal() picked us to notify about the
2623 * group-wide signal. Other threads should be notified now to take
2624 * the shared signals in @which since we will not.
2625 */
2626static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2627{
2628 sigset_t retarget;
2629 struct task_struct *t;
2630
2631 sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2632 if (sigisemptyset(&retarget))
2633 return;
2634
2635 t = tsk;
2636 while_each_thread(tsk, t) {
2637 if (t->flags & PF_EXITING)
2638 continue;
2639
2640 if (!has_pending_signals(&retarget, &t->blocked))
2641 continue;
2642 /* Remove the signals this thread can handle. */
2643 sigandsets(&retarget, &retarget, &t->blocked);
2644
2645 if (!signal_pending(t))
2646 signal_wake_up(t, 0);
2647
2648 if (sigisemptyset(&retarget))
2649 break;
2650 }
2651}
2652
2653void exit_signals(struct task_struct *tsk)
2654{
2655 int group_stop = 0;
2656 sigset_t unblocked;
2657
2658 /*
2659 * @tsk is about to have PF_EXITING set - lock out users which
2660 * expect stable threadgroup.
2661 */
2662 cgroup_threadgroup_change_begin(tsk);
2663
2664 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2665 tsk->flags |= PF_EXITING;
2666 cgroup_threadgroup_change_end(tsk);
2667 return;
2668 }
2669
2670 spin_lock_irq(&tsk->sighand->siglock);
2671 /*
2672 * From now this task is not visible for group-wide signals,
2673 * see wants_signal(), do_signal_stop().
2674 */
2675 tsk->flags |= PF_EXITING;
2676
2677 cgroup_threadgroup_change_end(tsk);
2678
2679 if (!signal_pending(tsk))
2680 goto out;
2681
2682 unblocked = tsk->blocked;
2683 signotset(&unblocked);
2684 retarget_shared_pending(tsk, &unblocked);
2685
2686 if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2687 task_participate_group_stop(tsk))
2688 group_stop = CLD_STOPPED;
2689out:
2690 spin_unlock_irq(&tsk->sighand->siglock);
2691
2692 /*
2693 * If group stop has completed, deliver the notification. This
2694 * should always go to the real parent of the group leader.
2695 */
2696 if (unlikely(group_stop)) {
2697 read_lock(&tasklist_lock);
2698 do_notify_parent_cldstop(tsk, false, group_stop);
2699 read_unlock(&tasklist_lock);
2700 }
2701}
2702
2703/*
2704 * System call entry points.
2705 */
2706
2707/**
2708 * sys_restart_syscall - restart a system call
2709 */
2710SYSCALL_DEFINE0(restart_syscall)
2711{
2712 struct restart_block *restart = &current->restart_block;
2713 return restart->fn(restart);
2714}
2715
2716long do_no_restart_syscall(struct restart_block *param)
2717{
2718 return -EINTR;
2719}
2720
2721static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
2722{
2723 if (signal_pending(tsk) && !thread_group_empty(tsk)) {
2724 sigset_t newblocked;
2725 /* A set of now blocked but previously unblocked signals. */
2726 sigandnsets(&newblocked, newset, &current->blocked);
2727 retarget_shared_pending(tsk, &newblocked);
2728 }
2729 tsk->blocked = *newset;
2730 recalc_sigpending();
2731}
2732
2733/**
2734 * set_current_blocked - change current->blocked mask
2735 * @newset: new mask
2736 *
2737 * It is wrong to change ->blocked directly, this helper should be used
2738 * to ensure the process can't miss a shared signal we are going to block.
2739 */
2740void set_current_blocked(sigset_t *newset)
2741{
2742 sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2743 __set_current_blocked(newset);
2744}
2745
2746void __set_current_blocked(const sigset_t *newset)
2747{
2748 struct task_struct *tsk = current;
2749
2750 /*
2751 * In case the signal mask hasn't changed, there is nothing we need
2752 * to do. The current->blocked shouldn't be modified by other task.
2753 */
2754 if (sigequalsets(&tsk->blocked, newset))
2755 return;
2756
2757 spin_lock_irq(&tsk->sighand->siglock);
2758 __set_task_blocked(tsk, newset);
2759 spin_unlock_irq(&tsk->sighand->siglock);
2760}
2761
2762/*
2763 * This is also useful for kernel threads that want to temporarily
2764 * (or permanently) block certain signals.
2765 *
2766 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2767 * interface happily blocks "unblockable" signals like SIGKILL
2768 * and friends.
2769 */
2770int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2771{
2772 struct task_struct *tsk = current;
2773 sigset_t newset;
2774
2775 /* Lockless, only current can change ->blocked, never from irq */
2776 if (oldset)
2777 *oldset = tsk->blocked;
2778
2779 switch (how) {
2780 case SIG_BLOCK:
2781 sigorsets(&newset, &tsk->blocked, set);
2782 break;
2783 case SIG_UNBLOCK:
2784 sigandnsets(&newset, &tsk->blocked, set);
2785 break;
2786 case SIG_SETMASK:
2787 newset = *set;
2788 break;
2789 default:
2790 return -EINVAL;
2791 }
2792
2793 __set_current_blocked(&newset);
2794 return 0;
2795}
2796EXPORT_SYMBOL(sigprocmask);
2797
2798/*
2799 * The api helps set app-provided sigmasks.
2800 *
2801 * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
2802 * epoll_pwait where a new sigmask is passed from userland for the syscalls.
2803 */
2804int set_user_sigmask(const sigset_t __user *usigmask, sigset_t *set,
2805 sigset_t *oldset, size_t sigsetsize)
2806{
2807 if (!usigmask)
2808 return 0;
2809
2810 if (sigsetsize != sizeof(sigset_t))
2811 return -EINVAL;
2812 if (copy_from_user(set, usigmask, sizeof(sigset_t)))
2813 return -EFAULT;
2814
2815 *oldset = current->blocked;
2816 set_current_blocked(set);
2817
2818 return 0;
2819}
2820EXPORT_SYMBOL(set_user_sigmask);
2821
2822#ifdef CONFIG_COMPAT
2823int set_compat_user_sigmask(const compat_sigset_t __user *usigmask,
2824 sigset_t *set, sigset_t *oldset,
2825 size_t sigsetsize)
2826{
2827 if (!usigmask)
2828 return 0;
2829
2830 if (sigsetsize != sizeof(compat_sigset_t))
2831 return -EINVAL;
2832 if (get_compat_sigset(set, usigmask))
2833 return -EFAULT;
2834
2835 *oldset = current->blocked;
2836 set_current_blocked(set);
2837
2838 return 0;
2839}
2840EXPORT_SYMBOL(set_compat_user_sigmask);
2841#endif
2842
2843/*
2844 * restore_user_sigmask:
2845 * usigmask: sigmask passed in from userland.
2846 * sigsaved: saved sigmask when the syscall started and changed the sigmask to
2847 * usigmask.
2848 *
2849 * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
2850 * epoll_pwait where a new sigmask is passed in from userland for the syscalls.
2851 */
2852void restore_user_sigmask(const void __user *usigmask, sigset_t *sigsaved)
2853{
2854
2855 if (!usigmask)
2856 return;
2857 /*
2858 * When signals are pending, do not restore them here.
2859 * Restoring sigmask here can lead to delivering signals that the above
2860 * syscalls are intended to block because of the sigmask passed in.
2861 */
2862 if (signal_pending(current)) {
2863 current->saved_sigmask = *sigsaved;
2864 set_restore_sigmask();
2865 return;
2866 }
2867
2868 /*
2869 * This is needed because the fast syscall return path does not restore
2870 * saved_sigmask when signals are not pending.
2871 */
2872 set_current_blocked(sigsaved);
2873}
2874EXPORT_SYMBOL(restore_user_sigmask);
2875
2876/**
2877 * sys_rt_sigprocmask - change the list of currently blocked signals
2878 * @how: whether to add, remove, or set signals
2879 * @nset: stores pending signals
2880 * @oset: previous value of signal mask if non-null
2881 * @sigsetsize: size of sigset_t type
2882 */
2883SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
2884 sigset_t __user *, oset, size_t, sigsetsize)
2885{
2886 sigset_t old_set, new_set;
2887 int error;
2888
2889 /* XXX: Don't preclude handling different sized sigset_t's. */
2890 if (sigsetsize != sizeof(sigset_t))
2891 return -EINVAL;
2892
2893 old_set = current->blocked;
2894
2895 if (nset) {
2896 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
2897 return -EFAULT;
2898 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2899
2900 error = sigprocmask(how, &new_set, NULL);
2901 if (error)
2902 return error;
2903 }
2904
2905 if (oset) {
2906 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
2907 return -EFAULT;
2908 }
2909
2910 return 0;
2911}
2912
2913#ifdef CONFIG_COMPAT
2914COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
2915 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
2916{
2917 sigset_t old_set = current->blocked;
2918
2919 /* XXX: Don't preclude handling different sized sigset_t's. */
2920 if (sigsetsize != sizeof(sigset_t))
2921 return -EINVAL;
2922
2923 if (nset) {
2924 sigset_t new_set;
2925 int error;
2926 if (get_compat_sigset(&new_set, nset))
2927 return -EFAULT;
2928 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2929
2930 error = sigprocmask(how, &new_set, NULL);
2931 if (error)
2932 return error;
2933 }
2934 return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
2935}
2936#endif
2937
2938static void do_sigpending(sigset_t *set)
2939{
2940 spin_lock_irq(&current->sighand->siglock);
2941 sigorsets(set, &current->pending.signal,
2942 &current->signal->shared_pending.signal);
2943 spin_unlock_irq(&current->sighand->siglock);
2944
2945 /* Outside the lock because only this thread touches it. */
2946 sigandsets(set, &current->blocked, set);
2947}
2948
2949/**
2950 * sys_rt_sigpending - examine a pending signal that has been raised
2951 * while blocked
2952 * @uset: stores pending signals
2953 * @sigsetsize: size of sigset_t type or larger
2954 */
2955SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
2956{
2957 sigset_t set;
2958
2959 if (sigsetsize > sizeof(*uset))
2960 return -EINVAL;
2961
2962 do_sigpending(&set);
2963
2964 if (copy_to_user(uset, &set, sigsetsize))
2965 return -EFAULT;
2966
2967 return 0;
2968}
2969
2970#ifdef CONFIG_COMPAT
2971COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
2972 compat_size_t, sigsetsize)
2973{
2974 sigset_t set;
2975
2976 if (sigsetsize > sizeof(*uset))
2977 return -EINVAL;
2978
2979 do_sigpending(&set);
2980
2981 return put_compat_sigset(uset, &set, sigsetsize);
2982}
2983#endif
2984
2985static const struct {
2986 unsigned char limit, layout;
2987} sig_sicodes[] = {
2988 [SIGILL] = { NSIGILL, SIL_FAULT },
2989 [SIGFPE] = { NSIGFPE, SIL_FAULT },
2990 [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
2991 [SIGBUS] = { NSIGBUS, SIL_FAULT },
2992 [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
2993#if defined(SIGEMT)
2994 [SIGEMT] = { NSIGEMT, SIL_FAULT },
2995#endif
2996 [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
2997 [SIGPOLL] = { NSIGPOLL, SIL_POLL },
2998 [SIGSYS] = { NSIGSYS, SIL_SYS },
2999};
3000
3001static bool known_siginfo_layout(unsigned sig, int si_code)
3002{
3003 if (si_code == SI_KERNEL)
3004 return true;
3005 else if ((si_code > SI_USER)) {
3006 if (sig_specific_sicodes(sig)) {
3007 if (si_code <= sig_sicodes[sig].limit)
3008 return true;
3009 }
3010 else if (si_code <= NSIGPOLL)
3011 return true;
3012 }
3013 else if (si_code >= SI_DETHREAD)
3014 return true;
3015 else if (si_code == SI_ASYNCNL)
3016 return true;
3017 return false;
3018}
3019
3020enum siginfo_layout siginfo_layout(unsigned sig, int si_code)
3021{
3022 enum siginfo_layout layout = SIL_KILL;
3023 if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
3024 if ((sig < ARRAY_SIZE(sig_sicodes)) &&
3025 (si_code <= sig_sicodes[sig].limit)) {
3026 layout = sig_sicodes[sig].layout;
3027 /* Handle the exceptions */
3028 if ((sig == SIGBUS) &&
3029 (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
3030 layout = SIL_FAULT_MCEERR;
3031 else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
3032 layout = SIL_FAULT_BNDERR;
3033#ifdef SEGV_PKUERR
3034 else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
3035 layout = SIL_FAULT_PKUERR;
3036#endif
3037 }
3038 else if (si_code <= NSIGPOLL)
3039 layout = SIL_POLL;
3040 } else {
3041 if (si_code == SI_TIMER)
3042 layout = SIL_TIMER;
3043 else if (si_code == SI_SIGIO)
3044 layout = SIL_POLL;
3045 else if (si_code < 0)
3046 layout = SIL_RT;
3047 }
3048 return layout;
3049}
3050
3051static inline char __user *si_expansion(const siginfo_t __user *info)
3052{
3053 return ((char __user *)info) + sizeof(struct kernel_siginfo);
3054}
3055
3056int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)
3057{
3058 char __user *expansion = si_expansion(to);
3059 if (copy_to_user(to, from , sizeof(struct kernel_siginfo)))
3060 return -EFAULT;
3061 if (clear_user(expansion, SI_EXPANSION_SIZE))
3062 return -EFAULT;
3063 return 0;
3064}
3065
3066static int post_copy_siginfo_from_user(kernel_siginfo_t *info,
3067 const siginfo_t __user *from)
3068{
3069 if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code))) {
3070 char __user *expansion = si_expansion(from);
3071 char buf[SI_EXPANSION_SIZE];
3072 int i;
3073 /*
3074 * An unknown si_code might need more than
3075 * sizeof(struct kernel_siginfo) bytes. Verify all of the
3076 * extra bytes are 0. This guarantees copy_siginfo_to_user
3077 * will return this data to userspace exactly.
3078 */
3079 if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE))
3080 return -EFAULT;
3081 for (i = 0; i < SI_EXPANSION_SIZE; i++) {
3082 if (buf[i] != 0)
3083 return -E2BIG;
3084 }
3085 }
3086 return 0;
3087}
3088
3089static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to,
3090 const siginfo_t __user *from)
3091{
3092 if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3093 return -EFAULT;
3094 to->si_signo = signo;
3095 return post_copy_siginfo_from_user(to, from);
3096}
3097
3098int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from)
3099{
3100 if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3101 return -EFAULT;
3102 return post_copy_siginfo_from_user(to, from);
3103}
3104
3105#ifdef CONFIG_COMPAT
3106int copy_siginfo_to_user32(struct compat_siginfo __user *to,
3107 const struct kernel_siginfo *from)
3108#if defined(CONFIG_X86_X32_ABI) || defined(CONFIG_IA32_EMULATION)
3109{
3110 return __copy_siginfo_to_user32(to, from, in_x32_syscall());
3111}
3112int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
3113 const struct kernel_siginfo *from, bool x32_ABI)
3114#endif
3115{
3116 struct compat_siginfo new;
3117 memset(&new, 0, sizeof(new));
3118
3119 new.si_signo = from->si_signo;
3120 new.si_errno = from->si_errno;
3121 new.si_code = from->si_code;
3122 switch(siginfo_layout(from->si_signo, from->si_code)) {
3123 case SIL_KILL:
3124 new.si_pid = from->si_pid;
3125 new.si_uid = from->si_uid;
3126 break;
3127 case SIL_TIMER:
3128 new.si_tid = from->si_tid;
3129 new.si_overrun = from->si_overrun;
3130 new.si_int = from->si_int;
3131 break;
3132 case SIL_POLL:
3133 new.si_band = from->si_band;
3134 new.si_fd = from->si_fd;
3135 break;
3136 case SIL_FAULT:
3137 new.si_addr = ptr_to_compat(from->si_addr);
3138#ifdef __ARCH_SI_TRAPNO
3139 new.si_trapno = from->si_trapno;
3140#endif
3141 break;
3142 case SIL_FAULT_MCEERR:
3143 new.si_addr = ptr_to_compat(from->si_addr);
3144#ifdef __ARCH_SI_TRAPNO
3145 new.si_trapno = from->si_trapno;
3146#endif
3147 new.si_addr_lsb = from->si_addr_lsb;
3148 break;
3149 case SIL_FAULT_BNDERR:
3150 new.si_addr = ptr_to_compat(from->si_addr);
3151#ifdef __ARCH_SI_TRAPNO
3152 new.si_trapno = from->si_trapno;
3153#endif
3154 new.si_lower = ptr_to_compat(from->si_lower);
3155 new.si_upper = ptr_to_compat(from->si_upper);
3156 break;
3157 case SIL_FAULT_PKUERR:
3158 new.si_addr = ptr_to_compat(from->si_addr);
3159#ifdef __ARCH_SI_TRAPNO
3160 new.si_trapno = from->si_trapno;
3161#endif
3162 new.si_pkey = from->si_pkey;
3163 break;
3164 case SIL_CHLD:
3165 new.si_pid = from->si_pid;
3166 new.si_uid = from->si_uid;
3167 new.si_status = from->si_status;
3168#ifdef CONFIG_X86_X32_ABI
3169 if (x32_ABI) {
3170 new._sifields._sigchld_x32._utime = from->si_utime;
3171 new._sifields._sigchld_x32._stime = from->si_stime;
3172 } else
3173#endif
3174 {
3175 new.si_utime = from->si_utime;
3176 new.si_stime = from->si_stime;
3177 }
3178 break;
3179 case SIL_RT:
3180 new.si_pid = from->si_pid;
3181 new.si_uid = from->si_uid;
3182 new.si_int = from->si_int;
3183 break;
3184 case SIL_SYS:
3185 new.si_call_addr = ptr_to_compat(from->si_call_addr);
3186 new.si_syscall = from->si_syscall;
3187 new.si_arch = from->si_arch;
3188 break;
3189 }
3190
3191 if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
3192 return -EFAULT;
3193
3194 return 0;
3195}
3196
3197static int post_copy_siginfo_from_user32(kernel_siginfo_t *to,
3198 const struct compat_siginfo *from)
3199{
3200 clear_siginfo(to);
3201 to->si_signo = from->si_signo;
3202 to->si_errno = from->si_errno;
3203 to->si_code = from->si_code;
3204 switch(siginfo_layout(from->si_signo, from->si_code)) {
3205 case SIL_KILL:
3206 to->si_pid = from->si_pid;
3207 to->si_uid = from->si_uid;
3208 break;
3209 case SIL_TIMER:
3210 to->si_tid = from->si_tid;
3211 to->si_overrun = from->si_overrun;
3212 to->si_int = from->si_int;
3213 break;
3214 case SIL_POLL:
3215 to->si_band = from->si_band;
3216 to->si_fd = from->si_fd;
3217 break;
3218 case SIL_FAULT:
3219 to->si_addr = compat_ptr(from->si_addr);
3220#ifdef __ARCH_SI_TRAPNO
3221 to->si_trapno = from->si_trapno;
3222#endif
3223 break;
3224 case SIL_FAULT_MCEERR:
3225 to->si_addr = compat_ptr(from->si_addr);
3226#ifdef __ARCH_SI_TRAPNO
3227 to->si_trapno = from->si_trapno;
3228#endif
3229 to->si_addr_lsb = from->si_addr_lsb;
3230 break;
3231 case SIL_FAULT_BNDERR:
3232 to->si_addr = compat_ptr(from->si_addr);
3233#ifdef __ARCH_SI_TRAPNO
3234 to->si_trapno = from->si_trapno;
3235#endif
3236 to->si_lower = compat_ptr(from->si_lower);
3237 to->si_upper = compat_ptr(from->si_upper);
3238 break;
3239 case SIL_FAULT_PKUERR:
3240 to->si_addr = compat_ptr(from->si_addr);
3241#ifdef __ARCH_SI_TRAPNO
3242 to->si_trapno = from->si_trapno;
3243#endif
3244 to->si_pkey = from->si_pkey;
3245 break;
3246 case SIL_CHLD:
3247 to->si_pid = from->si_pid;
3248 to->si_uid = from->si_uid;
3249 to->si_status = from->si_status;
3250#ifdef CONFIG_X86_X32_ABI
3251 if (in_x32_syscall()) {
3252 to->si_utime = from->_sifields._sigchld_x32._utime;
3253 to->si_stime = from->_sifields._sigchld_x32._stime;
3254 } else
3255#endif
3256 {
3257 to->si_utime = from->si_utime;
3258 to->si_stime = from->si_stime;
3259 }
3260 break;
3261 case SIL_RT:
3262 to->si_pid = from->si_pid;
3263 to->si_uid = from->si_uid;
3264 to->si_int = from->si_int;
3265 break;
3266 case SIL_SYS:
3267 to->si_call_addr = compat_ptr(from->si_call_addr);
3268 to->si_syscall = from->si_syscall;
3269 to->si_arch = from->si_arch;
3270 break;
3271 }
3272 return 0;
3273}
3274
3275static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to,
3276 const struct compat_siginfo __user *ufrom)
3277{
3278 struct compat_siginfo from;
3279
3280 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3281 return -EFAULT;
3282
3283 from.si_signo = signo;
3284 return post_copy_siginfo_from_user32(to, &from);
3285}
3286
3287int copy_siginfo_from_user32(struct kernel_siginfo *to,
3288 const struct compat_siginfo __user *ufrom)
3289{
3290 struct compat_siginfo from;
3291
3292 if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3293 return -EFAULT;
3294
3295 return post_copy_siginfo_from_user32(to, &from);
3296}
3297#endif /* CONFIG_COMPAT */
3298
3299/**
3300 * do_sigtimedwait - wait for queued signals specified in @which
3301 * @which: queued signals to wait for
3302 * @info: if non-null, the signal's siginfo is returned here
3303 * @ts: upper bound on process time suspension
3304 */
3305static int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info,
3306 const struct timespec64 *ts)
3307{
3308 ktime_t *to = NULL, timeout = KTIME_MAX;
3309 struct task_struct *tsk = current;
3310 sigset_t mask = *which;
3311 int sig, ret = 0;
3312
3313 if (ts) {
3314 if (!timespec64_valid(ts))
3315 return -EINVAL;
3316 timeout = timespec64_to_ktime(*ts);
3317 to = &timeout;
3318 }
3319
3320 /*
3321 * Invert the set of allowed signals to get those we want to block.
3322 */
3323 sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
3324 signotset(&mask);
3325
3326 spin_lock_irq(&tsk->sighand->siglock);
3327 sig = dequeue_signal(tsk, &mask, info);
3328 if (!sig && timeout) {
3329 /*
3330 * None ready, temporarily unblock those we're interested
3331 * while we are sleeping in so that we'll be awakened when
3332 * they arrive. Unblocking is always fine, we can avoid
3333 * set_current_blocked().
3334 */
3335 tsk->real_blocked = tsk->blocked;
3336 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
3337 recalc_sigpending();
3338 spin_unlock_irq(&tsk->sighand->siglock);
3339
3340 __set_current_state(TASK_INTERRUPTIBLE);
3341 ret = freezable_schedule_hrtimeout_range(to, tsk->timer_slack_ns,
3342 HRTIMER_MODE_REL);
3343 spin_lock_irq(&tsk->sighand->siglock);
3344 __set_task_blocked(tsk, &tsk->real_blocked);
3345 sigemptyset(&tsk->real_blocked);
3346 sig = dequeue_signal(tsk, &mask, info);
3347 }
3348 spin_unlock_irq(&tsk->sighand->siglock);
3349
3350 if (sig)
3351 return sig;
3352 return ret ? -EINTR : -EAGAIN;
3353}
3354
3355/**
3356 * sys_rt_sigtimedwait - synchronously wait for queued signals specified
3357 * in @uthese
3358 * @uthese: queued signals to wait for
3359 * @uinfo: if non-null, the signal's siginfo is returned here
3360 * @uts: upper bound on process time suspension
3361 * @sigsetsize: size of sigset_t type
3362 */
3363SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
3364 siginfo_t __user *, uinfo,
3365 const struct __kernel_timespec __user *, uts,
3366 size_t, sigsetsize)
3367{
3368 sigset_t these;
3369 struct timespec64 ts;
3370 kernel_siginfo_t info;
3371 int ret;
3372
3373 /* XXX: Don't preclude handling different sized sigset_t's. */
3374 if (sigsetsize != sizeof(sigset_t))
3375 return -EINVAL;
3376
3377 if (copy_from_user(&these, uthese, sizeof(these)))
3378 return -EFAULT;
3379
3380 if (uts) {
3381 if (get_timespec64(&ts, uts))
3382 return -EFAULT;
3383 }
3384
3385 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3386
3387 if (ret > 0 && uinfo) {
3388 if (copy_siginfo_to_user(uinfo, &info))
3389 ret = -EFAULT;
3390 }
3391
3392 return ret;
3393}
3394
3395#ifdef CONFIG_COMPAT_32BIT_TIME
3396SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese,
3397 siginfo_t __user *, uinfo,
3398 const struct old_timespec32 __user *, uts,
3399 size_t, sigsetsize)
3400{
3401 sigset_t these;
3402 struct timespec64 ts;
3403 kernel_siginfo_t info;
3404 int ret;
3405
3406 if (sigsetsize != sizeof(sigset_t))
3407 return -EINVAL;
3408
3409 if (copy_from_user(&these, uthese, sizeof(these)))
3410 return -EFAULT;
3411
3412 if (uts) {
3413 if (get_old_timespec32(&ts, uts))
3414 return -EFAULT;
3415 }
3416
3417 ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3418
3419 if (ret > 0 && uinfo) {
3420 if (copy_siginfo_to_user(uinfo, &info))
3421 ret = -EFAULT;
3422 }
3423
3424 return ret;
3425}
3426#endif
3427
3428#ifdef CONFIG_COMPAT
3429COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
3430 struct compat_siginfo __user *, uinfo,
3431 struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
3432{
3433 sigset_t s;
3434 struct timespec64 t;
3435 kernel_siginfo_t info;
3436 long ret;
3437
3438 if (sigsetsize != sizeof(sigset_t))
3439 return -EINVAL;
3440
3441 if (get_compat_sigset(&s, uthese))
3442 return -EFAULT;
3443
3444 if (uts) {
3445 if (get_timespec64(&t, uts))
3446 return -EFAULT;
3447 }
3448
3449 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3450
3451 if (ret > 0 && uinfo) {
3452 if (copy_siginfo_to_user32(uinfo, &info))
3453 ret = -EFAULT;
3454 }
3455
3456 return ret;
3457}
3458
3459#ifdef CONFIG_COMPAT_32BIT_TIME
3460COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese,
3461 struct compat_siginfo __user *, uinfo,
3462 struct old_timespec32 __user *, uts, compat_size_t, sigsetsize)
3463{
3464 sigset_t s;
3465 struct timespec64 t;
3466 kernel_siginfo_t info;
3467 long ret;
3468
3469 if (sigsetsize != sizeof(sigset_t))
3470 return -EINVAL;
3471
3472 if (get_compat_sigset(&s, uthese))
3473 return -EFAULT;
3474
3475 if (uts) {
3476 if (get_old_timespec32(&t, uts))
3477 return -EFAULT;
3478 }
3479
3480 ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3481
3482 if (ret > 0 && uinfo) {
3483 if (copy_siginfo_to_user32(uinfo, &info))
3484 ret = -EFAULT;
3485 }
3486
3487 return ret;
3488}
3489#endif
3490#endif
3491
3492static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info)
3493{
3494 clear_siginfo(info);
3495 info->si_signo = sig;
3496 info->si_errno = 0;
3497 info->si_code = SI_USER;
3498 info->si_pid = task_tgid_vnr(current);
3499 info->si_uid = from_kuid_munged(current_user_ns(), current_uid());
3500}
3501
3502/**
3503 * sys_kill - send a signal to a process
3504 * @pid: the PID of the process
3505 * @sig: signal to be sent
3506 */
3507SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
3508{
3509 struct kernel_siginfo info;
3510
3511 prepare_kill_siginfo(sig, &info);
3512
3513 return kill_something_info(sig, &info, pid);
3514}
3515
3516#ifdef CONFIG_PROC_FS
3517/*
3518 * Verify that the signaler and signalee either are in the same pid namespace