Merge tag 'pidfd-v5.1-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/brauner...
[muen/linux.git] / kernel / signal.c
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
61 static struct kmem_cache *sigqueue_cachep;
62
63 int print_fatal_signals __read_mostly;
64
65 static void __user *sig_handler(struct task_struct *t, int sig)
66 {
67         return t->sighand->action[sig - 1].sa.sa_handler;
68 }
69
70 static 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
77 static 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
94 static 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  */
119 static 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
147 static 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  */
168 void recalc_sigpending_and_wake(struct task_struct *t)
169 {
170         if (recalc_sigpending_tsk(t))
171                 signal_wake_up(t, 0);
172 }
173
174 void 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 }
181 EXPORT_SYMBOL(recalc_sigpending);
182
183 void 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
200 int 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
246 static 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  */
277 bool 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  */
305 void 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  */
329 void 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  */
358 static 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
384 void 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  */
403 static 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
438 static 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
447 void 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  */
462 void 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 }
472 EXPORT_SYMBOL(flush_signals);
473
474 #ifdef CONFIG_POSIX_TIMERS
475 static 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
498 void 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
510 void 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
524 void
525 flush_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
541 bool 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
554 static 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) {
574 still_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
599 static 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  */
615 int 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 }
691 EXPORT_SYMBOL_GPL(dequeue_signal);
692
693 static 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;
717 next:
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();
728 still_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  */
746 void 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  */
766 static 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
784 static inline int is_si_special(const struct kernel_siginfo *info)
785 {
786         return info <= SEND_SIG_PRIV;
787 }
788
789 static 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  */
798 static 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  */
814 static 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  */
866 static 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  */
885 static 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  */
958 static 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
975 static 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
1051 static 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
1057 static 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
1071 static inline void userns_fixup_signal_uid(struct kernel_siginfo *info, struct task_struct *t)
1072 {
1073         return;
1074 }
1075 #endif
1076
1077 static 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
1172 out_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);
1191 ret:
1192         trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
1193         return ret;
1194 }
1195
1196 static 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
1209 static 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
1233 static 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
1242 int
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
1248 int 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  */
1273 int
1274 force_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  */
1306 int 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
1327 struct 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  */
1362 int 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  */
1382 int __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
1397 int 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
1419 static 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
1428 static 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" */
1440 int 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         }
1471 out_unlock:
1472         rcu_read_unlock();
1473         return ret;
1474 }
1475 EXPORT_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
1484 static 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
1528 int 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 }
1539 EXPORT_SYMBOL(send_sig_info);
1540
1541 #define __si_special(priv) \
1542         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1543
1544 int
1545 send_sig(int sig, struct task_struct *p, int priv)
1546 {
1547         return send_sig_info(sig, __si_special(priv), p);
1548 }
1549 EXPORT_SYMBOL(send_sig);
1550
1551 void force_sig(int sig, struct task_struct *p)
1552 {
1553         force_sig_info(sig, SEND_SIG_PRIV, p);
1554 }
1555 EXPORT_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  */
1563 void 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
1574 int 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
1597 int 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
1620 int 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
1634 int 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 }
1647 EXPORT_SYMBOL(send_sig_mceerr);
1648
1649 int 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
1664 int 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  */
1681 int 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
1693 int 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 }
1703 EXPORT_SYMBOL(kill_pgrp);
1704
1705 int kill_pid(struct pid *pid, int sig, int priv)
1706 {
1707         return kill_pid_info(sig, __si_special(priv), pid);
1708 }
1709 EXPORT_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  */
1720 struct 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
1730 void 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
1755 int 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;
1795 out:
1796         trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
1797         unlock_task_sighand(t, &flags);
1798 ret:
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  */
1810 bool 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  */
1914 static 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
1972 static 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  */
2000 static 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  */
2017 static 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
2152 static 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
2166 void 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  */
2199 static 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  */
2316 static 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
2335 static 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
2383 bool 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
2402 relock:
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  */
2596 static 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
2613 void 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  */
2626 static 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
2653 void 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;
2689 out:
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  */
2710 SYSCALL_DEFINE0(restart_syscall)
2711 {
2712         struct restart_block *restart = &current->restart_block;
2713         return restart->fn(restart);
2714 }
2715
2716 long do_no_restart_syscall(struct restart_block *param)
2717 {
2718         return -EINTR;
2719 }
2720
2721 static 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  */
2740 void set_current_blocked(sigset_t *newset)
2741 {
2742         sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
2743         __set_current_blocked(newset);
2744 }
2745
2746 void __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  */
2770 int 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 }
2796 EXPORT_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  */
2804 int 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 }
2820 EXPORT_SYMBOL(set_user_sigmask);
2821
2822 #ifdef CONFIG_COMPAT
2823 int 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 }
2840 EXPORT_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  */
2852 void 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 }
2874 EXPORT_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  */
2883 SYSCALL_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
2914 COMPAT_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
2938 static 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  */
2955 SYSCALL_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
2971 COMPAT_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
2985 static 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
3001 static 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
3020 enum 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
3051 static inline char __user *si_expansion(const siginfo_t __user *info)
3052 {
3053         return ((char __user *)info) + sizeof(struct kernel_siginfo);
3054 }
3055
3056 int 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
3066 static 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
3089 static 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
3098 int 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
3106 int 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 }
3112 int __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
3197 static 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
3275 static 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
3287 int 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  */
3305 static 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  */
3363 SYSCALL_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
3396 SYSCALL_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
3429 COMPAT_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
3460 COMPAT_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
3492 static 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  */
3507 SYSCALL_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
3519  * or that the signaler's pid namespace is an ancestor of the signalee's pid
3520  * namespace.
3521  */
3522 static bool access_pidfd_pidns(struct pid *pid)
3523 {
3524         struct pid_namespace *active = task_active_pid_ns(current);
3525         struct pid_namespace *p = ns_of_pid(pid);
3526
3527         for (;;) {
3528                 if (!p)
3529                         return false;
3530                 if (p == active)
3531                         break;
3532                 p = p->parent;
3533         }
3534
3535         return true;
3536 }
3537
3538 static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo, siginfo_t *info)
3539 {