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