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