Merge tag 'irq-core-2022-10-12' of git://git.kernel.org/pub/scm/linux/kernel/git...
[platform/kernel/linux-starfive.git] / kernel / signal.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/kernel/signal.c
4  *
5  *  Copyright (C) 1991, 1992  Linus Torvalds
6  *
7  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
8  *
9  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
10  *              Changes to use preallocated sigqueue structures
11  *              to allow signals to be sent reliably.
12  */
13
14 #include <linux/slab.h>
15 #include <linux/export.h>
16 #include <linux/init.h>
17 #include <linux/sched/mm.h>
18 #include <linux/sched/user.h>
19 #include <linux/sched/debug.h>
20 #include <linux/sched/task.h>
21 #include <linux/sched/task_stack.h>
22 #include <linux/sched/cputime.h>
23 #include <linux/file.h>
24 #include <linux/fs.h>
25 #include <linux/proc_fs.h>
26 #include <linux/tty.h>
27 #include <linux/binfmts.h>
28 #include <linux/coredump.h>
29 #include <linux/security.h>
30 #include <linux/syscalls.h>
31 #include <linux/ptrace.h>
32 #include <linux/signal.h>
33 #include <linux/signalfd.h>
34 #include <linux/ratelimit.h>
35 #include <linux/task_work.h>
36 #include <linux/capability.h>
37 #include <linux/freezer.h>
38 #include <linux/pid_namespace.h>
39 #include <linux/nsproxy.h>
40 #include <linux/user_namespace.h>
41 #include <linux/uprobes.h>
42 #include <linux/compat.h>
43 #include <linux/cn_proc.h>
44 #include <linux/compiler.h>
45 #include <linux/posix-timers.h>
46 #include <linux/cgroup.h>
47 #include <linux/audit.h>
48
49 #define CREATE_TRACE_POINTS
50 #include <trace/events/signal.h>
51
52 #include <asm/param.h>
53 #include <linux/uaccess.h>
54 #include <asm/unistd.h>
55 #include <asm/siginfo.h>
56 #include <asm/cacheflush.h>
57 #include <asm/syscall.h>        /* for syscall_get_* */
58
59 /*
60  * SLAB caches for signal bits.
61  */
62
63 static struct kmem_cache *sigqueue_cachep;
64
65 int print_fatal_signals __read_mostly;
66
67 static void __user *sig_handler(struct task_struct *t, int sig)
68 {
69         return t->sighand->action[sig - 1].sa.sa_handler;
70 }
71
72 static inline bool sig_handler_ignored(void __user *handler, int sig)
73 {
74         /* Is it explicitly or implicitly ignored? */
75         return handler == SIG_IGN ||
76                (handler == SIG_DFL && sig_kernel_ignore(sig));
77 }
78
79 static bool sig_task_ignored(struct task_struct *t, int sig, bool force)
80 {
81         void __user *handler;
82
83         handler = sig_handler(t, sig);
84
85         /* SIGKILL and SIGSTOP may not be sent to the global init */
86         if (unlikely(is_global_init(t) && sig_kernel_only(sig)))
87                 return true;
88
89         if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
90             handler == SIG_DFL && !(force && sig_kernel_only(sig)))
91                 return true;
92
93         /* Only allow kernel generated signals to this kthread */
94         if (unlikely((t->flags & PF_KTHREAD) &&
95                      (handler == SIG_KTHREAD_KERNEL) && !force))
96                 return true;
97
98         return sig_handler_ignored(handler, sig);
99 }
100
101 static bool sig_ignored(struct task_struct *t, int sig, bool force)
102 {
103         /*
104          * Blocked signals are never ignored, since the
105          * signal handler may change by the time it is
106          * unblocked.
107          */
108         if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
109                 return false;
110
111         /*
112          * Tracers may want to know about even ignored signal unless it
113          * is SIGKILL which can't be reported anyway but can be ignored
114          * by SIGNAL_UNKILLABLE task.
115          */
116         if (t->ptrace && sig != SIGKILL)
117                 return false;
118
119         return sig_task_ignored(t, sig, force);
120 }
121
122 /*
123  * Re-calculate pending state from the set of locally pending
124  * signals, globally pending signals, and blocked signals.
125  */
126 static inline bool has_pending_signals(sigset_t *signal, sigset_t *blocked)
127 {
128         unsigned long ready;
129         long i;
130
131         switch (_NSIG_WORDS) {
132         default:
133                 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
134                         ready |= signal->sig[i] &~ blocked->sig[i];
135                 break;
136
137         case 4: ready  = signal->sig[3] &~ blocked->sig[3];
138                 ready |= signal->sig[2] &~ blocked->sig[2];
139                 ready |= signal->sig[1] &~ blocked->sig[1];
140                 ready |= signal->sig[0] &~ blocked->sig[0];
141                 break;
142
143         case 2: ready  = signal->sig[1] &~ blocked->sig[1];
144                 ready |= signal->sig[0] &~ blocked->sig[0];
145                 break;
146
147         case 1: ready  = signal->sig[0] &~ blocked->sig[0];
148         }
149         return ready != 0;
150 }
151
152 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
153
154 static bool recalc_sigpending_tsk(struct task_struct *t)
155 {
156         if ((t->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) ||
157             PENDING(&t->pending, &t->blocked) ||
158             PENDING(&t->signal->shared_pending, &t->blocked) ||
159             cgroup_task_frozen(t)) {
160                 set_tsk_thread_flag(t, TIF_SIGPENDING);
161                 return true;
162         }
163
164         /*
165          * We must never clear the flag in another thread, or in current
166          * when it's possible the current syscall is returning -ERESTART*.
167          * So we don't clear it here, and only callers who know they should do.
168          */
169         return false;
170 }
171
172 /*
173  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
174  * This is superfluous when called on current, the wakeup is a harmless no-op.
175  */
176 void recalc_sigpending_and_wake(struct task_struct *t)
177 {
178         if (recalc_sigpending_tsk(t))
179                 signal_wake_up(t, 0);
180 }
181
182 void recalc_sigpending(void)
183 {
184         if (!recalc_sigpending_tsk(current) && !freezing(current))
185                 clear_thread_flag(TIF_SIGPENDING);
186
187 }
188 EXPORT_SYMBOL(recalc_sigpending);
189
190 void calculate_sigpending(void)
191 {
192         /* Have any signals or users of TIF_SIGPENDING been delayed
193          * until after fork?
194          */
195         spin_lock_irq(&current->sighand->siglock);
196         set_tsk_thread_flag(current, TIF_SIGPENDING);
197         recalc_sigpending();
198         spin_unlock_irq(&current->sighand->siglock);
199 }
200
201 /* Given the mask, find the first available signal that should be serviced. */
202
203 #define SYNCHRONOUS_MASK \
204         (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
205          sigmask(SIGTRAP) | sigmask(SIGFPE) | sigmask(SIGSYS))
206
207 int next_signal(struct sigpending *pending, sigset_t *mask)
208 {
209         unsigned long i, *s, *m, x;
210         int sig = 0;
211
212         s = pending->signal.sig;
213         m = mask->sig;
214
215         /*
216          * Handle the first word specially: it contains the
217          * synchronous signals that need to be dequeued first.
218          */
219         x = *s &~ *m;
220         if (x) {
221                 if (x & SYNCHRONOUS_MASK)
222                         x &= SYNCHRONOUS_MASK;
223                 sig = ffz(~x) + 1;
224                 return sig;
225         }
226
227         switch (_NSIG_WORDS) {
228         default:
229                 for (i = 1; i < _NSIG_WORDS; ++i) {
230                         x = *++s &~ *++m;
231                         if (!x)
232                                 continue;
233                         sig = ffz(~x) + i*_NSIG_BPW + 1;
234                         break;
235                 }
236                 break;
237
238         case 2:
239                 x = s[1] &~ m[1];
240                 if (!x)
241                         break;
242                 sig = ffz(~x) + _NSIG_BPW + 1;
243                 break;
244
245         case 1:
246                 /* Nothing to do */
247                 break;
248         }
249
250         return sig;
251 }
252
253 static inline void print_dropped_signal(int sig)
254 {
255         static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
256
257         if (!print_fatal_signals)
258                 return;
259
260         if (!__ratelimit(&ratelimit_state))
261                 return;
262
263         pr_info("%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
264                                 current->comm, current->pid, sig);
265 }
266
267 /**
268  * task_set_jobctl_pending - set jobctl pending bits
269  * @task: target task
270  * @mask: pending bits to set
271  *
272  * Clear @mask from @task->jobctl.  @mask must be subset of
273  * %JOBCTL_PENDING_MASK | %JOBCTL_STOP_CONSUME | %JOBCTL_STOP_SIGMASK |
274  * %JOBCTL_TRAPPING.  If stop signo is being set, the existing signo is
275  * cleared.  If @task is already being killed or exiting, this function
276  * becomes noop.
277  *
278  * CONTEXT:
279  * Must be called with @task->sighand->siglock held.
280  *
281  * RETURNS:
282  * %true if @mask is set, %false if made noop because @task was dying.
283  */
284 bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask)
285 {
286         BUG_ON(mask & ~(JOBCTL_PENDING_MASK | JOBCTL_STOP_CONSUME |
287                         JOBCTL_STOP_SIGMASK | JOBCTL_TRAPPING));
288         BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK));
289
290         if (unlikely(fatal_signal_pending(task) || (task->flags & PF_EXITING)))
291                 return false;
292
293         if (mask & JOBCTL_STOP_SIGMASK)
294                 task->jobctl &= ~JOBCTL_STOP_SIGMASK;
295
296         task->jobctl |= mask;
297         return true;
298 }
299
300 /**
301  * task_clear_jobctl_trapping - clear jobctl trapping bit
302  * @task: target task
303  *
304  * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED.
305  * Clear it and wake up the ptracer.  Note that we don't need any further
306  * locking.  @task->siglock guarantees that @task->parent points to the
307  * ptracer.
308  *
309  * CONTEXT:
310  * Must be called with @task->sighand->siglock held.
311  */
312 void task_clear_jobctl_trapping(struct task_struct *task)
313 {
314         if (unlikely(task->jobctl & JOBCTL_TRAPPING)) {
315                 task->jobctl &= ~JOBCTL_TRAPPING;
316                 smp_mb();       /* advised by wake_up_bit() */
317                 wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT);
318         }
319 }
320
321 /**
322  * task_clear_jobctl_pending - clear jobctl pending bits
323  * @task: target task
324  * @mask: pending bits to clear
325  *
326  * Clear @mask from @task->jobctl.  @mask must be subset of
327  * %JOBCTL_PENDING_MASK.  If %JOBCTL_STOP_PENDING is being cleared, other
328  * STOP bits are cleared together.
329  *
330  * If clearing of @mask leaves no stop or trap pending, this function calls
331  * task_clear_jobctl_trapping().
332  *
333  * CONTEXT:
334  * Must be called with @task->sighand->siglock held.
335  */
336 void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask)
337 {
338         BUG_ON(mask & ~JOBCTL_PENDING_MASK);
339
340         if (mask & JOBCTL_STOP_PENDING)
341                 mask |= JOBCTL_STOP_CONSUME | JOBCTL_STOP_DEQUEUED;
342
343         task->jobctl &= ~mask;
344
345         if (!(task->jobctl & JOBCTL_PENDING_MASK))
346                 task_clear_jobctl_trapping(task);
347 }
348
349 /**
350  * task_participate_group_stop - participate in a group stop
351  * @task: task participating in a group stop
352  *
353  * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop.
354  * Group stop states are cleared and the group stop count is consumed if
355  * %JOBCTL_STOP_CONSUME was set.  If the consumption completes the group
356  * stop, the appropriate `SIGNAL_*` flags are set.
357  *
358  * CONTEXT:
359  * Must be called with @task->sighand->siglock held.
360  *
361  * RETURNS:
362  * %true if group stop completion should be notified to the parent, %false
363  * otherwise.
364  */
365 static bool task_participate_group_stop(struct task_struct *task)
366 {
367         struct signal_struct *sig = task->signal;
368         bool consume = task->jobctl & JOBCTL_STOP_CONSUME;
369
370         WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING));
371
372         task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING);
373
374         if (!consume)
375                 return false;
376
377         if (!WARN_ON_ONCE(sig->group_stop_count == 0))
378                 sig->group_stop_count--;
379
380         /*
381          * Tell the caller to notify completion iff we are entering into a
382          * fresh group stop.  Read comment in do_signal_stop() for details.
383          */
384         if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) {
385                 signal_set_stop_flags(sig, SIGNAL_STOP_STOPPED);
386                 return true;
387         }
388         return false;
389 }
390
391 void task_join_group_stop(struct task_struct *task)
392 {
393         unsigned long mask = current->jobctl & JOBCTL_STOP_SIGMASK;
394         struct signal_struct *sig = current->signal;
395
396         if (sig->group_stop_count) {
397                 sig->group_stop_count++;
398                 mask |= JOBCTL_STOP_CONSUME;
399         } else if (!(sig->flags & SIGNAL_STOP_STOPPED))
400                 return;
401
402         /* Have the new thread join an on-going signal group stop */
403         task_set_jobctl_pending(task, mask | JOBCTL_STOP_PENDING);
404 }
405
406 /*
407  * allocate a new signal queue record
408  * - this may be called without locks if and only if t == current, otherwise an
409  *   appropriate lock must be held to stop the target task from exiting
410  */
411 static struct sigqueue *
412 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t gfp_flags,
413                  int override_rlimit, const unsigned int sigqueue_flags)
414 {
415         struct sigqueue *q = NULL;
416         struct ucounts *ucounts = NULL;
417         long sigpending;
418
419         /*
420          * Protect access to @t credentials. This can go away when all
421          * callers hold rcu read lock.
422          *
423          * NOTE! A pending signal will hold on to the user refcount,
424          * and we get/put the refcount only when the sigpending count
425          * changes from/to zero.
426          */
427         rcu_read_lock();
428         ucounts = task_ucounts(t);
429         sigpending = inc_rlimit_get_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING);
430         rcu_read_unlock();
431         if (!sigpending)
432                 return NULL;
433
434         if (override_rlimit || likely(sigpending <= task_rlimit(t, RLIMIT_SIGPENDING))) {
435                 q = kmem_cache_alloc(sigqueue_cachep, gfp_flags);
436         } else {
437                 print_dropped_signal(sig);
438         }
439
440         if (unlikely(q == NULL)) {
441                 dec_rlimit_put_ucounts(ucounts, UCOUNT_RLIMIT_SIGPENDING);
442         } else {
443                 INIT_LIST_HEAD(&q->list);
444                 q->flags = sigqueue_flags;
445                 q->ucounts = ucounts;
446         }
447         return q;
448 }
449
450 static void __sigqueue_free(struct sigqueue *q)
451 {
452         if (q->flags & SIGQUEUE_PREALLOC)
453                 return;
454         if (q->ucounts) {
455                 dec_rlimit_put_ucounts(q->ucounts, UCOUNT_RLIMIT_SIGPENDING);
456                 q->ucounts = NULL;
457         }
458         kmem_cache_free(sigqueue_cachep, q);
459 }
460
461 void flush_sigqueue(struct sigpending *queue)
462 {
463         struct sigqueue *q;
464
465         sigemptyset(&queue->signal);
466         while (!list_empty(&queue->list)) {
467                 q = list_entry(queue->list.next, struct sigqueue , list);
468                 list_del_init(&q->list);
469                 __sigqueue_free(q);
470         }
471 }
472
473 /*
474  * Flush all pending signals for this kthread.
475  */
476 void flush_signals(struct task_struct *t)
477 {
478         unsigned long flags;
479
480         spin_lock_irqsave(&t->sighand->siglock, flags);
481         clear_tsk_thread_flag(t, TIF_SIGPENDING);
482         flush_sigqueue(&t->pending);
483         flush_sigqueue(&t->signal->shared_pending);
484         spin_unlock_irqrestore(&t->sighand->siglock, flags);
485 }
486 EXPORT_SYMBOL(flush_signals);
487
488 #ifdef CONFIG_POSIX_TIMERS
489 static void __flush_itimer_signals(struct sigpending *pending)
490 {
491         sigset_t signal, retain;
492         struct sigqueue *q, *n;
493
494         signal = pending->signal;
495         sigemptyset(&retain);
496
497         list_for_each_entry_safe(q, n, &pending->list, list) {
498                 int sig = q->info.si_signo;
499
500                 if (likely(q->info.si_code != SI_TIMER)) {
501                         sigaddset(&retain, sig);
502                 } else {
503                         sigdelset(&signal, sig);
504                         list_del_init(&q->list);
505                         __sigqueue_free(q);
506                 }
507         }
508
509         sigorsets(&pending->signal, &signal, &retain);
510 }
511
512 void flush_itimer_signals(void)
513 {
514         struct task_struct *tsk = current;
515         unsigned long flags;
516
517         spin_lock_irqsave(&tsk->sighand->siglock, flags);
518         __flush_itimer_signals(&tsk->pending);
519         __flush_itimer_signals(&tsk->signal->shared_pending);
520         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
521 }
522 #endif
523
524 void ignore_signals(struct task_struct *t)
525 {
526         int i;
527
528         for (i = 0; i < _NSIG; ++i)
529                 t->sighand->action[i].sa.sa_handler = SIG_IGN;
530
531         flush_signals(t);
532 }
533
534 /*
535  * Flush all handlers for a task.
536  */
537
538 void
539 flush_signal_handlers(struct task_struct *t, int force_default)
540 {
541         int i;
542         struct k_sigaction *ka = &t->sighand->action[0];
543         for (i = _NSIG ; i != 0 ; i--) {
544                 if (force_default || ka->sa.sa_handler != SIG_IGN)
545                         ka->sa.sa_handler = SIG_DFL;
546                 ka->sa.sa_flags = 0;
547 #ifdef __ARCH_HAS_SA_RESTORER
548                 ka->sa.sa_restorer = NULL;
549 #endif
550                 sigemptyset(&ka->sa.sa_mask);
551                 ka++;
552         }
553 }
554
555 bool unhandled_signal(struct task_struct *tsk, int sig)
556 {
557         void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
558         if (is_global_init(tsk))
559                 return true;
560
561         if (handler != SIG_IGN && handler != SIG_DFL)
562                 return false;
563
564         /* if ptraced, let the tracer determine */
565         return !tsk->ptrace;
566 }
567
568 static void collect_signal(int sig, struct sigpending *list, kernel_siginfo_t *info,
569                            bool *resched_timer)
570 {
571         struct sigqueue *q, *first = NULL;
572
573         /*
574          * Collect the siginfo appropriate to this signal.  Check if
575          * there is another siginfo for the same signal.
576         */
577         list_for_each_entry(q, &list->list, list) {
578                 if (q->info.si_signo == sig) {
579                         if (first)
580                                 goto still_pending;
581                         first = q;
582                 }
583         }
584
585         sigdelset(&list->signal, sig);
586
587         if (first) {
588 still_pending:
589                 list_del_init(&first->list);
590                 copy_siginfo(info, &first->info);
591
592                 *resched_timer =
593                         (first->flags & SIGQUEUE_PREALLOC) &&
594                         (info->si_code == SI_TIMER) &&
595                         (info->si_sys_private);
596
597                 __sigqueue_free(first);
598         } else {
599                 /*
600                  * Ok, it wasn't in the queue.  This must be
601                  * a fast-pathed signal or we must have been
602                  * out of queue space.  So zero out the info.
603                  */
604                 clear_siginfo(info);
605                 info->si_signo = sig;
606                 info->si_errno = 0;
607                 info->si_code = SI_USER;
608                 info->si_pid = 0;
609                 info->si_uid = 0;
610         }
611 }
612
613 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
614                         kernel_siginfo_t *info, bool *resched_timer)
615 {
616         int sig = next_signal(pending, mask);
617
618         if (sig)
619                 collect_signal(sig, pending, info, resched_timer);
620         return sig;
621 }
622
623 /*
624  * Dequeue a signal and return the element to the caller, which is
625  * expected to free it.
626  *
627  * All callers have to hold the siglock.
628  */
629 int dequeue_signal(struct task_struct *tsk, sigset_t *mask,
630                    kernel_siginfo_t *info, enum pid_type *type)
631 {
632         bool resched_timer = false;
633         int signr;
634
635         /* We only dequeue private signals from ourselves, we don't let
636          * signalfd steal them
637          */
638         *type = PIDTYPE_PID;
639         signr = __dequeue_signal(&tsk->pending, mask, info, &resched_timer);
640         if (!signr) {
641                 *type = PIDTYPE_TGID;
642                 signr = __dequeue_signal(&tsk->signal->shared_pending,
643                                          mask, info, &resched_timer);
644 #ifdef CONFIG_POSIX_TIMERS
645                 /*
646                  * itimer signal ?
647                  *
648                  * itimers are process shared and we restart periodic
649                  * itimers in the signal delivery path to prevent DoS
650                  * attacks in the high resolution timer case. This is
651                  * compliant with the old way of self-restarting
652                  * itimers, as the SIGALRM is a legacy signal and only
653                  * queued once. Changing the restart behaviour to
654                  * restart the timer in the signal dequeue path is
655                  * reducing the timer noise on heavy loaded !highres
656                  * systems too.
657                  */
658                 if (unlikely(signr == SIGALRM)) {
659                         struct hrtimer *tmr = &tsk->signal->real_timer;
660
661                         if (!hrtimer_is_queued(tmr) &&
662                             tsk->signal->it_real_incr != 0) {
663                                 hrtimer_forward(tmr, tmr->base->get_time(),
664                                                 tsk->signal->it_real_incr);
665                                 hrtimer_restart(tmr);
666                         }
667                 }
668 #endif
669         }
670
671         recalc_sigpending();
672         if (!signr)
673                 return 0;
674
675         if (unlikely(sig_kernel_stop(signr))) {
676                 /*
677                  * Set a marker that we have dequeued a stop signal.  Our
678                  * caller might release the siglock and then the pending
679                  * stop signal it is about to process is no longer in the
680                  * pending bitmasks, but must still be cleared by a SIGCONT
681                  * (and overruled by a SIGKILL).  So those cases clear this
682                  * shared flag after we've set it.  Note that this flag may
683                  * remain set after the signal we return is ignored or
684                  * handled.  That doesn't matter because its only purpose
685                  * is to alert stop-signal processing code when another
686                  * processor has come along and cleared the flag.
687                  */
688                 current->jobctl |= JOBCTL_STOP_DEQUEUED;
689         }
690 #ifdef CONFIG_POSIX_TIMERS
691         if (resched_timer) {
692                 /*
693                  * Release the siglock to ensure proper locking order
694                  * of timer locks outside of siglocks.  Note, we leave
695                  * irqs disabled here, since the posix-timers code is
696                  * about to disable them again anyway.
697                  */
698                 spin_unlock(&tsk->sighand->siglock);
699                 posixtimer_rearm(info);
700                 spin_lock(&tsk->sighand->siglock);
701
702                 /* Don't expose the si_sys_private value to userspace */
703                 info->si_sys_private = 0;
704         }
705 #endif
706         return signr;
707 }
708 EXPORT_SYMBOL_GPL(dequeue_signal);
709
710 static int dequeue_synchronous_signal(kernel_siginfo_t *info)
711 {
712         struct task_struct *tsk = current;
713         struct sigpending *pending = &tsk->pending;
714         struct sigqueue *q, *sync = NULL;
715
716         /*
717          * Might a synchronous signal be in the queue?
718          */
719         if (!((pending->signal.sig[0] & ~tsk->blocked.sig[0]) & SYNCHRONOUS_MASK))
720                 return 0;
721
722         /*
723          * Return the first synchronous signal in the queue.
724          */
725         list_for_each_entry(q, &pending->list, list) {
726                 /* Synchronous signals have a positive si_code */
727                 if ((q->info.si_code > SI_USER) &&
728                     (sigmask(q->info.si_signo) & SYNCHRONOUS_MASK)) {
729                         sync = q;
730                         goto next;
731                 }
732         }
733         return 0;
734 next:
735         /*
736          * Check if there is another siginfo for the same signal.
737          */
738         list_for_each_entry_continue(q, &pending->list, list) {
739                 if (q->info.si_signo == sync->info.si_signo)
740                         goto still_pending;
741         }
742
743         sigdelset(&pending->signal, sync->info.si_signo);
744         recalc_sigpending();
745 still_pending:
746         list_del_init(&sync->list);
747         copy_siginfo(info, &sync->info);
748         __sigqueue_free(sync);
749         return info->si_signo;
750 }
751
752 /*
753  * Tell a process that it has a new active signal..
754  *
755  * NOTE! we rely on the previous spin_lock to
756  * lock interrupts for us! We can only be called with
757  * "siglock" held, and the local interrupt must
758  * have been disabled when that got acquired!
759  *
760  * No need to set need_resched since signal event passing
761  * goes through ->blocked
762  */
763 void signal_wake_up_state(struct task_struct *t, unsigned int state)
764 {
765         lockdep_assert_held(&t->sighand->siglock);
766
767         set_tsk_thread_flag(t, TIF_SIGPENDING);
768
769         /*
770          * TASK_WAKEKILL also means wake it up in the stopped/traced/killable
771          * case. We don't check t->state here because there is a race with it
772          * executing another processor and just now entering stopped state.
773          * By using wake_up_state, we ensure the process will wake up and
774          * handle its death signal.
775          */
776         if (!wake_up_state(t, state | TASK_INTERRUPTIBLE))
777                 kick_process(t);
778 }
779
780 /*
781  * Remove signals in mask from the pending set and queue.
782  * Returns 1 if any signals were found.
783  *
784  * All callers must be holding the siglock.
785  */
786 static void flush_sigqueue_mask(sigset_t *mask, struct sigpending *s)
787 {
788         struct sigqueue *q, *n;
789         sigset_t m;
790
791         sigandsets(&m, mask, &s->signal);
792         if (sigisemptyset(&m))
793                 return;
794
795         sigandnsets(&s->signal, &s->signal, mask);
796         list_for_each_entry_safe(q, n, &s->list, list) {
797                 if (sigismember(mask, q->info.si_signo)) {
798                         list_del_init(&q->list);
799                         __sigqueue_free(q);
800                 }
801         }
802 }
803
804 static inline int is_si_special(const struct kernel_siginfo *info)
805 {
806         return info <= SEND_SIG_PRIV;
807 }
808
809 static inline bool si_fromuser(const struct kernel_siginfo *info)
810 {
811         return info == SEND_SIG_NOINFO ||
812                 (!is_si_special(info) && SI_FROMUSER(info));
813 }
814
815 /*
816  * called with RCU read lock from check_kill_permission()
817  */
818 static bool kill_ok_by_cred(struct task_struct *t)
819 {
820         const struct cred *cred = current_cred();
821         const struct cred *tcred = __task_cred(t);
822
823         return uid_eq(cred->euid, tcred->suid) ||
824                uid_eq(cred->euid, tcred->uid) ||
825                uid_eq(cred->uid, tcred->suid) ||
826                uid_eq(cred->uid, tcred->uid) ||
827                ns_capable(tcred->user_ns, CAP_KILL);
828 }
829
830 /*
831  * Bad permissions for sending the signal
832  * - the caller must hold the RCU read lock
833  */
834 static int check_kill_permission(int sig, struct kernel_siginfo *info,
835                                  struct task_struct *t)
836 {
837         struct pid *sid;
838         int error;
839
840         if (!valid_signal(sig))
841                 return -EINVAL;
842
843         if (!si_fromuser(info))
844                 return 0;
845
846         error = audit_signal_info(sig, t); /* Let audit system see the signal */
847         if (error)
848                 return error;
849
850         if (!same_thread_group(current, t) &&
851             !kill_ok_by_cred(t)) {
852                 switch (sig) {
853                 case SIGCONT:
854                         sid = task_session(t);
855                         /*
856                          * We don't return the error if sid == NULL. The
857                          * task was unhashed, the caller must notice this.
858                          */
859                         if (!sid || sid == task_session(current))
860                                 break;
861                         fallthrough;
862                 default:
863                         return -EPERM;
864                 }
865         }
866
867         return security_task_kill(t, info, sig, NULL);
868 }
869
870 /**
871  * ptrace_trap_notify - schedule trap to notify ptracer
872  * @t: tracee wanting to notify tracer
873  *
874  * This function schedules sticky ptrace trap which is cleared on the next
875  * TRAP_STOP to notify ptracer of an event.  @t must have been seized by
876  * ptracer.
877  *
878  * If @t is running, STOP trap will be taken.  If trapped for STOP and
879  * ptracer is listening for events, tracee is woken up so that it can
880  * re-trap for the new event.  If trapped otherwise, STOP trap will be
881  * eventually taken without returning to userland after the existing traps
882  * are finished by PTRACE_CONT.
883  *
884  * CONTEXT:
885  * Must be called with @task->sighand->siglock held.
886  */
887 static void ptrace_trap_notify(struct task_struct *t)
888 {
889         WARN_ON_ONCE(!(t->ptrace & PT_SEIZED));
890         lockdep_assert_held(&t->sighand->siglock);
891
892         task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY);
893         ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING);
894 }
895
896 /*
897  * Handle magic process-wide effects of stop/continue signals. Unlike
898  * the signal actions, these happen immediately at signal-generation
899  * time regardless of blocking, ignoring, or handling.  This does the
900  * actual continuing for SIGCONT, but not the actual stopping for stop
901  * signals. The process stop is done as a signal action for SIG_DFL.
902  *
903  * Returns true if the signal should be actually delivered, otherwise
904  * it should be dropped.
905  */
906 static bool prepare_signal(int sig, struct task_struct *p, bool force)
907 {
908         struct signal_struct *signal = p->signal;
909         struct task_struct *t;
910         sigset_t flush;
911
912         if (signal->flags & SIGNAL_GROUP_EXIT) {
913                 if (signal->core_state)
914                         return sig == SIGKILL;
915                 /*
916                  * The process is in the middle of dying, drop the signal.
917                  */
918                 return false;
919         } else if (sig_kernel_stop(sig)) {
920                 /*
921                  * This is a stop signal.  Remove SIGCONT from all queues.
922                  */
923                 siginitset(&flush, sigmask(SIGCONT));
924                 flush_sigqueue_mask(&flush, &signal->shared_pending);
925                 for_each_thread(p, t)
926                         flush_sigqueue_mask(&flush, &t->pending);
927         } else if (sig == SIGCONT) {
928                 unsigned int why;
929                 /*
930                  * Remove all stop signals from all queues, wake all threads.
931                  */
932                 siginitset(&flush, SIG_KERNEL_STOP_MASK);
933                 flush_sigqueue_mask(&flush, &signal->shared_pending);
934                 for_each_thread(p, t) {
935                         flush_sigqueue_mask(&flush, &t->pending);
936                         task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING);
937                         if (likely(!(t->ptrace & PT_SEIZED))) {
938                                 t->jobctl &= ~JOBCTL_STOPPED;
939                                 wake_up_state(t, __TASK_STOPPED);
940                         } else
941                                 ptrace_trap_notify(t);
942                 }
943
944                 /*
945                  * Notify the parent with CLD_CONTINUED if we were stopped.
946                  *
947                  * If we were in the middle of a group stop, we pretend it
948                  * was already finished, and then continued. Since SIGCHLD
949                  * doesn't queue we report only CLD_STOPPED, as if the next
950                  * CLD_CONTINUED was dropped.
951                  */
952                 why = 0;
953                 if (signal->flags & SIGNAL_STOP_STOPPED)
954                         why |= SIGNAL_CLD_CONTINUED;
955                 else if (signal->group_stop_count)
956                         why |= SIGNAL_CLD_STOPPED;
957
958                 if (why) {
959                         /*
960                          * The first thread which returns from do_signal_stop()
961                          * will take ->siglock, notice SIGNAL_CLD_MASK, and
962                          * notify its parent. See get_signal().
963                          */
964                         signal_set_stop_flags(signal, why | SIGNAL_STOP_CONTINUED);
965                         signal->group_stop_count = 0;
966                         signal->group_exit_code = 0;
967                 }
968         }
969
970         return !sig_ignored(p, sig, force);
971 }
972
973 /*
974  * Test if P wants to take SIG.  After we've checked all threads with this,
975  * it's equivalent to finding no threads not blocking SIG.  Any threads not
976  * blocking SIG were ruled out because they are not running and already
977  * have pending signals.  Such threads will dequeue from the shared queue
978  * as soon as they're available, so putting the signal on the shared queue
979  * will be equivalent to sending it to one such thread.
980  */
981 static inline bool wants_signal(int sig, struct task_struct *p)
982 {
983         if (sigismember(&p->blocked, sig))
984                 return false;
985
986         if (p->flags & PF_EXITING)
987                 return false;
988
989         if (sig == SIGKILL)
990                 return true;
991
992         if (task_is_stopped_or_traced(p))
993                 return false;
994
995         return task_curr(p) || !task_sigpending(p);
996 }
997
998 static void complete_signal(int sig, struct task_struct *p, enum pid_type type)
999 {
1000         struct signal_struct *signal = p->signal;
1001         struct task_struct *t;
1002
1003         /*
1004          * Now find a thread we can wake up to take the signal off the queue.
1005          *
1006          * If the main thread wants the signal, it gets first crack.
1007          * Probably the least surprising to the average bear.
1008          */
1009         if (wants_signal(sig, p))
1010                 t = p;
1011         else if ((type == PIDTYPE_PID) || thread_group_empty(p))
1012                 /*
1013                  * There is just one thread and it does not need to be woken.
1014                  * It will dequeue unblocked signals before it runs again.
1015                  */
1016                 return;
1017         else {
1018                 /*
1019                  * Otherwise try to find a suitable thread.
1020                  */
1021                 t = signal->curr_target;
1022                 while (!wants_signal(sig, t)) {
1023                         t = next_thread(t);
1024                         if (t == signal->curr_target)
1025                                 /*
1026                                  * No thread needs to be woken.
1027                                  * Any eligible threads will see
1028                                  * the signal in the queue soon.
1029                                  */
1030                                 return;
1031                 }
1032                 signal->curr_target = t;
1033         }
1034
1035         /*
1036          * Found a killable thread.  If the signal will be fatal,
1037          * then start taking the whole group down immediately.
1038          */
1039         if (sig_fatal(p, sig) &&
1040             (signal->core_state || !(signal->flags & SIGNAL_GROUP_EXIT)) &&
1041             !sigismember(&t->real_blocked, sig) &&
1042             (sig == SIGKILL || !p->ptrace)) {
1043                 /*
1044                  * This signal will be fatal to the whole group.
1045                  */
1046                 if (!sig_kernel_coredump(sig)) {
1047                         /*
1048                          * Start a group exit and wake everybody up.
1049                          * This way we don't have other threads
1050                          * running and doing things after a slower
1051                          * thread has the fatal signal pending.
1052                          */
1053                         signal->flags = SIGNAL_GROUP_EXIT;
1054                         signal->group_exit_code = sig;
1055                         signal->group_stop_count = 0;
1056                         t = p;
1057                         do {
1058                                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1059                                 sigaddset(&t->pending.signal, SIGKILL);
1060                                 signal_wake_up(t, 1);
1061                         } while_each_thread(p, t);
1062                         return;
1063                 }
1064         }
1065
1066         /*
1067          * The signal is already in the shared-pending queue.
1068          * Tell the chosen thread to wake up and dequeue it.
1069          */
1070         signal_wake_up(t, sig == SIGKILL);
1071         return;
1072 }
1073
1074 static inline bool legacy_queue(struct sigpending *signals, int sig)
1075 {
1076         return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
1077 }
1078
1079 static int __send_signal_locked(int sig, struct kernel_siginfo *info,
1080                                 struct task_struct *t, enum pid_type type, bool force)
1081 {
1082         struct sigpending *pending;
1083         struct sigqueue *q;
1084         int override_rlimit;
1085         int ret = 0, result;
1086
1087         lockdep_assert_held(&t->sighand->siglock);
1088
1089         result = TRACE_SIGNAL_IGNORED;
1090         if (!prepare_signal(sig, t, force))
1091                 goto ret;
1092
1093         pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1094         /*
1095          * Short-circuit ignored signals and support queuing
1096          * exactly one non-rt signal, so that we can get more
1097          * detailed information about the cause of the signal.
1098          */
1099         result = TRACE_SIGNAL_ALREADY_PENDING;
1100         if (legacy_queue(pending, sig))
1101                 goto ret;
1102
1103         result = TRACE_SIGNAL_DELIVERED;
1104         /*
1105          * Skip useless siginfo allocation for SIGKILL and kernel threads.
1106          */
1107         if ((sig == SIGKILL) || (t->flags & PF_KTHREAD))
1108                 goto out_set;
1109
1110         /*
1111          * Real-time signals must be queued if sent by sigqueue, or
1112          * some other real-time mechanism.  It is implementation
1113          * defined whether kill() does so.  We attempt to do so, on
1114          * the principle of least surprise, but since kill is not
1115          * allowed to fail with EAGAIN when low on memory we just
1116          * make sure at least one signal gets delivered and don't
1117          * pass on the info struct.
1118          */
1119         if (sig < SIGRTMIN)
1120                 override_rlimit = (is_si_special(info) || info->si_code >= 0);
1121         else
1122                 override_rlimit = 0;
1123
1124         q = __sigqueue_alloc(sig, t, GFP_ATOMIC, override_rlimit, 0);
1125
1126         if (q) {
1127                 list_add_tail(&q->list, &pending->list);
1128                 switch ((unsigned long) info) {
1129                 case (unsigned long) SEND_SIG_NOINFO:
1130                         clear_siginfo(&q->info);
1131                         q->info.si_signo = sig;
1132                         q->info.si_errno = 0;
1133                         q->info.si_code = SI_USER;
1134                         q->info.si_pid = task_tgid_nr_ns(current,
1135                                                         task_active_pid_ns(t));
1136                         rcu_read_lock();
1137                         q->info.si_uid =
1138                                 from_kuid_munged(task_cred_xxx(t, user_ns),
1139                                                  current_uid());
1140                         rcu_read_unlock();
1141                         break;
1142                 case (unsigned long) SEND_SIG_PRIV:
1143                         clear_siginfo(&q->info);
1144                         q->info.si_signo = sig;
1145                         q->info.si_errno = 0;
1146                         q->info.si_code = SI_KERNEL;
1147                         q->info.si_pid = 0;
1148                         q->info.si_uid = 0;
1149                         break;
1150                 default:
1151                         copy_siginfo(&q->info, info);
1152                         break;
1153                 }
1154         } else if (!is_si_special(info) &&
1155                    sig >= SIGRTMIN && info->si_code != SI_USER) {
1156                 /*
1157                  * Queue overflow, abort.  We may abort if the
1158                  * signal was rt and sent by user using something
1159                  * other than kill().
1160                  */
1161                 result = TRACE_SIGNAL_OVERFLOW_FAIL;
1162                 ret = -EAGAIN;
1163                 goto ret;
1164         } else {
1165                 /*
1166                  * This is a silent loss of information.  We still
1167                  * send the signal, but the *info bits are lost.
1168                  */
1169                 result = TRACE_SIGNAL_LOSE_INFO;
1170         }
1171
1172 out_set:
1173         signalfd_notify(t, sig);
1174         sigaddset(&pending->signal, sig);
1175
1176         /* Let multiprocess signals appear after on-going forks */
1177         if (type > PIDTYPE_TGID) {
1178                 struct multiprocess_signals *delayed;
1179                 hlist_for_each_entry(delayed, &t->signal->multiprocess, node) {
1180                         sigset_t *signal = &delayed->signal;
1181                         /* Can't queue both a stop and a continue signal */
1182                         if (sig == SIGCONT)
1183                                 sigdelsetmask(signal, SIG_KERNEL_STOP_MASK);
1184                         else if (sig_kernel_stop(sig))
1185                                 sigdelset(signal, SIGCONT);
1186                         sigaddset(signal, sig);
1187                 }
1188         }
1189
1190         complete_signal(sig, t, type);
1191 ret:
1192         trace_signal_generate(sig, info, t, type != PIDTYPE_PID, result);
1193         return ret;
1194 }
1195
1196 static inline bool has_si_pid_and_uid(struct kernel_siginfo *info)
1197 {
1198         bool ret = false;
1199         switch (siginfo_layout(info->si_signo, info->si_code)) {
1200         case SIL_KILL:
1201         case SIL_CHLD:
1202         case SIL_RT:
1203                 ret = true;
1204                 break;
1205         case SIL_TIMER:
1206         case SIL_POLL:
1207         case SIL_FAULT:
1208         case SIL_FAULT_TRAPNO:
1209         case SIL_FAULT_MCEERR:
1210         case SIL_FAULT_BNDERR:
1211         case SIL_FAULT_PKUERR:
1212         case SIL_FAULT_PERF_EVENT:
1213         case SIL_SYS:
1214                 ret = false;
1215                 break;
1216         }
1217         return ret;
1218 }
1219
1220 int send_signal_locked(int sig, struct kernel_siginfo *info,
1221                        struct task_struct *t, enum pid_type type)
1222 {
1223         /* Should SIGKILL or SIGSTOP be received by a pid namespace init? */
1224         bool force = false;
1225
1226         if (info == SEND_SIG_NOINFO) {
1227                 /* Force if sent from an ancestor pid namespace */
1228                 force = !task_pid_nr_ns(current, task_active_pid_ns(t));
1229         } else if (info == SEND_SIG_PRIV) {
1230                 /* Don't ignore kernel generated signals */
1231                 force = true;
1232         } else if (has_si_pid_and_uid(info)) {
1233                 /* SIGKILL and SIGSTOP is special or has ids */
1234                 struct user_namespace *t_user_ns;
1235
1236                 rcu_read_lock();
1237                 t_user_ns = task_cred_xxx(t, user_ns);
1238                 if (current_user_ns() != t_user_ns) {
1239                         kuid_t uid = make_kuid(current_user_ns(), info->si_uid);
1240                         info->si_uid = from_kuid_munged(t_user_ns, uid);
1241                 }
1242                 rcu_read_unlock();
1243
1244                 /* A kernel generated signal? */
1245                 force = (info->si_code == SI_KERNEL);
1246
1247                 /* From an ancestor pid namespace? */
1248                 if (!task_pid_nr_ns(current, task_active_pid_ns(t))) {
1249                         info->si_pid = 0;
1250                         force = true;
1251                 }
1252         }
1253         return __send_signal_locked(sig, info, t, type, force);
1254 }
1255
1256 static void print_fatal_signal(int signr)
1257 {
1258         struct pt_regs *regs = signal_pt_regs();
1259         pr_info("potentially unexpected fatal signal %d.\n", signr);
1260
1261 #if defined(__i386__) && !defined(__arch_um__)
1262         pr_info("code at %08lx: ", regs->ip);
1263         {
1264                 int i;
1265                 for (i = 0; i < 16; i++) {
1266                         unsigned char insn;
1267
1268                         if (get_user(insn, (unsigned char *)(regs->ip + i)))
1269                                 break;
1270                         pr_cont("%02x ", insn);
1271                 }
1272         }
1273         pr_cont("\n");
1274 #endif
1275         preempt_disable();
1276         show_regs(regs);
1277         preempt_enable();
1278 }
1279
1280 static int __init setup_print_fatal_signals(char *str)
1281 {
1282         get_option (&str, &print_fatal_signals);
1283
1284         return 1;
1285 }
1286
1287 __setup("print-fatal-signals=", setup_print_fatal_signals);
1288
1289 int do_send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p,
1290                         enum pid_type type)
1291 {
1292         unsigned long flags;
1293         int ret = -ESRCH;
1294
1295         if (lock_task_sighand(p, &flags)) {
1296                 ret = send_signal_locked(sig, info, p, type);
1297                 unlock_task_sighand(p, &flags);
1298         }
1299
1300         return ret;
1301 }
1302
1303 enum sig_handler {
1304         HANDLER_CURRENT, /* If reachable use the current handler */
1305         HANDLER_SIG_DFL, /* Always use SIG_DFL handler semantics */
1306         HANDLER_EXIT,    /* Only visible as the process exit code */
1307 };
1308
1309 /*
1310  * Force a signal that the process can't ignore: if necessary
1311  * we unblock the signal and change any SIG_IGN to SIG_DFL.
1312  *
1313  * Note: If we unblock the signal, we always reset it to SIG_DFL,
1314  * since we do not want to have a signal handler that was blocked
1315  * be invoked when user space had explicitly blocked it.
1316  *
1317  * We don't want to have recursive SIGSEGV's etc, for example,
1318  * that is why we also clear SIGNAL_UNKILLABLE.
1319  */
1320 static int
1321 force_sig_info_to_task(struct kernel_siginfo *info, struct task_struct *t,
1322         enum sig_handler handler)
1323 {
1324         unsigned long int flags;
1325         int ret, blocked, ignored;
1326         struct k_sigaction *action;
1327         int sig = info->si_signo;
1328
1329         spin_lock_irqsave(&t->sighand->siglock, flags);
1330         action = &t->sighand->action[sig-1];
1331         ignored = action->sa.sa_handler == SIG_IGN;
1332         blocked = sigismember(&t->blocked, sig);
1333         if (blocked || ignored || (handler != HANDLER_CURRENT)) {
1334                 action->sa.sa_handler = SIG_DFL;
1335                 if (handler == HANDLER_EXIT)
1336                         action->sa.sa_flags |= SA_IMMUTABLE;
1337                 if (blocked) {
1338                         sigdelset(&t->blocked, sig);
1339                         recalc_sigpending_and_wake(t);
1340                 }
1341         }
1342         /*
1343          * Don't clear SIGNAL_UNKILLABLE for traced tasks, users won't expect
1344          * debugging to leave init killable. But HANDLER_EXIT is always fatal.
1345          */
1346         if (action->sa.sa_handler == SIG_DFL &&
1347             (!t->ptrace || (handler == HANDLER_EXIT)))
1348                 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1349         ret = send_signal_locked(sig, info, t, PIDTYPE_PID);
1350         spin_unlock_irqrestore(&t->sighand->siglock, flags);
1351
1352         return ret;
1353 }
1354
1355 int force_sig_info(struct kernel_siginfo *info)
1356 {
1357         return force_sig_info_to_task(info, current, HANDLER_CURRENT);
1358 }
1359
1360 /*
1361  * Nuke all other threads in the group.
1362  */
1363 int zap_other_threads(struct task_struct *p)
1364 {
1365         struct task_struct *t = p;
1366         int count = 0;
1367
1368         p->signal->group_stop_count = 0;
1369
1370         while_each_thread(p, t) {
1371                 task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK);
1372                 count++;
1373
1374                 /* Don't bother with already dead threads */
1375                 if (t->exit_state)
1376                         continue;
1377                 sigaddset(&t->pending.signal, SIGKILL);
1378                 signal_wake_up(t, 1);
1379         }
1380
1381         return count;
1382 }
1383
1384 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1385                                            unsigned long *flags)
1386 {
1387         struct sighand_struct *sighand;
1388
1389         rcu_read_lock();
1390         for (;;) {
1391                 sighand = rcu_dereference(tsk->sighand);
1392                 if (unlikely(sighand == NULL))
1393                         break;
1394
1395                 /*
1396                  * This sighand can be already freed and even reused, but
1397                  * we rely on SLAB_TYPESAFE_BY_RCU and sighand_ctor() which
1398                  * initializes ->siglock: this slab can't go away, it has
1399                  * the same object type, ->siglock can't be reinitialized.
1400                  *
1401                  * We need to ensure that tsk->sighand is still the same
1402                  * after we take the lock, we can race with de_thread() or
1403                  * __exit_signal(). In the latter case the next iteration
1404                  * must see ->sighand == NULL.
1405                  */
1406                 spin_lock_irqsave(&sighand->siglock, *flags);
1407                 if (likely(sighand == rcu_access_pointer(tsk->sighand)))
1408                         break;
1409                 spin_unlock_irqrestore(&sighand->siglock, *flags);
1410         }
1411         rcu_read_unlock();
1412
1413         return sighand;
1414 }
1415
1416 #ifdef CONFIG_LOCKDEP
1417 void lockdep_assert_task_sighand_held(struct task_struct *task)
1418 {
1419         struct sighand_struct *sighand;
1420
1421         rcu_read_lock();
1422         sighand = rcu_dereference(task->sighand);
1423         if (sighand)
1424                 lockdep_assert_held(&sighand->siglock);
1425         else
1426                 WARN_ON_ONCE(1);
1427         rcu_read_unlock();
1428 }
1429 #endif
1430
1431 /*
1432  * send signal info to all the members of a group
1433  */
1434 int group_send_sig_info(int sig, struct kernel_siginfo *info,
1435                         struct task_struct *p, enum pid_type type)
1436 {
1437         int ret;
1438
1439         rcu_read_lock();
1440         ret = check_kill_permission(sig, info, p);
1441         rcu_read_unlock();
1442
1443         if (!ret && sig)
1444                 ret = do_send_sig_info(sig, info, p, type);
1445
1446         return ret;
1447 }
1448
1449 /*
1450  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1451  * control characters do (^C, ^Z etc)
1452  * - the caller must hold at least a readlock on tasklist_lock
1453  */
1454 int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp)
1455 {
1456         struct task_struct *p = NULL;
1457         int retval, success;
1458
1459         success = 0;
1460         retval = -ESRCH;
1461         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1462                 int err = group_send_sig_info(sig, info, p, PIDTYPE_PGID);
1463                 success |= !err;
1464                 retval = err;
1465         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1466         return success ? 0 : retval;
1467 }
1468
1469 int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid)
1470 {
1471         int error = -ESRCH;
1472         struct task_struct *p;
1473
1474         for (;;) {
1475                 rcu_read_lock();
1476                 p = pid_task(pid, PIDTYPE_PID);
1477                 if (p)
1478                         error = group_send_sig_info(sig, info, p, PIDTYPE_TGID);
1479                 rcu_read_unlock();
1480                 if (likely(!p || error != -ESRCH))
1481                         return error;
1482
1483                 /*
1484                  * The task was unhashed in between, try again.  If it
1485                  * is dead, pid_task() will return NULL, if we race with
1486                  * de_thread() it will find the new leader.
1487                  */
1488         }
1489 }
1490
1491 static int kill_proc_info(int sig, struct kernel_siginfo *info, pid_t pid)
1492 {
1493         int error;
1494         rcu_read_lock();
1495         error = kill_pid_info(sig, info, find_vpid(pid));
1496         rcu_read_unlock();
1497         return error;
1498 }
1499
1500 static inline bool kill_as_cred_perm(const struct cred *cred,
1501                                      struct task_struct *target)
1502 {
1503         const struct cred *pcred = __task_cred(target);
1504
1505         return uid_eq(cred->euid, pcred->suid) ||
1506                uid_eq(cred->euid, pcred->uid) ||
1507                uid_eq(cred->uid, pcred->suid) ||
1508                uid_eq(cred->uid, pcred->uid);
1509 }
1510
1511 /*
1512  * The usb asyncio usage of siginfo is wrong.  The glibc support
1513  * for asyncio which uses SI_ASYNCIO assumes the layout is SIL_RT.
1514  * AKA after the generic fields:
1515  *      kernel_pid_t    si_pid;
1516  *      kernel_uid32_t  si_uid;
1517  *      sigval_t        si_value;
1518  *
1519  * Unfortunately when usb generates SI_ASYNCIO it assumes the layout
1520  * after the generic fields is:
1521  *      void __user     *si_addr;
1522  *
1523  * This is a practical problem when there is a 64bit big endian kernel
1524  * and a 32bit userspace.  As the 32bit address will encoded in the low
1525  * 32bits of the pointer.  Those low 32bits will be stored at higher
1526  * address than appear in a 32 bit pointer.  So userspace will not
1527  * see the address it was expecting for it's completions.
1528  *
1529  * There is nothing in the encoding that can allow
1530  * copy_siginfo_to_user32 to detect this confusion of formats, so
1531  * handle this by requiring the caller of kill_pid_usb_asyncio to
1532  * notice when this situration takes place and to store the 32bit
1533  * pointer in sival_int, instead of sival_addr of the sigval_t addr
1534  * parameter.
1535  */
1536 int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr,
1537                          struct pid *pid, const struct cred *cred)
1538 {
1539         struct kernel_siginfo info;
1540         struct task_struct *p;
1541         unsigned long flags;
1542         int ret = -EINVAL;
1543
1544         if (!valid_signal(sig))
1545                 return ret;
1546
1547         clear_siginfo(&info);
1548         info.si_signo = sig;
1549         info.si_errno = errno;
1550         info.si_code = SI_ASYNCIO;
1551         *((sigval_t *)&info.si_pid) = addr;
1552
1553         rcu_read_lock();
1554         p = pid_task(pid, PIDTYPE_PID);
1555         if (!p) {
1556                 ret = -ESRCH;
1557                 goto out_unlock;
1558         }
1559         if (!kill_as_cred_perm(cred, p)) {
1560                 ret = -EPERM;
1561                 goto out_unlock;
1562         }
1563         ret = security_task_kill(p, &info, sig, cred);
1564         if (ret)
1565                 goto out_unlock;
1566
1567         if (sig) {
1568                 if (lock_task_sighand(p, &flags)) {
1569                         ret = __send_signal_locked(sig, &info, p, PIDTYPE_TGID, false);
1570                         unlock_task_sighand(p, &flags);
1571                 } else
1572                         ret = -ESRCH;
1573         }
1574 out_unlock:
1575         rcu_read_unlock();
1576         return ret;
1577 }
1578 EXPORT_SYMBOL_GPL(kill_pid_usb_asyncio);
1579
1580 /*
1581  * kill_something_info() interprets pid in interesting ways just like kill(2).
1582  *
1583  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1584  * is probably wrong.  Should make it like BSD or SYSV.
1585  */
1586
1587 static int kill_something_info(int sig, struct kernel_siginfo *info, pid_t pid)
1588 {
1589         int ret;
1590
1591         if (pid > 0)
1592                 return kill_proc_info(sig, info, pid);
1593
1594         /* -INT_MIN is undefined.  Exclude this case to avoid a UBSAN warning */
1595         if (pid == INT_MIN)
1596                 return -ESRCH;
1597
1598         read_lock(&tasklist_lock);
1599         if (pid != -1) {
1600                 ret = __kill_pgrp_info(sig, info,
1601                                 pid ? find_vpid(-pid) : task_pgrp(current));
1602         } else {
1603                 int retval = 0, count = 0;
1604                 struct task_struct * p;
1605
1606                 for_each_process(p) {
1607                         if (task_pid_vnr(p) > 1 &&
1608                                         !same_thread_group(p, current)) {
1609                                 int err = group_send_sig_info(sig, info, p,
1610                                                               PIDTYPE_MAX);
1611                                 ++count;
1612                                 if (err != -EPERM)
1613                                         retval = err;
1614                         }
1615                 }
1616                 ret = count ? retval : -ESRCH;
1617         }
1618         read_unlock(&tasklist_lock);
1619
1620         return ret;
1621 }
1622
1623 /*
1624  * These are for backward compatibility with the rest of the kernel source.
1625  */
1626
1627 int send_sig_info(int sig, struct kernel_siginfo *info, struct task_struct *p)
1628 {
1629         /*
1630          * Make sure legacy kernel users don't send in bad values
1631          * (normal paths check this in check_kill_permission).
1632          */
1633         if (!valid_signal(sig))
1634                 return -EINVAL;
1635
1636         return do_send_sig_info(sig, info, p, PIDTYPE_PID);
1637 }
1638 EXPORT_SYMBOL(send_sig_info);
1639
1640 #define __si_special(priv) \
1641         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1642
1643 int
1644 send_sig(int sig, struct task_struct *p, int priv)
1645 {
1646         return send_sig_info(sig, __si_special(priv), p);
1647 }
1648 EXPORT_SYMBOL(send_sig);
1649
1650 void force_sig(int sig)
1651 {
1652         struct kernel_siginfo info;
1653
1654         clear_siginfo(&info);
1655         info.si_signo = sig;
1656         info.si_errno = 0;
1657         info.si_code = SI_KERNEL;
1658         info.si_pid = 0;
1659         info.si_uid = 0;
1660         force_sig_info(&info);
1661 }
1662 EXPORT_SYMBOL(force_sig);
1663
1664 void force_fatal_sig(int sig)
1665 {
1666         struct kernel_siginfo info;
1667
1668         clear_siginfo(&info);
1669         info.si_signo = sig;
1670         info.si_errno = 0;
1671         info.si_code = SI_KERNEL;
1672         info.si_pid = 0;
1673         info.si_uid = 0;
1674         force_sig_info_to_task(&info, current, HANDLER_SIG_DFL);
1675 }
1676
1677 void force_exit_sig(int sig)
1678 {
1679         struct kernel_siginfo info;
1680
1681         clear_siginfo(&info);
1682         info.si_signo = sig;
1683         info.si_errno = 0;
1684         info.si_code = SI_KERNEL;
1685         info.si_pid = 0;
1686         info.si_uid = 0;
1687         force_sig_info_to_task(&info, current, HANDLER_EXIT);
1688 }
1689
1690 /*
1691  * When things go south during signal handling, we
1692  * will force a SIGSEGV. And if the signal that caused
1693  * the problem was already a SIGSEGV, we'll want to
1694  * make sure we don't even try to deliver the signal..
1695  */
1696 void force_sigsegv(int sig)
1697 {
1698         if (sig == SIGSEGV)
1699                 force_fatal_sig(SIGSEGV);
1700         else
1701                 force_sig(SIGSEGV);
1702 }
1703
1704 int force_sig_fault_to_task(int sig, int code, void __user *addr
1705         ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1706         , struct task_struct *t)
1707 {
1708         struct kernel_siginfo info;
1709
1710         clear_siginfo(&info);
1711         info.si_signo = sig;
1712         info.si_errno = 0;
1713         info.si_code  = code;
1714         info.si_addr  = addr;
1715 #ifdef __ia64__
1716         info.si_imm = imm;
1717         info.si_flags = flags;
1718         info.si_isr = isr;
1719 #endif
1720         return force_sig_info_to_task(&info, t, HANDLER_CURRENT);
1721 }
1722
1723 int force_sig_fault(int sig, int code, void __user *addr
1724         ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr))
1725 {
1726         return force_sig_fault_to_task(sig, code, addr
1727                                        ___ARCH_SI_IA64(imm, flags, isr), current);
1728 }
1729
1730 int send_sig_fault(int sig, int code, void __user *addr
1731         ___ARCH_SI_IA64(int imm, unsigned int flags, unsigned long isr)
1732         , struct task_struct *t)
1733 {
1734         struct kernel_siginfo info;
1735
1736         clear_siginfo(&info);
1737         info.si_signo = sig;
1738         info.si_errno = 0;
1739         info.si_code  = code;
1740         info.si_addr  = addr;
1741 #ifdef __ia64__
1742         info.si_imm = imm;
1743         info.si_flags = flags;
1744         info.si_isr = isr;
1745 #endif
1746         return send_sig_info(info.si_signo, &info, t);
1747 }
1748
1749 int force_sig_mceerr(int code, void __user *addr, short lsb)
1750 {
1751         struct kernel_siginfo info;
1752
1753         WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1754         clear_siginfo(&info);
1755         info.si_signo = SIGBUS;
1756         info.si_errno = 0;
1757         info.si_code = code;
1758         info.si_addr = addr;
1759         info.si_addr_lsb = lsb;
1760         return force_sig_info(&info);
1761 }
1762
1763 int send_sig_mceerr(int code, void __user *addr, short lsb, struct task_struct *t)
1764 {
1765         struct kernel_siginfo info;
1766
1767         WARN_ON((code != BUS_MCEERR_AO) && (code != BUS_MCEERR_AR));
1768         clear_siginfo(&info);
1769         info.si_signo = SIGBUS;
1770         info.si_errno = 0;
1771         info.si_code = code;
1772         info.si_addr = addr;
1773         info.si_addr_lsb = lsb;
1774         return send_sig_info(info.si_signo, &info, t);
1775 }
1776 EXPORT_SYMBOL(send_sig_mceerr);
1777
1778 int force_sig_bnderr(void __user *addr, void __user *lower, void __user *upper)
1779 {
1780         struct kernel_siginfo info;
1781
1782         clear_siginfo(&info);
1783         info.si_signo = SIGSEGV;
1784         info.si_errno = 0;
1785         info.si_code  = SEGV_BNDERR;
1786         info.si_addr  = addr;
1787         info.si_lower = lower;
1788         info.si_upper = upper;
1789         return force_sig_info(&info);
1790 }
1791
1792 #ifdef SEGV_PKUERR
1793 int force_sig_pkuerr(void __user *addr, u32 pkey)
1794 {
1795         struct kernel_siginfo info;
1796
1797         clear_siginfo(&info);
1798         info.si_signo = SIGSEGV;
1799         info.si_errno = 0;
1800         info.si_code  = SEGV_PKUERR;
1801         info.si_addr  = addr;
1802         info.si_pkey  = pkey;
1803         return force_sig_info(&info);
1804 }
1805 #endif
1806
1807 int send_sig_perf(void __user *addr, u32 type, u64 sig_data)
1808 {
1809         struct kernel_siginfo info;
1810
1811         clear_siginfo(&info);
1812         info.si_signo     = SIGTRAP;
1813         info.si_errno     = 0;
1814         info.si_code      = TRAP_PERF;
1815         info.si_addr      = addr;
1816         info.si_perf_data = sig_data;
1817         info.si_perf_type = type;
1818
1819         /*
1820          * Signals generated by perf events should not terminate the whole
1821          * process if SIGTRAP is blocked, however, delivering the signal
1822          * asynchronously is better than not delivering at all. But tell user
1823          * space if the signal was asynchronous, so it can clearly be
1824          * distinguished from normal synchronous ones.
1825          */
1826         info.si_perf_flags = sigismember(&current->blocked, info.si_signo) ?
1827                                      TRAP_PERF_FLAG_ASYNC :
1828                                      0;
1829
1830         return send_sig_info(info.si_signo, &info, current);
1831 }
1832
1833 /**
1834  * force_sig_seccomp - signals the task to allow in-process syscall emulation
1835  * @syscall: syscall number to send to userland
1836  * @reason: filter-supplied reason code to send to userland (via si_errno)
1837  * @force_coredump: true to trigger a coredump
1838  *
1839  * Forces a SIGSYS with a code of SYS_SECCOMP and related sigsys info.
1840  */
1841 int force_sig_seccomp(int syscall, int reason, bool force_coredump)
1842 {
1843         struct kernel_siginfo info;
1844
1845         clear_siginfo(&info);
1846         info.si_signo = SIGSYS;
1847         info.si_code = SYS_SECCOMP;
1848         info.si_call_addr = (void __user *)KSTK_EIP(current);
1849         info.si_errno = reason;
1850         info.si_arch = syscall_get_arch(current);
1851         info.si_syscall = syscall;
1852         return force_sig_info_to_task(&info, current,
1853                 force_coredump ? HANDLER_EXIT : HANDLER_CURRENT);
1854 }
1855
1856 /* For the crazy architectures that include trap information in
1857  * the errno field, instead of an actual errno value.
1858  */
1859 int force_sig_ptrace_errno_trap(int errno, void __user *addr)
1860 {
1861         struct kernel_siginfo info;
1862
1863         clear_siginfo(&info);
1864         info.si_signo = SIGTRAP;
1865         info.si_errno = errno;
1866         info.si_code  = TRAP_HWBKPT;
1867         info.si_addr  = addr;
1868         return force_sig_info(&info);
1869 }
1870
1871 /* For the rare architectures that include trap information using
1872  * si_trapno.
1873  */
1874 int force_sig_fault_trapno(int sig, int code, void __user *addr, int trapno)
1875 {
1876         struct kernel_siginfo info;
1877
1878         clear_siginfo(&info);
1879         info.si_signo = sig;
1880         info.si_errno = 0;
1881         info.si_code  = code;
1882         info.si_addr  = addr;
1883         info.si_trapno = trapno;
1884         return force_sig_info(&info);
1885 }
1886
1887 /* For the rare architectures that include trap information using
1888  * si_trapno.
1889  */
1890 int send_sig_fault_trapno(int sig, int code, void __user *addr, int trapno,
1891                           struct task_struct *t)
1892 {
1893         struct kernel_siginfo info;
1894
1895         clear_siginfo(&info);
1896         info.si_signo = sig;
1897         info.si_errno = 0;
1898         info.si_code  = code;
1899         info.si_addr  = addr;
1900         info.si_trapno = trapno;
1901         return send_sig_info(info.si_signo, &info, t);
1902 }
1903
1904 int kill_pgrp(struct pid *pid, int sig, int priv)
1905 {
1906         int ret;
1907
1908         read_lock(&tasklist_lock);
1909         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1910         read_unlock(&tasklist_lock);
1911
1912         return ret;
1913 }
1914 EXPORT_SYMBOL(kill_pgrp);
1915
1916 int kill_pid(struct pid *pid, int sig, int priv)
1917 {
1918         return kill_pid_info(sig, __si_special(priv), pid);
1919 }
1920 EXPORT_SYMBOL(kill_pid);
1921
1922 /*
1923  * These functions support sending signals using preallocated sigqueue
1924  * structures.  This is needed "because realtime applications cannot
1925  * afford to lose notifications of asynchronous events, like timer
1926  * expirations or I/O completions".  In the case of POSIX Timers
1927  * we allocate the sigqueue structure from the timer_create.  If this
1928  * allocation fails we are able to report the failure to the application
1929  * with an EAGAIN error.
1930  */
1931 struct sigqueue *sigqueue_alloc(void)
1932 {
1933         return __sigqueue_alloc(-1, current, GFP_KERNEL, 0, SIGQUEUE_PREALLOC);
1934 }
1935
1936 void sigqueue_free(struct sigqueue *q)
1937 {
1938         unsigned long flags;
1939         spinlock_t *lock = &current->sighand->siglock;
1940
1941         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1942         /*
1943          * We must hold ->siglock while testing q->list
1944          * to serialize with collect_signal() or with
1945          * __exit_signal()->flush_sigqueue().
1946          */
1947         spin_lock_irqsave(lock, flags);
1948         q->flags &= ~SIGQUEUE_PREALLOC;
1949         /*
1950          * If it is queued it will be freed when dequeued,
1951          * like the "regular" sigqueue.
1952          */
1953         if (!list_empty(&q->list))
1954                 q = NULL;
1955         spin_unlock_irqrestore(lock, flags);
1956
1957         if (q)
1958                 __sigqueue_free(q);
1959 }
1960
1961 int send_sigqueue(struct sigqueue *q, struct pid *pid, enum pid_type type)
1962 {
1963         int sig = q->info.si_signo;
1964         struct sigpending *pending;
1965         struct task_struct *t;
1966         unsigned long flags;
1967         int ret, result;
1968
1969         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1970
1971         ret = -1;
1972         rcu_read_lock();
1973         t = pid_task(pid, type);
1974         if (!t || !likely(lock_task_sighand(t, &flags)))
1975                 goto ret;
1976
1977         ret = 1; /* the signal is ignored */
1978         result = TRACE_SIGNAL_IGNORED;
1979         if (!prepare_signal(sig, t, false))
1980                 goto out;
1981
1982         ret = 0;
1983         if (unlikely(!list_empty(&q->list))) {
1984                 /*
1985                  * If an SI_TIMER entry is already queue just increment
1986                  * the overrun count.
1987                  */
1988                 BUG_ON(q->info.si_code != SI_TIMER);
1989                 q->info.si_overrun++;
1990                 result = TRACE_SIGNAL_ALREADY_PENDING;
1991                 goto out;
1992         }
1993         q->info.si_overrun = 0;
1994
1995         signalfd_notify(t, sig);
1996         pending = (type != PIDTYPE_PID) ? &t->signal->shared_pending : &t->pending;
1997         list_add_tail(&q->list, &pending->list);
1998         sigaddset(&pending->signal, sig);
1999         complete_signal(sig, t, type);
2000         result = TRACE_SIGNAL_DELIVERED;
2001 out:
2002         trace_signal_generate(sig, &q->info, t, type != PIDTYPE_PID, result);
2003         unlock_task_sighand(t, &flags);
2004 ret:
2005         rcu_read_unlock();
2006         return ret;
2007 }
2008
2009 static void do_notify_pidfd(struct task_struct *task)
2010 {
2011         struct pid *pid;
2012
2013         WARN_ON(task->exit_state == 0);
2014         pid = task_pid(task);
2015         wake_up_all(&pid->wait_pidfd);
2016 }
2017
2018 /*
2019  * Let a parent know about the death of a child.
2020  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
2021  *
2022  * Returns true if our parent ignored us and so we've switched to
2023  * self-reaping.
2024  */
2025 bool do_notify_parent(struct task_struct *tsk, int sig)
2026 {
2027         struct kernel_siginfo info;
2028         unsigned long flags;
2029         struct sighand_struct *psig;
2030         bool autoreap = false;
2031         u64 utime, stime;
2032
2033         WARN_ON_ONCE(sig == -1);
2034
2035         /* do_notify_parent_cldstop should have been called instead.  */
2036         WARN_ON_ONCE(task_is_stopped_or_traced(tsk));
2037
2038         WARN_ON_ONCE(!tsk->ptrace &&
2039                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
2040
2041         /* Wake up all pidfd waiters */
2042         do_notify_pidfd(tsk);
2043
2044         if (sig != SIGCHLD) {
2045                 /*
2046                  * This is only possible if parent == real_parent.
2047                  * Check if it has changed security domain.
2048                  */
2049                 if (tsk->parent_exec_id != READ_ONCE(tsk->parent->self_exec_id))
2050                         sig = SIGCHLD;
2051         }
2052
2053         clear_siginfo(&info);
2054         info.si_signo = sig;
2055         info.si_errno = 0;
2056         /*
2057          * We are under tasklist_lock here so our parent is tied to
2058          * us and cannot change.
2059          *
2060          * task_active_pid_ns will always return the same pid namespace
2061          * until a task passes through release_task.
2062          *
2063          * write_lock() currently calls preempt_disable() which is the
2064          * same as rcu_read_lock(), but according to Oleg, this is not
2065          * correct to rely on this
2066          */
2067         rcu_read_lock();
2068         info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent));
2069         info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns),
2070                                        task_uid(tsk));
2071         rcu_read_unlock();
2072
2073         task_cputime(tsk, &utime, &stime);
2074         info.si_utime = nsec_to_clock_t(utime + tsk->signal->utime);
2075         info.si_stime = nsec_to_clock_t(stime + tsk->signal->stime);
2076
2077         info.si_status = tsk->exit_code & 0x7f;
2078         if (tsk->exit_code & 0x80)
2079                 info.si_code = CLD_DUMPED;
2080         else if (tsk->exit_code & 0x7f)
2081                 info.si_code = CLD_KILLED;
2082         else {
2083                 info.si_code = CLD_EXITED;
2084                 info.si_status = tsk->exit_code >> 8;
2085         }
2086
2087         psig = tsk->parent->sighand;
2088         spin_lock_irqsave(&psig->siglock, flags);
2089         if (!tsk->ptrace && sig == SIGCHLD &&
2090             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
2091              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
2092                 /*
2093                  * We are exiting and our parent doesn't care.  POSIX.1
2094                  * defines special semantics for setting SIGCHLD to SIG_IGN
2095                  * or setting the SA_NOCLDWAIT flag: we should be reaped
2096                  * automatically and not left for our parent's wait4 call.
2097                  * Rather than having the parent do it as a magic kind of
2098                  * signal handler, we just set this to tell do_exit that we
2099                  * can be cleaned up without becoming a zombie.  Note that
2100                  * we still call __wake_up_parent in this case, because a
2101                  * blocked sys_wait4 might now return -ECHILD.
2102                  *
2103                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
2104                  * is implementation-defined: we do (if you don't want
2105                  * it, just use SIG_IGN instead).
2106                  */
2107                 autoreap = true;
2108                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
2109                         sig = 0;
2110         }
2111         /*
2112          * Send with __send_signal as si_pid and si_uid are in the
2113          * parent's namespaces.
2114          */
2115         if (valid_signal(sig) && sig)
2116                 __send_signal_locked(sig, &info, tsk->parent, PIDTYPE_TGID, false);
2117         __wake_up_parent(tsk, tsk->parent);
2118         spin_unlock_irqrestore(&psig->siglock, flags);
2119
2120         return autoreap;
2121 }
2122
2123 /**
2124  * do_notify_parent_cldstop - notify parent of stopped/continued state change
2125  * @tsk: task reporting the state change
2126  * @for_ptracer: the notification is for ptracer
2127  * @why: CLD_{CONTINUED|STOPPED|TRAPPED} to report
2128  *
2129  * Notify @tsk's parent that the stopped/continued state has changed.  If
2130  * @for_ptracer is %false, @tsk's group leader notifies to its real parent.
2131  * If %true, @tsk reports to @tsk->parent which should be the ptracer.
2132  *
2133  * CONTEXT:
2134  * Must be called with tasklist_lock at least read locked.
2135  */
2136 static void do_notify_parent_cldstop(struct task_struct *tsk,
2137                                      bool for_ptracer, int why)
2138 {
2139         struct kernel_siginfo info;
2140         unsigned long flags;
2141         struct task_struct *parent;
2142         struct sighand_struct *sighand;
2143         u64 utime, stime;
2144
2145         if (for_ptracer) {
2146                 parent = tsk->parent;
2147         } else {
2148                 tsk = tsk->group_leader;
2149                 parent = tsk->real_parent;
2150         }
2151
2152         clear_siginfo(&info);
2153         info.si_signo = SIGCHLD;
2154         info.si_errno = 0;
2155         /*
2156          * see comment in do_notify_parent() about the following 4 lines
2157          */
2158         rcu_read_lock();
2159         info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent));
2160         info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk));
2161         rcu_read_unlock();
2162
2163         task_cputime(tsk, &utime, &stime);
2164         info.si_utime = nsec_to_clock_t(utime);
2165         info.si_stime = nsec_to_clock_t(stime);
2166
2167         info.si_code = why;
2168         switch (why) {
2169         case CLD_CONTINUED:
2170                 info.si_status = SIGCONT;
2171                 break;
2172         case CLD_STOPPED:
2173                 info.si_status = tsk->signal->group_exit_code & 0x7f;
2174                 break;
2175         case CLD_TRAPPED:
2176                 info.si_status = tsk->exit_code & 0x7f;
2177                 break;
2178         default:
2179                 BUG();
2180         }
2181
2182         sighand = parent->sighand;
2183         spin_lock_irqsave(&sighand->siglock, flags);
2184         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
2185             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
2186                 send_signal_locked(SIGCHLD, &info, parent, PIDTYPE_TGID);
2187         /*
2188          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
2189          */
2190         __wake_up_parent(tsk, parent);
2191         spin_unlock_irqrestore(&sighand->siglock, flags);
2192 }
2193
2194 /*
2195  * This must be called with current->sighand->siglock held.
2196  *
2197  * This should be the path for all ptrace stops.
2198  * We always set current->last_siginfo while stopped here.
2199  * That makes it a way to test a stopped process for
2200  * being ptrace-stopped vs being job-control-stopped.
2201  *
2202  * Returns the signal the ptracer requested the code resume
2203  * with.  If the code did not stop because the tracer is gone,
2204  * the stop signal remains unchanged unless clear_code.
2205  */
2206 static int ptrace_stop(int exit_code, int why, unsigned long message,
2207                        kernel_siginfo_t *info)
2208         __releases(&current->sighand->siglock)
2209         __acquires(&current->sighand->siglock)
2210 {
2211         bool gstop_done = false;
2212
2213         if (arch_ptrace_stop_needed()) {
2214                 /*
2215                  * The arch code has something special to do before a
2216                  * ptrace stop.  This is allowed to block, e.g. for faults
2217                  * on user stack pages.  We can't keep the siglock while
2218                  * calling arch_ptrace_stop, so we must release it now.
2219                  * To preserve proper semantics, we must do this before
2220                  * any signal bookkeeping like checking group_stop_count.
2221                  */
2222                 spin_unlock_irq(&current->sighand->siglock);
2223                 arch_ptrace_stop();
2224                 spin_lock_irq(&current->sighand->siglock);
2225         }
2226
2227         /*
2228          * After this point ptrace_signal_wake_up or signal_wake_up
2229          * will clear TASK_TRACED if ptrace_unlink happens or a fatal
2230          * signal comes in.  Handle previous ptrace_unlinks and fatal
2231          * signals here to prevent ptrace_stop sleeping in schedule.
2232          */
2233         if (!current->ptrace || __fatal_signal_pending(current))
2234                 return exit_code;
2235
2236         set_special_state(TASK_TRACED);
2237         current->jobctl |= JOBCTL_TRACED;
2238
2239         /*
2240          * We're committing to trapping.  TRACED should be visible before
2241          * TRAPPING is cleared; otherwise, the tracer might fail do_wait().
2242          * Also, transition to TRACED and updates to ->jobctl should be
2243          * atomic with respect to siglock and should be done after the arch
2244          * hook as siglock is released and regrabbed across it.
2245          *
2246          *     TRACER                               TRACEE
2247          *
2248          *     ptrace_attach()
2249          * [L]   wait_on_bit(JOBCTL_TRAPPING)   [S] set_special_state(TRACED)
2250          *     do_wait()
2251          *       set_current_state()                smp_wmb();
2252          *       ptrace_do_wait()
2253          *         wait_task_stopped()
2254          *           task_stopped_code()
2255          * [L]         task_is_traced()         [S] task_clear_jobctl_trapping();
2256          */
2257         smp_wmb();
2258
2259         current->ptrace_message = message;
2260         current->last_siginfo = info;
2261         current->exit_code = exit_code;
2262
2263         /*
2264          * If @why is CLD_STOPPED, we're trapping to participate in a group
2265          * stop.  Do the bookkeeping.  Note that if SIGCONT was delievered
2266          * across siglock relocks since INTERRUPT was scheduled, PENDING
2267          * could be clear now.  We act as if SIGCONT is received after
2268          * TASK_TRACED is entered - ignore it.
2269          */
2270         if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING))
2271                 gstop_done = task_participate_group_stop(current);
2272
2273         /* any trap clears pending STOP trap, STOP trap clears NOTIFY */
2274         task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP);
2275         if (info && info->si_code >> 8 == PTRACE_EVENT_STOP)
2276                 task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY);
2277
2278         /* entering a trap, clear TRAPPING */
2279         task_clear_jobctl_trapping(current);
2280
2281         spin_unlock_irq(&current->sighand->siglock);
2282         read_lock(&tasklist_lock);
2283         /*
2284          * Notify parents of the stop.
2285          *
2286          * While ptraced, there are two parents - the ptracer and
2287          * the real_parent of the group_leader.  The ptracer should
2288          * know about every stop while the real parent is only
2289          * interested in the completion of group stop.  The states
2290          * for the two don't interact with each other.  Notify
2291          * separately unless they're gonna be duplicates.
2292          */
2293         if (current->ptrace)
2294                 do_notify_parent_cldstop(current, true, why);
2295         if (gstop_done && (!current->ptrace || ptrace_reparented(current)))
2296                 do_notify_parent_cldstop(current, false, why);
2297
2298         /*
2299          * Don't want to allow preemption here, because
2300          * sys_ptrace() needs this task to be inactive.
2301          *
2302          * XXX: implement read_unlock_no_resched().
2303          */
2304         preempt_disable();
2305         read_unlock(&tasklist_lock);
2306         cgroup_enter_frozen();
2307         preempt_enable_no_resched();
2308         schedule();
2309         cgroup_leave_frozen(true);
2310
2311         /*
2312          * We are back.  Now reacquire the siglock before touching
2313          * last_siginfo, so that we are sure to have synchronized with
2314          * any signal-sending on another CPU that wants to examine it.
2315          */
2316         spin_lock_irq(&current->sighand->siglock);
2317         exit_code = current->exit_code;
2318         current->last_siginfo = NULL;
2319         current->ptrace_message = 0;
2320         current->exit_code = 0;
2321
2322         /* LISTENING can be set only during STOP traps, clear it */
2323         current->jobctl &= ~(JOBCTL_LISTENING | JOBCTL_PTRACE_FROZEN);
2324
2325         /*
2326          * Queued signals ignored us while we were stopped for tracing.
2327          * So check for any that we should take before resuming user mode.
2328          * This sets TIF_SIGPENDING, but never clears it.
2329          */
2330         recalc_sigpending_tsk(current);
2331         return exit_code;
2332 }
2333
2334 static int ptrace_do_notify(int signr, int exit_code, int why, unsigned long message)
2335 {
2336         kernel_siginfo_t info;
2337
2338         clear_siginfo(&info);
2339         info.si_signo = signr;
2340         info.si_code = exit_code;
2341         info.si_pid = task_pid_vnr(current);
2342         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
2343
2344         /* Let the debugger run.  */
2345         return ptrace_stop(exit_code, why, message, &info);
2346 }
2347
2348 int ptrace_notify(int exit_code, unsigned long message)
2349 {
2350         int signr;
2351
2352         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
2353         if (unlikely(task_work_pending(current)))
2354                 task_work_run();
2355
2356         spin_lock_irq(&current->sighand->siglock);
2357         signr = ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED, message);
2358         spin_unlock_irq(&current->sighand->siglock);
2359         return signr;
2360 }
2361
2362 /**
2363  * do_signal_stop - handle group stop for SIGSTOP and other stop signals
2364  * @signr: signr causing group stop if initiating
2365  *
2366  * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr
2367  * and participate in it.  If already set, participate in the existing
2368  * group stop.  If participated in a group stop (and thus slept), %true is
2369  * returned with siglock released.
2370  *
2371  * If ptraced, this function doesn't handle stop itself.  Instead,
2372  * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock
2373  * untouched.  The caller must ensure that INTERRUPT trap handling takes
2374  * places afterwards.
2375  *
2376  * CONTEXT:
2377  * Must be called with @current->sighand->siglock held, which is released
2378  * on %true return.
2379  *
2380  * RETURNS:
2381  * %false if group stop is already cancelled or ptrace trap is scheduled.
2382  * %true if participated in group stop.
2383  */
2384 static bool do_signal_stop(int signr)
2385         __releases(&current->sighand->siglock)
2386 {
2387         struct signal_struct *sig = current->signal;
2388
2389         if (!(current->jobctl & JOBCTL_STOP_PENDING)) {
2390                 unsigned long gstop = JOBCTL_STOP_PENDING | JOBCTL_STOP_CONSUME;
2391                 struct task_struct *t;
2392
2393                 /* signr will be recorded in task->jobctl for retries */
2394                 WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK);
2395
2396                 if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) ||
2397                     unlikely(sig->flags & SIGNAL_GROUP_EXIT) ||
2398                     unlikely(sig->group_exec_task))
2399                         return false;
2400                 /*
2401                  * There is no group stop already in progress.  We must
2402                  * initiate one now.
2403                  *
2404                  * While ptraced, a task may be resumed while group stop is
2405                  * still in effect and then receive a stop signal and
2406                  * initiate another group stop.  This deviates from the
2407                  * usual behavior as two consecutive stop signals can't
2408                  * cause two group stops when !ptraced.  That is why we
2409                  * also check !task_is_stopped(t) below.
2410                  *
2411                  * The condition can be distinguished by testing whether
2412                  * SIGNAL_STOP_STOPPED is already set.  Don't generate
2413                  * group_exit_code in such case.
2414                  *
2415                  * This is not necessary for SIGNAL_STOP_CONTINUED because
2416                  * an intervening stop signal is required to cause two
2417                  * continued events regardless of ptrace.
2418                  */
2419                 if (!(sig->flags & SIGNAL_STOP_STOPPED))
2420                         sig->group_exit_code = signr;
2421
2422                 sig->group_stop_count = 0;
2423
2424                 if (task_set_jobctl_pending(current, signr | gstop))
2425                         sig->group_stop_count++;
2426
2427                 t = current;
2428                 while_each_thread(current, t) {
2429                         /*
2430                          * Setting state to TASK_STOPPED for a group
2431                          * stop is always done with the siglock held,
2432                          * so this check has no races.
2433                          */
2434                         if (!task_is_stopped(t) &&
2435                             task_set_jobctl_pending(t, signr | gstop)) {
2436                                 sig->group_stop_count++;
2437                                 if (likely(!(t->ptrace & PT_SEIZED)))
2438                                         signal_wake_up(t, 0);
2439                                 else
2440                                         ptrace_trap_notify(t);
2441                         }
2442                 }
2443         }
2444
2445         if (likely(!current->ptrace)) {
2446                 int notify = 0;
2447
2448                 /*
2449                  * If there are no other threads in the group, or if there
2450                  * is a group stop in progress and we are the last to stop,
2451                  * report to the parent.
2452                  */
2453                 if (task_participate_group_stop(current))
2454                         notify = CLD_STOPPED;
2455
2456                 current->jobctl |= JOBCTL_STOPPED;
2457                 set_special_state(TASK_STOPPED);
2458                 spin_unlock_irq(&current->sighand->siglock);
2459
2460                 /*
2461                  * Notify the parent of the group stop completion.  Because
2462                  * we're not holding either the siglock or tasklist_lock
2463                  * here, ptracer may attach inbetween; however, this is for
2464                  * group stop and should always be delivered to the real
2465                  * parent of the group leader.  The new ptracer will get
2466                  * its notification when this task transitions into
2467                  * TASK_TRACED.
2468                  */
2469                 if (notify) {
2470                         read_lock(&tasklist_lock);
2471                         do_notify_parent_cldstop(current, false, notify);
2472                         read_unlock(&tasklist_lock);
2473                 }
2474
2475                 /* Now we don't run again until woken by SIGCONT or SIGKILL */
2476                 cgroup_enter_frozen();
2477                 schedule();
2478                 return true;
2479         } else {
2480                 /*
2481                  * While ptraced, group stop is handled by STOP trap.
2482                  * Schedule it and let the caller deal with it.
2483                  */
2484                 task_set_jobctl_pending(current, JOBCTL_TRAP_STOP);
2485                 return false;
2486         }
2487 }
2488
2489 /**
2490  * do_jobctl_trap - take care of ptrace jobctl traps
2491  *
2492  * When PT_SEIZED, it's used for both group stop and explicit
2493  * SEIZE/INTERRUPT traps.  Both generate PTRACE_EVENT_STOP trap with
2494  * accompanying siginfo.  If stopped, lower eight bits of exit_code contain
2495  * the stop signal; otherwise, %SIGTRAP.
2496  *
2497  * When !PT_SEIZED, it's used only for group stop trap with stop signal
2498  * number as exit_code and no siginfo.
2499  *
2500  * CONTEXT:
2501  * Must be called with @current->sighand->siglock held, which may be
2502  * released and re-acquired before returning with intervening sleep.
2503  */
2504 static void do_jobctl_trap(void)
2505 {
2506         struct signal_struct *signal = current->signal;
2507         int signr = current->jobctl & JOBCTL_STOP_SIGMASK;
2508
2509         if (current->ptrace & PT_SEIZED) {
2510                 if (!signal->group_stop_count &&
2511                     !(signal->flags & SIGNAL_STOP_STOPPED))
2512                         signr = SIGTRAP;
2513                 WARN_ON_ONCE(!signr);
2514                 ptrace_do_notify(signr, signr | (PTRACE_EVENT_STOP << 8),
2515                                  CLD_STOPPED, 0);
2516         } else {
2517                 WARN_ON_ONCE(!signr);
2518                 ptrace_stop(signr, CLD_STOPPED, 0, NULL);
2519         }
2520 }
2521
2522 /**
2523  * do_freezer_trap - handle the freezer jobctl trap
2524  *
2525  * Puts the task into frozen state, if only the task is not about to quit.
2526  * In this case it drops JOBCTL_TRAP_FREEZE.
2527  *
2528  * CONTEXT:
2529  * Must be called with @current->sighand->siglock held,
2530  * which is always released before returning.
2531  */
2532 static void do_freezer_trap(void)
2533         __releases(&current->sighand->siglock)
2534 {
2535         /*
2536          * If there are other trap bits pending except JOBCTL_TRAP_FREEZE,
2537          * let's make another loop to give it a chance to be handled.
2538          * In any case, we'll return back.
2539          */
2540         if ((current->jobctl & (JOBCTL_PENDING_MASK | JOBCTL_TRAP_FREEZE)) !=
2541              JOBCTL_TRAP_FREEZE) {
2542                 spin_unlock_irq(&current->sighand->siglock);
2543                 return;
2544         }
2545
2546         /*
2547          * Now we're sure that there is no pending fatal signal and no
2548          * pending traps. Clear TIF_SIGPENDING to not get out of schedule()
2549          * immediately (if there is a non-fatal signal pending), and
2550          * put the task into sleep.
2551          */
2552         __set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
2553         clear_thread_flag(TIF_SIGPENDING);
2554         spin_unlock_irq(&current->sighand->siglock);
2555         cgroup_enter_frozen();
2556         schedule();
2557 }
2558
2559 static int ptrace_signal(int signr, kernel_siginfo_t *info, enum pid_type type)
2560 {
2561         /*
2562          * We do not check sig_kernel_stop(signr) but set this marker
2563          * unconditionally because we do not know whether debugger will
2564          * change signr. This flag has no meaning unless we are going
2565          * to stop after return from ptrace_stop(). In this case it will
2566          * be checked in do_signal_stop(), we should only stop if it was
2567          * not cleared by SIGCONT while we were sleeping. See also the
2568          * comment in dequeue_signal().
2569          */
2570         current->jobctl |= JOBCTL_STOP_DEQUEUED;
2571         signr = ptrace_stop(signr, CLD_TRAPPED, 0, info);
2572
2573         /* We're back.  Did the debugger cancel the sig?  */
2574         if (signr == 0)
2575                 return signr;
2576
2577         /*
2578          * Update the siginfo structure if the signal has
2579          * changed.  If the debugger wanted something
2580          * specific in the siginfo structure then it should
2581          * have updated *info via PTRACE_SETSIGINFO.
2582          */
2583         if (signr != info->si_signo) {
2584                 clear_siginfo(info);
2585                 info->si_signo = signr;
2586                 info->si_errno = 0;
2587                 info->si_code = SI_USER;
2588                 rcu_read_lock();
2589                 info->si_pid = task_pid_vnr(current->parent);
2590                 info->si_uid = from_kuid_munged(current_user_ns(),
2591                                                 task_uid(current->parent));
2592                 rcu_read_unlock();
2593         }
2594
2595         /* If the (new) signal is now blocked, requeue it.  */
2596         if (sigismember(&current->blocked, signr) ||
2597             fatal_signal_pending(current)) {
2598                 send_signal_locked(signr, info, current, type);
2599                 signr = 0;
2600         }
2601
2602         return signr;
2603 }
2604
2605 static void hide_si_addr_tag_bits(struct ksignal *ksig)
2606 {
2607         switch (siginfo_layout(ksig->sig, ksig->info.si_code)) {
2608         case SIL_FAULT:
2609         case SIL_FAULT_TRAPNO:
2610         case SIL_FAULT_MCEERR:
2611         case SIL_FAULT_BNDERR:
2612         case SIL_FAULT_PKUERR:
2613         case SIL_FAULT_PERF_EVENT:
2614                 ksig->info.si_addr = arch_untagged_si_addr(
2615                         ksig->info.si_addr, ksig->sig, ksig->info.si_code);
2616                 break;
2617         case SIL_KILL:
2618         case SIL_TIMER:
2619         case SIL_POLL:
2620         case SIL_CHLD:
2621         case SIL_RT:
2622         case SIL_SYS:
2623                 break;
2624         }
2625 }
2626
2627 bool get_signal(struct ksignal *ksig)
2628 {
2629         struct sighand_struct *sighand = current->sighand;
2630         struct signal_struct *signal = current->signal;
2631         int signr;
2632
2633         clear_notify_signal();
2634         if (unlikely(task_work_pending(current)))
2635                 task_work_run();
2636
2637         if (!task_sigpending(current))
2638                 return false;
2639
2640         if (unlikely(uprobe_deny_signal()))
2641                 return false;
2642
2643         /*
2644          * Do this once, we can't return to user-mode if freezing() == T.
2645          * do_signal_stop() and ptrace_stop() do freezable_schedule() and
2646          * thus do not need another check after return.
2647          */
2648         try_to_freeze();
2649
2650 relock:
2651         spin_lock_irq(&sighand->siglock);
2652
2653         /*
2654          * Every stopped thread goes here after wakeup. Check to see if
2655          * we should notify the parent, prepare_signal(SIGCONT) encodes
2656          * the CLD_ si_code into SIGNAL_CLD_MASK bits.
2657          */
2658         if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
2659                 int why;
2660
2661                 if (signal->flags & SIGNAL_CLD_CONTINUED)
2662                         why = CLD_CONTINUED;
2663                 else
2664                         why = CLD_STOPPED;
2665
2666                 signal->flags &= ~SIGNAL_CLD_MASK;
2667
2668                 spin_unlock_irq(&sighand->siglock);
2669
2670                 /*
2671                  * Notify the parent that we're continuing.  This event is
2672                  * always per-process and doesn't make whole lot of sense
2673                  * for ptracers, who shouldn't consume the state via
2674                  * wait(2) either, but, for backward compatibility, notify
2675                  * the ptracer of the group leader too unless it's gonna be
2676                  * a duplicate.
2677                  */
2678                 read_lock(&tasklist_lock);
2679                 do_notify_parent_cldstop(current, false, why);
2680
2681                 if (ptrace_reparented(current->group_leader))
2682                         do_notify_parent_cldstop(current->group_leader,
2683                                                 true, why);
2684                 read_unlock(&tasklist_lock);
2685
2686                 goto relock;
2687         }
2688
2689         for (;;) {
2690                 struct k_sigaction *ka;
2691                 enum pid_type type;
2692
2693                 /* Has this task already been marked for death? */
2694                 if ((signal->flags & SIGNAL_GROUP_EXIT) ||
2695                      signal->group_exec_task) {
2696                         ksig->info.si_signo = signr = SIGKILL;
2697                         sigdelset(&current->pending.signal, SIGKILL);
2698                         trace_signal_deliver(SIGKILL, SEND_SIG_NOINFO,
2699                                 &sighand->action[SIGKILL - 1]);
2700                         recalc_sigpending();
2701                         goto fatal;
2702                 }
2703
2704                 if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) &&
2705                     do_signal_stop(0))
2706                         goto relock;
2707
2708                 if (unlikely(current->jobctl &
2709                              (JOBCTL_TRAP_MASK | JOBCTL_TRAP_FREEZE))) {
2710                         if (current->jobctl & JOBCTL_TRAP_MASK) {
2711                                 do_jobctl_trap();
2712                                 spin_unlock_irq(&sighand->siglock);
2713                         } else if (current->jobctl & JOBCTL_TRAP_FREEZE)
2714                                 do_freezer_trap();
2715
2716                         goto relock;
2717                 }
2718
2719                 /*
2720                  * If the task is leaving the frozen state, let's update
2721                  * cgroup counters and reset the frozen bit.
2722                  */
2723                 if (unlikely(cgroup_task_frozen(current))) {
2724                         spin_unlock_irq(&sighand->siglock);
2725                         cgroup_leave_frozen(false);
2726                         goto relock;
2727                 }
2728
2729                 /*
2730                  * Signals generated by the execution of an instruction
2731                  * need to be delivered before any other pending signals
2732                  * so that the instruction pointer in the signal stack
2733                  * frame points to the faulting instruction.
2734                  */
2735                 type = PIDTYPE_PID;
2736                 signr = dequeue_synchronous_signal(&ksig->info);
2737                 if (!signr)
2738                         signr = dequeue_signal(current, &current->blocked,
2739                                                &ksig->info, &type);
2740
2741                 if (!signr)
2742                         break; /* will return 0 */
2743
2744                 if (unlikely(current->ptrace) && (signr != SIGKILL) &&
2745                     !(sighand->action[signr -1].sa.sa_flags & SA_IMMUTABLE)) {
2746                         signr = ptrace_signal(signr, &ksig->info, type);
2747                         if (!signr)
2748                                 continue;
2749                 }
2750
2751                 ka = &sighand->action[signr-1];
2752
2753                 /* Trace actually delivered signals. */
2754                 trace_signal_deliver(signr, &ksig->info, ka);
2755
2756                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
2757                         continue;
2758                 if (ka->sa.sa_handler != SIG_DFL) {
2759                         /* Run the handler.  */
2760                         ksig->ka = *ka;
2761
2762                         if (ka->sa.sa_flags & SA_ONESHOT)
2763                                 ka->sa.sa_handler = SIG_DFL;
2764
2765                         break; /* will return non-zero "signr" value */
2766                 }
2767
2768                 /*
2769                  * Now we are doing the default action for this signal.
2770                  */
2771                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
2772                         continue;
2773
2774                 /*
2775                  * Global init gets no signals it doesn't want.
2776                  * Container-init gets no signals it doesn't want from same
2777                  * container.
2778                  *
2779                  * Note that if global/container-init sees a sig_kernel_only()
2780                  * signal here, the signal must have been generated internally
2781                  * or must have come from an ancestor namespace. In either
2782                  * case, the signal cannot be dropped.
2783                  */
2784                 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
2785                                 !sig_kernel_only(signr))
2786                         continue;
2787
2788                 if (sig_kernel_stop(signr)) {
2789                         /*
2790                          * The default action is to stop all threads in
2791                          * the thread group.  The job control signals
2792                          * do nothing in an orphaned pgrp, but SIGSTOP
2793                          * always works.  Note that siglock needs to be
2794                          * dropped during the call to is_orphaned_pgrp()
2795                          * because of lock ordering with tasklist_lock.
2796                          * This allows an intervening SIGCONT to be posted.
2797                          * We need to check for that and bail out if necessary.
2798                          */
2799                         if (signr != SIGSTOP) {
2800                                 spin_unlock_irq(&sighand->siglock);
2801
2802                                 /* signals can be posted during this window */
2803
2804                                 if (is_current_pgrp_orphaned())
2805                                         goto relock;
2806
2807                                 spin_lock_irq(&sighand->siglock);
2808                         }
2809
2810                         if (likely(do_signal_stop(ksig->info.si_signo))) {
2811                                 /* It released the siglock.  */
2812                                 goto relock;
2813                         }
2814
2815                         /*
2816                          * We didn't actually stop, due to a race
2817                          * with SIGCONT or something like that.
2818                          */
2819                         continue;
2820                 }
2821
2822         fatal:
2823                 spin_unlock_irq(&sighand->siglock);
2824                 if (unlikely(cgroup_task_frozen(current)))
2825                         cgroup_leave_frozen(true);
2826
2827                 /*
2828                  * Anything else is fatal, maybe with a core dump.
2829                  */
2830                 current->flags |= PF_SIGNALED;
2831
2832                 if (sig_kernel_coredump(signr)) {
2833                         if (print_fatal_signals)
2834                                 print_fatal_signal(ksig->info.si_signo);
2835                         proc_coredump_connector(current);
2836                         /*
2837                          * If it was able to dump core, this kills all
2838                          * other threads in the group and synchronizes with
2839                          * their demise.  If we lost the race with another
2840                          * thread getting here, it set group_exit_code
2841                          * first and our do_group_exit call below will use
2842                          * that value and ignore the one we pass it.
2843                          */
2844                         do_coredump(&ksig->info);
2845                 }
2846
2847                 /*
2848                  * PF_IO_WORKER threads will catch and exit on fatal signals
2849                  * themselves. They have cleanup that must be performed, so
2850                  * we cannot call do_exit() on their behalf.
2851                  */
2852                 if (current->flags & PF_IO_WORKER)
2853                         goto out;
2854
2855                 /*
2856                  * Death signals, no core dump.
2857                  */
2858                 do_group_exit(ksig->info.si_signo);
2859                 /* NOTREACHED */
2860         }
2861         spin_unlock_irq(&sighand->siglock);
2862 out:
2863         ksig->sig = signr;
2864
2865         if (!(ksig->ka.sa.sa_flags & SA_EXPOSE_TAGBITS))
2866                 hide_si_addr_tag_bits(ksig);
2867
2868         return ksig->sig > 0;
2869 }
2870
2871 /**
2872  * signal_delivered - called after signal delivery to update blocked signals
2873  * @ksig:               kernel signal struct
2874  * @stepping:           nonzero if debugger single-step or block-step in use
2875  *
2876  * This function should be called when a signal has successfully been
2877  * delivered. It updates the blocked signals accordingly (@ksig->ka.sa.sa_mask
2878  * is always blocked), and the signal itself is blocked unless %SA_NODEFER
2879  * is set in @ksig->ka.sa.sa_flags.  Tracing is notified.
2880  */
2881 static void signal_delivered(struct ksignal *ksig, int stepping)
2882 {
2883         sigset_t blocked;
2884
2885         /* A signal was successfully delivered, and the
2886            saved sigmask was stored on the signal frame,
2887            and will be restored by sigreturn.  So we can
2888            simply clear the restore sigmask flag.  */
2889         clear_restore_sigmask();
2890
2891         sigorsets(&blocked, &current->blocked, &ksig->ka.sa.sa_mask);
2892         if (!(ksig->ka.sa.sa_flags & SA_NODEFER))
2893                 sigaddset(&blocked, ksig->sig);
2894         set_current_blocked(&blocked);
2895         if (current->sas_ss_flags & SS_AUTODISARM)
2896                 sas_ss_reset(current);
2897         if (stepping)
2898                 ptrace_notify(SIGTRAP, 0);
2899 }
2900
2901 void signal_setup_done(int failed, struct ksignal *ksig, int stepping)
2902 {
2903         if (failed)
2904                 force_sigsegv(ksig->sig);
2905         else
2906                 signal_delivered(ksig, stepping);
2907 }
2908
2909 /*
2910  * It could be that complete_signal() picked us to notify about the
2911  * group-wide signal. Other threads should be notified now to take
2912  * the shared signals in @which since we will not.
2913  */
2914 static void retarget_shared_pending(struct task_struct *tsk, sigset_t *which)
2915 {
2916         sigset_t retarget;
2917         struct task_struct *t;
2918
2919         sigandsets(&retarget, &tsk->signal->shared_pending.signal, which);
2920         if (sigisemptyset(&retarget))
2921                 return;
2922
2923         t = tsk;
2924         while_each_thread(tsk, t) {
2925                 if (t->flags & PF_EXITING)
2926                         continue;
2927
2928                 if (!has_pending_signals(&retarget, &t->blocked))
2929                         continue;
2930                 /* Remove the signals this thread can handle. */
2931                 sigandsets(&retarget, &retarget, &t->blocked);
2932
2933                 if (!task_sigpending(t))
2934                         signal_wake_up(t, 0);
2935
2936                 if (sigisemptyset(&retarget))
2937                         break;
2938         }
2939 }
2940
2941 void exit_signals(struct task_struct *tsk)
2942 {
2943         int group_stop = 0;
2944         sigset_t unblocked;
2945
2946         /*
2947          * @tsk is about to have PF_EXITING set - lock out users which
2948          * expect stable threadgroup.
2949          */
2950         cgroup_threadgroup_change_begin(tsk);
2951
2952         if (thread_group_empty(tsk) || (tsk->signal->flags & SIGNAL_GROUP_EXIT)) {
2953                 tsk->flags |= PF_EXITING;
2954                 cgroup_threadgroup_change_end(tsk);
2955                 return;
2956         }
2957
2958         spin_lock_irq(&tsk->sighand->siglock);
2959         /*
2960          * From now this task is not visible for group-wide signals,
2961          * see wants_signal(), do_signal_stop().
2962          */
2963         tsk->flags |= PF_EXITING;
2964
2965         cgroup_threadgroup_change_end(tsk);
2966
2967         if (!task_sigpending(tsk))
2968                 goto out;
2969
2970         unblocked = tsk->blocked;
2971         signotset(&unblocked);
2972         retarget_shared_pending(tsk, &unblocked);
2973
2974         if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) &&
2975             task_participate_group_stop(tsk))
2976                 group_stop = CLD_STOPPED;
2977 out:
2978         spin_unlock_irq(&tsk->sighand->siglock);
2979
2980         /*
2981          * If group stop has completed, deliver the notification.  This
2982          * should always go to the real parent of the group leader.
2983          */
2984         if (unlikely(group_stop)) {
2985                 read_lock(&tasklist_lock);
2986                 do_notify_parent_cldstop(tsk, false, group_stop);
2987                 read_unlock(&tasklist_lock);
2988         }
2989 }
2990
2991 /*
2992  * System call entry points.
2993  */
2994
2995 /**
2996  *  sys_restart_syscall - restart a system call
2997  */
2998 SYSCALL_DEFINE0(restart_syscall)
2999 {
3000         struct restart_block *restart = &current->restart_block;
3001         return restart->fn(restart);
3002 }
3003
3004 long do_no_restart_syscall(struct restart_block *param)
3005 {
3006         return -EINTR;
3007 }
3008
3009 static void __set_task_blocked(struct task_struct *tsk, const sigset_t *newset)
3010 {
3011         if (task_sigpending(tsk) && !thread_group_empty(tsk)) {
3012                 sigset_t newblocked;
3013                 /* A set of now blocked but previously unblocked signals. */
3014                 sigandnsets(&newblocked, newset, &current->blocked);
3015                 retarget_shared_pending(tsk, &newblocked);
3016         }
3017         tsk->blocked = *newset;
3018         recalc_sigpending();
3019 }
3020
3021 /**
3022  * set_current_blocked - change current->blocked mask
3023  * @newset: new mask
3024  *
3025  * It is wrong to change ->blocked directly, this helper should be used
3026  * to ensure the process can't miss a shared signal we are going to block.
3027  */
3028 void set_current_blocked(sigset_t *newset)
3029 {
3030         sigdelsetmask(newset, sigmask(SIGKILL) | sigmask(SIGSTOP));
3031         __set_current_blocked(newset);
3032 }
3033
3034 void __set_current_blocked(const sigset_t *newset)
3035 {
3036         struct task_struct *tsk = current;
3037
3038         /*
3039          * In case the signal mask hasn't changed, there is nothing we need
3040          * to do. The current->blocked shouldn't be modified by other task.
3041          */
3042         if (sigequalsets(&tsk->blocked, newset))
3043                 return;
3044
3045         spin_lock_irq(&tsk->sighand->siglock);
3046         __set_task_blocked(tsk, newset);
3047         spin_unlock_irq(&tsk->sighand->siglock);
3048 }
3049
3050 /*
3051  * This is also useful for kernel threads that want to temporarily
3052  * (or permanently) block certain signals.
3053  *
3054  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
3055  * interface happily blocks "unblockable" signals like SIGKILL
3056  * and friends.
3057  */
3058 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
3059 {
3060         struct task_struct *tsk = current;
3061         sigset_t newset;
3062
3063         /* Lockless, only current can change ->blocked, never from irq */
3064         if (oldset)
3065                 *oldset = tsk->blocked;
3066
3067         switch (how) {
3068         case SIG_BLOCK:
3069                 sigorsets(&newset, &tsk->blocked, set);
3070                 break;
3071         case SIG_UNBLOCK:
3072                 sigandnsets(&newset, &tsk->blocked, set);
3073                 break;
3074         case SIG_SETMASK:
3075                 newset = *set;
3076                 break;
3077         default:
3078                 return -EINVAL;
3079         }
3080
3081         __set_current_blocked(&newset);
3082         return 0;
3083 }
3084 EXPORT_SYMBOL(sigprocmask);
3085
3086 /*
3087  * The api helps set app-provided sigmasks.
3088  *
3089  * This is useful for syscalls such as ppoll, pselect, io_pgetevents and
3090  * epoll_pwait where a new sigmask is passed from userland for the syscalls.
3091  *
3092  * Note that it does set_restore_sigmask() in advance, so it must be always
3093  * paired with restore_saved_sigmask_unless() before return from syscall.
3094  */
3095 int set_user_sigmask(const sigset_t __user *umask, size_t sigsetsize)
3096 {
3097         sigset_t kmask;
3098
3099         if (!umask)
3100                 return 0;
3101         if (sigsetsize != sizeof(sigset_t))
3102                 return -EINVAL;
3103         if (copy_from_user(&kmask, umask, sizeof(sigset_t)))
3104                 return -EFAULT;
3105
3106         set_restore_sigmask();
3107         current->saved_sigmask = current->blocked;
3108         set_current_blocked(&kmask);
3109
3110         return 0;
3111 }
3112
3113 #ifdef CONFIG_COMPAT
3114 int set_compat_user_sigmask(const compat_sigset_t __user *umask,
3115                             size_t sigsetsize)
3116 {
3117         sigset_t kmask;
3118
3119         if (!umask)
3120                 return 0;
3121         if (sigsetsize != sizeof(compat_sigset_t))
3122                 return -EINVAL;
3123         if (get_compat_sigset(&kmask, umask))
3124                 return -EFAULT;
3125
3126         set_restore_sigmask();
3127         current->saved_sigmask = current->blocked;
3128         set_current_blocked(&kmask);
3129
3130         return 0;
3131 }
3132 #endif
3133
3134 /**
3135  *  sys_rt_sigprocmask - change the list of currently blocked signals
3136  *  @how: whether to add, remove, or set signals
3137  *  @nset: stores pending signals
3138  *  @oset: previous value of signal mask if non-null
3139  *  @sigsetsize: size of sigset_t type
3140  */
3141 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, nset,
3142                 sigset_t __user *, oset, size_t, sigsetsize)
3143 {
3144         sigset_t old_set, new_set;
3145         int error;
3146
3147         /* XXX: Don't preclude handling different sized sigset_t's.  */
3148         if (sigsetsize != sizeof(sigset_t))
3149                 return -EINVAL;
3150
3151         old_set = current->blocked;
3152
3153         if (nset) {
3154                 if (copy_from_user(&new_set, nset, sizeof(sigset_t)))
3155                         return -EFAULT;
3156                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
3157
3158                 error = sigprocmask(how, &new_set, NULL);
3159                 if (error)
3160                         return error;
3161         }
3162
3163         if (oset) {
3164                 if (copy_to_user(oset, &old_set, sizeof(sigset_t)))
3165                         return -EFAULT;
3166         }
3167
3168         return 0;
3169 }
3170
3171 #ifdef CONFIG_COMPAT
3172 COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user *, nset,
3173                 compat_sigset_t __user *, oset, compat_size_t, sigsetsize)
3174 {
3175         sigset_t old_set = current->blocked;
3176
3177         /* XXX: Don't preclude handling different sized sigset_t's.  */
3178         if (sigsetsize != sizeof(sigset_t))
3179                 return -EINVAL;
3180
3181         if (nset) {
3182                 sigset_t new_set;
3183                 int error;
3184                 if (get_compat_sigset(&new_set, nset))
3185                         return -EFAULT;
3186                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
3187
3188                 error = sigprocmask(how, &new_set, NULL);
3189                 if (error)
3190                         return error;
3191         }
3192         return oset ? put_compat_sigset(oset, &old_set, sizeof(*oset)) : 0;
3193 }
3194 #endif
3195
3196 static void do_sigpending(sigset_t *set)
3197 {
3198         spin_lock_irq(&current->sighand->siglock);
3199         sigorsets(set, &current->pending.signal,
3200                   &current->signal->shared_pending.signal);
3201         spin_unlock_irq(&current->sighand->siglock);
3202
3203         /* Outside the lock because only this thread touches it.  */
3204         sigandsets(set, &current->blocked, set);
3205 }
3206
3207 /**
3208  *  sys_rt_sigpending - examine a pending signal that has been raised
3209  *                      while blocked
3210  *  @uset: stores pending signals
3211  *  @sigsetsize: size of sigset_t type or larger
3212  */
3213 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, uset, size_t, sigsetsize)
3214 {
3215         sigset_t set;
3216
3217         if (sigsetsize > sizeof(*uset))
3218                 return -EINVAL;
3219
3220         do_sigpending(&set);
3221
3222         if (copy_to_user(uset, &set, sigsetsize))
3223                 return -EFAULT;
3224
3225         return 0;
3226 }
3227
3228 #ifdef CONFIG_COMPAT
3229 COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user *, uset,
3230                 compat_size_t, sigsetsize)
3231 {
3232         sigset_t set;
3233
3234         if (sigsetsize > sizeof(*uset))
3235                 return -EINVAL;
3236
3237         do_sigpending(&set);
3238
3239         return put_compat_sigset(uset, &set, sigsetsize);
3240 }
3241 #endif
3242
3243 static const struct {
3244         unsigned char limit, layout;
3245 } sig_sicodes[] = {
3246         [SIGILL]  = { NSIGILL,  SIL_FAULT },
3247         [SIGFPE]  = { NSIGFPE,  SIL_FAULT },
3248         [SIGSEGV] = { NSIGSEGV, SIL_FAULT },
3249         [SIGBUS]  = { NSIGBUS,  SIL_FAULT },
3250         [SIGTRAP] = { NSIGTRAP, SIL_FAULT },
3251 #if defined(SIGEMT)
3252         [SIGEMT]  = { NSIGEMT,  SIL_FAULT },
3253 #endif
3254         [SIGCHLD] = { NSIGCHLD, SIL_CHLD },
3255         [SIGPOLL] = { NSIGPOLL, SIL_POLL },
3256         [SIGSYS]  = { NSIGSYS,  SIL_SYS },
3257 };
3258
3259 static bool known_siginfo_layout(unsigned sig, int si_code)
3260 {
3261         if (si_code == SI_KERNEL)
3262                 return true;
3263         else if ((si_code > SI_USER)) {
3264                 if (sig_specific_sicodes(sig)) {
3265                         if (si_code <= sig_sicodes[sig].limit)
3266                                 return true;
3267                 }
3268                 else if (si_code <= NSIGPOLL)
3269                         return true;
3270         }
3271         else if (si_code >= SI_DETHREAD)
3272                 return true;
3273         else if (si_code == SI_ASYNCNL)
3274                 return true;
3275         return false;
3276 }
3277
3278 enum siginfo_layout siginfo_layout(unsigned sig, int si_code)
3279 {
3280         enum siginfo_layout layout = SIL_KILL;
3281         if ((si_code > SI_USER) && (si_code < SI_KERNEL)) {
3282                 if ((sig < ARRAY_SIZE(sig_sicodes)) &&
3283                     (si_code <= sig_sicodes[sig].limit)) {
3284                         layout = sig_sicodes[sig].layout;
3285                         /* Handle the exceptions */
3286                         if ((sig == SIGBUS) &&
3287                             (si_code >= BUS_MCEERR_AR) && (si_code <= BUS_MCEERR_AO))
3288                                 layout = SIL_FAULT_MCEERR;
3289                         else if ((sig == SIGSEGV) && (si_code == SEGV_BNDERR))
3290                                 layout = SIL_FAULT_BNDERR;
3291 #ifdef SEGV_PKUERR
3292                         else if ((sig == SIGSEGV) && (si_code == SEGV_PKUERR))
3293                                 layout = SIL_FAULT_PKUERR;
3294 #endif
3295                         else if ((sig == SIGTRAP) && (si_code == TRAP_PERF))
3296                                 layout = SIL_FAULT_PERF_EVENT;
3297                         else if (IS_ENABLED(CONFIG_SPARC) &&
3298                                  (sig == SIGILL) && (si_code == ILL_ILLTRP))
3299                                 layout = SIL_FAULT_TRAPNO;
3300                         else if (IS_ENABLED(CONFIG_ALPHA) &&
3301                                  ((sig == SIGFPE) ||
3302                                   ((sig == SIGTRAP) && (si_code == TRAP_UNK))))
3303                                 layout = SIL_FAULT_TRAPNO;
3304                 }
3305                 else if (si_code <= NSIGPOLL)
3306                         layout = SIL_POLL;
3307         } else {
3308                 if (si_code == SI_TIMER)
3309                         layout = SIL_TIMER;
3310                 else if (si_code == SI_SIGIO)
3311                         layout = SIL_POLL;
3312                 else if (si_code < 0)
3313                         layout = SIL_RT;
3314         }
3315         return layout;
3316 }
3317
3318 static inline char __user *si_expansion(const siginfo_t __user *info)
3319 {
3320         return ((char __user *)info) + sizeof(struct kernel_siginfo);
3321 }
3322
3323 int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from)
3324 {
3325         char __user *expansion = si_expansion(to);
3326         if (copy_to_user(to, from , sizeof(struct kernel_siginfo)))
3327                 return -EFAULT;
3328         if (clear_user(expansion, SI_EXPANSION_SIZE))
3329                 return -EFAULT;
3330         return 0;
3331 }
3332
3333 static int post_copy_siginfo_from_user(kernel_siginfo_t *info,
3334                                        const siginfo_t __user *from)
3335 {
3336         if (unlikely(!known_siginfo_layout(info->si_signo, info->si_code))) {
3337                 char __user *expansion = si_expansion(from);
3338                 char buf[SI_EXPANSION_SIZE];
3339                 int i;
3340                 /*
3341                  * An unknown si_code might need more than
3342                  * sizeof(struct kernel_siginfo) bytes.  Verify all of the
3343                  * extra bytes are 0.  This guarantees copy_siginfo_to_user
3344                  * will return this data to userspace exactly.
3345                  */
3346                 if (copy_from_user(&buf, expansion, SI_EXPANSION_SIZE))
3347                         return -EFAULT;
3348                 for (i = 0; i < SI_EXPANSION_SIZE; i++) {
3349                         if (buf[i] != 0)
3350                                 return -E2BIG;
3351                 }
3352         }
3353         return 0;
3354 }
3355
3356 static int __copy_siginfo_from_user(int signo, kernel_siginfo_t *to,
3357                                     const siginfo_t __user *from)
3358 {
3359         if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3360                 return -EFAULT;
3361         to->si_signo = signo;
3362         return post_copy_siginfo_from_user(to, from);
3363 }
3364
3365 int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from)
3366 {
3367         if (copy_from_user(to, from, sizeof(struct kernel_siginfo)))
3368                 return -EFAULT;
3369         return post_copy_siginfo_from_user(to, from);
3370 }
3371
3372 #ifdef CONFIG_COMPAT
3373 /**
3374  * copy_siginfo_to_external32 - copy a kernel siginfo into a compat user siginfo
3375  * @to: compat siginfo destination
3376  * @from: kernel siginfo source
3377  *
3378  * Note: This function does not work properly for the SIGCHLD on x32, but
3379  * fortunately it doesn't have to.  The only valid callers for this function are
3380  * copy_siginfo_to_user32, which is overriden for x32 and the coredump code.
3381  * The latter does not care because SIGCHLD will never cause a coredump.
3382  */
3383 void copy_siginfo_to_external32(struct compat_siginfo *to,
3384                 const struct kernel_siginfo *from)
3385 {
3386         memset(to, 0, sizeof(*to));
3387
3388         to->si_signo = from->si_signo;
3389         to->si_errno = from->si_errno;
3390         to->si_code  = from->si_code;
3391         switch(siginfo_layout(from->si_signo, from->si_code)) {
3392         case SIL_KILL:
3393                 to->si_pid = from->si_pid;
3394                 to->si_uid = from->si_uid;
3395                 break;
3396         case SIL_TIMER:
3397                 to->si_tid     = from->si_tid;
3398                 to->si_overrun = from->si_overrun;
3399                 to->si_int     = from->si_int;
3400                 break;
3401         case SIL_POLL:
3402                 to->si_band = from->si_band;
3403                 to->si_fd   = from->si_fd;
3404                 break;
3405         case SIL_FAULT:
3406                 to->si_addr = ptr_to_compat(from->si_addr);
3407                 break;
3408         case SIL_FAULT_TRAPNO:
3409                 to->si_addr = ptr_to_compat(from->si_addr);
3410                 to->si_trapno = from->si_trapno;
3411                 break;
3412         case SIL_FAULT_MCEERR:
3413                 to->si_addr = ptr_to_compat(from->si_addr);
3414                 to->si_addr_lsb = from->si_addr_lsb;
3415                 break;
3416         case SIL_FAULT_BNDERR:
3417                 to->si_addr = ptr_to_compat(from->si_addr);
3418                 to->si_lower = ptr_to_compat(from->si_lower);
3419                 to->si_upper = ptr_to_compat(from->si_upper);
3420                 break;
3421         case SIL_FAULT_PKUERR:
3422                 to->si_addr = ptr_to_compat(from->si_addr);
3423                 to->si_pkey = from->si_pkey;
3424                 break;
3425         case SIL_FAULT_PERF_EVENT:
3426                 to->si_addr = ptr_to_compat(from->si_addr);
3427                 to->si_perf_data = from->si_perf_data;
3428                 to->si_perf_type = from->si_perf_type;
3429                 to->si_perf_flags = from->si_perf_flags;
3430                 break;
3431         case SIL_CHLD:
3432                 to->si_pid = from->si_pid;
3433                 to->si_uid = from->si_uid;
3434                 to->si_status = from->si_status;
3435                 to->si_utime = from->si_utime;
3436                 to->si_stime = from->si_stime;
3437                 break;
3438         case SIL_RT:
3439                 to->si_pid = from->si_pid;
3440                 to->si_uid = from->si_uid;
3441                 to->si_int = from->si_int;
3442                 break;
3443         case SIL_SYS:
3444                 to->si_call_addr = ptr_to_compat(from->si_call_addr);
3445                 to->si_syscall   = from->si_syscall;
3446                 to->si_arch      = from->si_arch;
3447                 break;
3448         }
3449 }
3450
3451 int __copy_siginfo_to_user32(struct compat_siginfo __user *to,
3452                            const struct kernel_siginfo *from)
3453 {
3454         struct compat_siginfo new;
3455
3456         copy_siginfo_to_external32(&new, from);
3457         if (copy_to_user(to, &new, sizeof(struct compat_siginfo)))
3458                 return -EFAULT;
3459         return 0;
3460 }
3461
3462 static int post_copy_siginfo_from_user32(kernel_siginfo_t *to,
3463                                          const struct compat_siginfo *from)
3464 {
3465         clear_siginfo(to);
3466         to->si_signo = from->si_signo;
3467         to->si_errno = from->si_errno;
3468         to->si_code  = from->si_code;
3469         switch(siginfo_layout(from->si_signo, from->si_code)) {
3470         case SIL_KILL:
3471                 to->si_pid = from->si_pid;
3472                 to->si_uid = from->si_uid;
3473                 break;
3474         case SIL_TIMER:
3475                 to->si_tid     = from->si_tid;
3476                 to->si_overrun = from->si_overrun;
3477                 to->si_int     = from->si_int;
3478                 break;
3479         case SIL_POLL:
3480                 to->si_band = from->si_band;
3481                 to->si_fd   = from->si_fd;
3482                 break;
3483         case SIL_FAULT:
3484                 to->si_addr = compat_ptr(from->si_addr);
3485                 break;
3486         case SIL_FAULT_TRAPNO:
3487                 to->si_addr = compat_ptr(from->si_addr);
3488                 to->si_trapno = from->si_trapno;
3489                 break;
3490         case SIL_FAULT_MCEERR:
3491                 to->si_addr = compat_ptr(from->si_addr);
3492                 to->si_addr_lsb = from->si_addr_lsb;
3493                 break;
3494         case SIL_FAULT_BNDERR:
3495                 to->si_addr = compat_ptr(from->si_addr);
3496                 to->si_lower = compat_ptr(from->si_lower);
3497                 to->si_upper = compat_ptr(from->si_upper);
3498                 break;
3499         case SIL_FAULT_PKUERR:
3500                 to->si_addr = compat_ptr(from->si_addr);
3501                 to->si_pkey = from->si_pkey;
3502                 break;
3503         case SIL_FAULT_PERF_EVENT:
3504                 to->si_addr = compat_ptr(from->si_addr);
3505                 to->si_perf_data = from->si_perf_data;
3506                 to->si_perf_type = from->si_perf_type;
3507                 to->si_perf_flags = from->si_perf_flags;
3508                 break;
3509         case SIL_CHLD:
3510                 to->si_pid    = from->si_pid;
3511                 to->si_uid    = from->si_uid;
3512                 to->si_status = from->si_status;
3513 #ifdef CONFIG_X86_X32_ABI
3514                 if (in_x32_syscall()) {
3515                         to->si_utime = from->_sifields._sigchld_x32._utime;
3516                         to->si_stime = from->_sifields._sigchld_x32._stime;
3517                 } else
3518 #endif
3519                 {
3520                         to->si_utime = from->si_utime;
3521                         to->si_stime = from->si_stime;
3522                 }
3523                 break;
3524         case SIL_RT:
3525                 to->si_pid = from->si_pid;
3526                 to->si_uid = from->si_uid;
3527                 to->si_int = from->si_int;
3528                 break;
3529         case SIL_SYS:
3530                 to->si_call_addr = compat_ptr(from->si_call_addr);
3531                 to->si_syscall   = from->si_syscall;
3532                 to->si_arch      = from->si_arch;
3533                 break;
3534         }
3535         return 0;
3536 }
3537
3538 static int __copy_siginfo_from_user32(int signo, struct kernel_siginfo *to,
3539                                       const struct compat_siginfo __user *ufrom)
3540 {
3541         struct compat_siginfo from;
3542
3543         if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3544                 return -EFAULT;
3545
3546         from.si_signo = signo;
3547         return post_copy_siginfo_from_user32(to, &from);
3548 }
3549
3550 int copy_siginfo_from_user32(struct kernel_siginfo *to,
3551                              const struct compat_siginfo __user *ufrom)
3552 {
3553         struct compat_siginfo from;
3554
3555         if (copy_from_user(&from, ufrom, sizeof(struct compat_siginfo)))
3556                 return -EFAULT;
3557
3558         return post_copy_siginfo_from_user32(to, &from);
3559 }
3560 #endif /* CONFIG_COMPAT */
3561
3562 /**
3563  *  do_sigtimedwait - wait for queued signals specified in @which
3564  *  @which: queued signals to wait for
3565  *  @info: if non-null, the signal's siginfo is returned here
3566  *  @ts: upper bound on process time suspension
3567  */
3568 static int do_sigtimedwait(const sigset_t *which, kernel_siginfo_t *info,
3569                     const struct timespec64 *ts)
3570 {
3571         ktime_t *to = NULL, timeout = KTIME_MAX;
3572         struct task_struct *tsk = current;
3573         sigset_t mask = *which;
3574         enum pid_type type;
3575         int sig, ret = 0;
3576
3577         if (ts) {
3578                 if (!timespec64_valid(ts))
3579                         return -EINVAL;
3580                 timeout = timespec64_to_ktime(*ts);
3581                 to = &timeout;
3582         }
3583
3584         /*
3585          * Invert the set of allowed signals to get those we want to block.
3586          */
3587         sigdelsetmask(&mask, sigmask(SIGKILL) | sigmask(SIGSTOP));
3588         signotset(&mask);
3589
3590         spin_lock_irq(&tsk->sighand->siglock);
3591         sig = dequeue_signal(tsk, &mask, info, &type);
3592         if (!sig && timeout) {
3593                 /*
3594                  * None ready, temporarily unblock those we're interested
3595                  * while we are sleeping in so that we'll be awakened when
3596                  * they arrive. Unblocking is always fine, we can avoid
3597                  * set_current_blocked().
3598                  */
3599                 tsk->real_blocked = tsk->blocked;
3600                 sigandsets(&tsk->blocked, &tsk->blocked, &mask);
3601                 recalc_sigpending();
3602                 spin_unlock_irq(&tsk->sighand->siglock);
3603
3604                 __set_current_state(TASK_INTERRUPTIBLE|TASK_FREEZABLE);
3605                 ret = schedule_hrtimeout_range(to, tsk->timer_slack_ns,
3606                                                HRTIMER_MODE_REL);
3607                 spin_lock_irq(&tsk->sighand->siglock);
3608                 __set_task_blocked(tsk, &tsk->real_blocked);
3609                 sigemptyset(&tsk->real_blocked);
3610                 sig = dequeue_signal(tsk, &mask, info, &type);
3611         }
3612         spin_unlock_irq(&tsk->sighand->siglock);
3613
3614         if (sig)
3615                 return sig;
3616         return ret ? -EINTR : -EAGAIN;
3617 }
3618
3619 /**
3620  *  sys_rt_sigtimedwait - synchronously wait for queued signals specified
3621  *                      in @uthese
3622  *  @uthese: queued signals to wait for
3623  *  @uinfo: if non-null, the signal's siginfo is returned here
3624  *  @uts: upper bound on process time suspension
3625  *  @sigsetsize: size of sigset_t type
3626  */
3627 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
3628                 siginfo_t __user *, uinfo,
3629                 const struct __kernel_timespec __user *, uts,
3630                 size_t, sigsetsize)
3631 {
3632         sigset_t these;
3633         struct timespec64 ts;
3634         kernel_siginfo_t info;
3635         int ret;
3636
3637         /* XXX: Don't preclude handling different sized sigset_t's.  */
3638         if (sigsetsize != sizeof(sigset_t))
3639                 return -EINVAL;
3640
3641         if (copy_from_user(&these, uthese, sizeof(these)))
3642                 return -EFAULT;
3643
3644         if (uts) {
3645                 if (get_timespec64(&ts, uts))
3646                         return -EFAULT;
3647         }
3648
3649         ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3650
3651         if (ret > 0 && uinfo) {
3652                 if (copy_siginfo_to_user(uinfo, &info))
3653                         ret = -EFAULT;
3654         }
3655
3656         return ret;
3657 }
3658
3659 #ifdef CONFIG_COMPAT_32BIT_TIME
3660 SYSCALL_DEFINE4(rt_sigtimedwait_time32, const sigset_t __user *, uthese,
3661                 siginfo_t __user *, uinfo,
3662                 const struct old_timespec32 __user *, uts,
3663                 size_t, sigsetsize)
3664 {
3665         sigset_t these;
3666         struct timespec64 ts;
3667         kernel_siginfo_t info;
3668         int ret;
3669
3670         if (sigsetsize != sizeof(sigset_t))
3671                 return -EINVAL;
3672
3673         if (copy_from_user(&these, uthese, sizeof(these)))
3674                 return -EFAULT;
3675
3676         if (uts) {
3677                 if (get_old_timespec32(&ts, uts))
3678                         return -EFAULT;
3679         }
3680
3681         ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL);
3682
3683         if (ret > 0 && uinfo) {
3684                 if (copy_siginfo_to_user(uinfo, &info))
3685                         ret = -EFAULT;
3686         }
3687
3688         return ret;
3689 }
3690 #endif
3691
3692 #ifdef CONFIG_COMPAT
3693 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time64, compat_sigset_t __user *, uthese,
3694                 struct compat_siginfo __user *, uinfo,
3695                 struct __kernel_timespec __user *, uts, compat_size_t, sigsetsize)
3696 {
3697         sigset_t s;
3698         struct timespec64 t;
3699         kernel_siginfo_t info;
3700         long ret;
3701
3702         if (sigsetsize != sizeof(sigset_t))
3703                 return -EINVAL;
3704
3705         if (get_compat_sigset(&s, uthese))
3706                 return -EFAULT;
3707
3708         if (uts) {
3709                 if (get_timespec64(&t, uts))
3710                         return -EFAULT;
3711         }
3712
3713         ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3714
3715         if (ret > 0 && uinfo) {
3716                 if (copy_siginfo_to_user32(uinfo, &info))
3717                         ret = -EFAULT;
3718         }
3719
3720         return ret;
3721 }
3722
3723 #ifdef CONFIG_COMPAT_32BIT_TIME
3724 COMPAT_SYSCALL_DEFINE4(rt_sigtimedwait_time32, compat_sigset_t __user *, uthese,
3725                 struct compat_siginfo __user *, uinfo,
3726                 struct old_timespec32 __user *, uts, compat_size_t, sigsetsize)
3727 {
3728         sigset_t s;
3729         struct timespec64 t;
3730         kernel_siginfo_t info;
3731         long ret;
3732
3733         if (sigsetsize != sizeof(sigset_t))
3734                 return -EINVAL;
3735
3736         if (get_compat_sigset(&s, uthese))
3737                 return -EFAULT;
3738
3739         if (uts) {
3740                 if (get_old_timespec32(&t, uts))
3741                         return -EFAULT;
3742         }
3743
3744         ret = do_sigtimedwait(&s, &info, uts ? &t : NULL);
3745
3746         if (ret > 0 && uinfo) {
3747                 if (copy_siginfo_to_user32(uinfo, &info))
3748                         ret = -EFAULT;
3749         }
3750
3751         return ret;
3752 }
3753 #endif
3754 #endif
3755
3756 static inline void prepare_kill_siginfo(int sig, struct kernel_siginfo *info)
3757 {
3758         clear_siginfo(info);
3759         info->si_signo = sig;
3760         info->si_errno = 0;
3761         info->si_code = SI_USER;
3762         info->si_pid = task_tgid_vnr(current);
3763         info->si_uid = from_kuid_munged(current_user_ns(), current_uid());
3764 }
3765
3766 /**
3767  *  sys_kill - send a signal to a process
3768  *  @pid: the PID of the process
3769  *  @sig: signal to be sent
3770  */
3771 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
3772 {
3773         struct kernel_siginfo info;
3774
3775         prepare_kill_siginfo(sig, &info);
3776
3777         return kill_something_info(sig, &info, pid);
3778 }
3779
3780 /*
3781  * Verify that the signaler and signalee either are in the same pid namespace
3782  * or that the signaler's pid namespace is an ancestor of the signalee's pid
3783  * namespace.
3784  */
3785 static bool access_pidfd_pidns(struct pid *pid)
3786 {
3787         struct pid_namespace *active = task_active_pid_ns(current);
3788         struct pid_namespace *p = ns_of_pid(pid);
3789
3790         for (;;) {
3791                 if (!p)
3792                         return false;
3793                 if (p == active)
3794                         break;
3795                 p = p->parent;
3796         }
3797
3798         return true;
3799 }
3800
3801 static int copy_siginfo_from_user_any(kernel_siginfo_t *kinfo,
3802                 siginfo_t __user *info)
3803 {
3804 #ifdef CONFIG_COMPAT
3805         /*
3806          * Avoid hooking up compat syscalls and instead handle necessary
3807          * conversions here. Note, this is a stop-gap measure and should not be
3808          * considered a generic solution.
3809          */
3810         if (in_compat_syscall())
3811                 return copy_siginfo_from_user32(
3812                         kinfo, (struct compat_siginfo __user *)info);
3813 #endif
3814         return copy_siginfo_from_user(kinfo, info);
3815 }
3816
3817 static struct pid *pidfd_to_pid(const struct file *file)
3818 {
3819         struct pid *pid;
3820
3821         pid = pidfd_pid(file);
3822         if (!IS_ERR(pid))
3823                 return pid;
3824
3825         return tgid_pidfd_to_pid(file);
3826 }
3827
3828 /**
3829  * sys_pidfd_send_signal - Signal a process through a pidfd
3830  * @pidfd:  file descriptor of the process
3831  * @sig:    signal to send
3832  * @info:   signal info
3833  * @flags:  future flags
3834  *
3835  * The syscall currently only signals via PIDTYPE_PID which covers
3836  * kill(<positive-pid>, <signal>. It does not signal threads or process
3837  * groups.
3838  * In order to extend the syscall to threads and process groups the @flags
3839  * argument should be used. In essence, the @flags argument will determine
3840  * what is signaled and not the file descriptor itself. Put in other words,
3841  * grouping is a property of the flags argument not a property of the file
3842  * descriptor.
3843  *
3844  * Return: 0 on success, negative errno on failure
3845  */
3846 SYSCALL_DEFINE4(pidfd_send_signal, int, pidfd, int, sig,
3847                 siginfo_t __user *, info, unsigned int, flags)
3848 {
3849         int ret;
3850         struct fd f;
3851         struct pid *pid;
3852         kernel_siginfo_t kinfo;
3853
3854         /* Enforce flags be set to 0 until we add an extension. */
3855         if (flags)
3856                 return -EINVAL;
3857
3858         f = fdget(pidfd);
3859         if (!f.file)
3860                 return -EBADF;
3861
3862         /* Is this a pidfd? */
3863         pid = pidfd_to_pid(f.file);
3864         if (IS_ERR(pid)) {
3865                 ret = PTR_ERR(pid);
3866                 goto err;
3867         }
3868
3869         ret = -EINVAL;
3870         if (!access_pidfd_pidns(pid))
3871                 goto err;
3872
3873         if (info) {
3874                 ret = copy_siginfo_from_user_any(&kinfo, info);
3875                 if (unlikely(ret))
3876                         goto err;
3877
3878                 ret = -EINVAL;
3879                 if (unlikely(sig != kinfo.si_signo))
3880                         goto err;
3881
3882                 /* Only allow sending arbitrary signals to yourself. */
3883                 ret = -EPERM;
3884                 if ((task_pid(current) != pid) &&
3885                     (kinfo.si_code >= 0 || kinfo.si_code == SI_TKILL))
3886                         goto err;
3887         } else {
3888                 prepare_kill_siginfo(sig, &kinfo);
3889         }
3890
3891         ret = kill_pid_info(sig, &kinfo, pid);
3892
3893 err:
3894         fdput(f);
3895         return ret;
3896 }
3897
3898 static int
3899 do_send_specific(pid_t tgid, pid_t pid, int sig, struct kernel_siginfo *info)
3900 {
3901         struct task_struct *p;
3902         int error = -ESRCH;
3903
3904         rcu_read_lock();
3905         p = find_task_by_vpid(pid);
3906         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
3907                 error = check_kill_permission(sig, info, p);
3908                 /*
3909                  * The null signal is a permissions and process existence
3910                  * probe.  No signal is actually delivered.
3911                  */
3912                 if (!error && sig) {
3913                         error = do_send_sig_info(sig, info, p, PIDTYPE_PID);
3914                         /*
3915                          * If lock_task_sighand() failed we pretend the task
3916                          * dies after receiving the signal. The window is tiny,
3917                          * and the signal is private anyway.
3918                          */
3919                         if (unlikely(error == -ESRCH))
3920                                 error = 0;
3921                 }
3922         }
3923         rcu_read_unlock();
3924
3925         return error;
3926 }
3927
3928 static int do_tkill(pid_t tgid, pid_t pid, int sig)
3929 {
3930         struct kernel_siginfo info;
3931
3932         clear_siginfo(&info);
3933         info.si_signo = sig;
3934         info.si_errno = 0;
3935         info.si_code = SI_TKILL;
3936         info.si_pid = task_tgid_vnr(current);
3937         info.si_uid = from_kuid_munged(current_user_ns(), current_uid());
3938
3939         return do_send_specific(tgid, pid, sig, &info);
3940 }
3941
3942 /**
3943  *  sys_tgkill - send signal to one specific thread
3944  *  @tgid: the thread group ID of the thread
3945  *  @pid: the PID of the thread
3946  *  @sig: signal to be sent
3947  *
3948  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
3949  *  exists but it's not belonging to the target process anymore. This
3950  *  method solves the problem of threads exiting and PIDs getting reused.
3951  */
3952 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
3953 {
3954         /* This is only valid for single tasks */
3955         if (pid <= 0 || tgid <= 0)
3956                 return -EINVAL;
3957
3958         return do_tkill(tgid, pid, sig);
3959 }
3960
3961 /**
3962  *  sys_tkill - send signal to one specific task
3963  *  @pid: the PID of the task
3964  *  @sig: signal to be sent
3965  *
3966  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
3967  */
3968 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
3969 {
3970         /* This is only valid for single tasks */
3971         if (pid <= 0)
3972                 return -EINVAL;
3973
3974         return do_tkill(0, pid, sig);
3975 }
3976
3977 static int do_rt_sigqueueinfo(pid_t pid, int sig, kernel_siginfo_t *info)
3978 {
3979         /* Not even root can pretend to send signals from the kernel.
3980          * Nor can they impersonate a kill()/tgkill(), which adds source info.
3981          */
3982         if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
3983             (task_pid_vnr(current) != pid))
3984                 return -EPERM;
3985
3986         /* POSIX.1b doesn't mention process groups.  */
3987         return kill_proc_info(sig, info, pid);
3988 }
3989
3990 /**
3991  *  sys_rt_sigqueueinfo - send signal information to a signal
3992  *  @pid: the PID of the thread
3993  *  @sig: signal to be sent
3994  *  @uinfo: signal info to be sent
3995  */
3996 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
3997                 siginfo_t __user *, uinfo)
3998 {
3999         kernel_siginfo_t info;
4000         int ret = __copy_siginfo_from_user(sig, &info, uinfo);
4001         if (unlikely(ret))
4002                 return ret;
4003         return do_rt_sigqueueinfo(pid, sig, &info);
4004 }
4005
4006 #ifdef CONFIG_COMPAT
4007 COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo,
4008                         compat_pid_t, pid,
4009                         int, sig,
4010                         struct compat_siginfo __user *, uinfo)
4011 {
4012         kernel_siginfo_t info;
4013         int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
4014         if (unlikely(ret))
4015                 return ret;
4016         return do_rt_sigqueueinfo(pid, sig, &info);
4017 }
4018 #endif
4019
4020 static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, kernel_siginfo_t *info)
4021 {
4022         /* This is only valid for single tasks */
4023         if (pid <= 0 || tgid <= 0)
4024                 return -EINVAL;
4025
4026         /* Not even root can pretend to send signals from the kernel.
4027          * Nor can they impersonate a kill()/tgkill(), which adds source info.
4028          */
4029         if ((info->si_code >= 0 || info->si_code == SI_TKILL) &&
4030             (task_pid_vnr(current) != pid))
4031                 return -EPERM;
4032
4033         return do_send_specific(tgid, pid, sig, info);
4034 }
4035
4036 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
4037                 siginfo_t __user *, uinfo)
4038 {
4039         kernel_siginfo_t info;
4040         int ret = __copy_siginfo_from_user(sig, &info, uinfo);
4041         if (unlikely(ret))
4042                 return ret;
4043         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
4044 }
4045
4046 #ifdef CONFIG_COMPAT
4047 COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo,
4048                         compat_pid_t, tgid,
4049                         compat_pid_t, pid,
4050                         int, sig,
4051                         struct compat_siginfo __user *, uinfo)
4052 {
4053         kernel_siginfo_t info;
4054         int ret = __copy_siginfo_from_user32(sig, &info, uinfo);
4055         if (unlikely(ret))
4056                 return ret;
4057         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
4058 }
4059 #endif
4060
4061 /*
4062  * For kthreads only, must not be used if cloned with CLONE_SIGHAND
4063  */
4064 void kernel_sigaction(int sig, __sighandler_t action)
4065 {
4066         spin_lock_irq(&current->sighand->siglock);
4067         current->sighand->action[sig - 1].sa.sa_handler = action;
4068         if (action == SIG_IGN) {
4069                 sigset_t mask;
4070
4071                 sigemptyset(&mask);
4072                 sigaddset(&mask, sig);
4073
4074                 flush_sigqueue_mask(&mask, &current->signal->shared_pending);
4075                 flush_sigqueue_mask(&mask, &current->pending);
4076                 recalc_sigpending();
4077         }
4078         spin_unlock_irq(&current->sighand->siglock);
4079 }
4080 EXPORT_SYMBOL(kernel_sigaction);
4081
4082 void __weak sigaction_compat_abi(struct k_sigaction *act,
4083                 struct k_sigaction *oact)
4084 {
4085 }
4086
4087 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
4088 {
4089         struct task_struct *p = current, *t;
4090         struct k_sigaction *k;
4091         sigset_t mask;
4092
4093         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
4094                 return -EINVAL;
4095
4096         k = &p->sighand->action[sig-1];
4097
4098         spin_lock_irq(&p->sighand->siglock);
4099         if (k->sa.sa_flags & SA_IMMUTABLE) {
4100                 spin_unlock_irq(&p->sighand->siglock);
4101                 return -EINVAL;
4102         }
4103         if (oact)
4104                 *oact = *k;
4105
4106         /*
4107          * Make sure that we never accidentally claim to support SA_UNSUPPORTED,
4108          * e.g. by having an architecture use the bit in their uapi.
4109          */
4110         BUILD_BUG_ON(UAPI_SA_FLAGS & SA_UNSUPPORTED);
4111
4112         /*
4113          * Clear unknown flag bits in order to allow userspace to detect missing
4114          * support for flag bits and to allow the kernel to use non-uapi bits
4115          * internally.
4116          */
4117         if (act)
4118                 act->sa.sa_flags &= UAPI_SA_FLAGS;
4119         if (oact)
4120                 oact->sa.sa_flags &= UAPI_SA_FLAGS;
4121
4122         sigaction_compat_abi(act, oact);
4123
4124         if (act) {
4125                 sigdelsetmask(&act->sa.sa_mask,
4126                               sigmask(SIGKILL) | sigmask(SIGSTOP));
4127                 *k = *act;
4128                 /*
4129                  * POSIX 3.3.1.3:
4130                  *  "Setting a signal action to SIG_IGN for a signal that is
4131                  *   pending shall cause the pending signal to be discarded,
4132                  *   whether or not it is blocked."
4133                  *
4134                  *  "Setting a signal action to SIG_DFL for a signal that is
4135                  *   pending and whose default action is to ignore the signal
4136                  *   (for example, SIGCHLD), shall cause the pending signal to
4137                  *   be discarded, whether or not it is blocked"
4138                  */
4139                 if (sig_handler_ignored(sig_handler(p, sig), sig)) {
4140                         sigemptyset(&mask);
4141                         sigaddset(&mask, sig);
4142                         flush_sigqueue_mask(&mask, &p->signal->shared_pending);
4143                         for_each_thread(p, t)
4144                                 flush_sigqueue_mask(&mask, &t->pending);
4145                 }
4146         }
4147
4148         spin_unlock_irq(&p->sighand->siglock);
4149         return 0;
4150 }
4151
4152 #ifdef CONFIG_DYNAMIC_SIGFRAME
4153 static inline void sigaltstack_lock(void)
4154         __acquires(&current->sighand->siglock)
4155 {
4156         spin_lock_irq(&current->sighand->siglock);
4157 }
4158
4159 static inline void sigaltstack_unlock(void)
4160         __releases(&current->sighand->siglock)
4161 {
4162         spin_unlock_irq(&current->sighand->siglock);
4163 }
4164 #else
4165 static inline void sigaltstack_lock(void) { }
4166 static inline void sigaltstack_unlock(void) { }
4167 #endif
4168
4169 static int
4170 do_sigaltstack (const stack_t *ss, stack_t *oss, unsigned long sp,
4171                 size_t min_ss_size)
4172 {
4173         struct task_struct *t = current;
4174         int ret = 0;
4175
4176         if (oss) {
4177                 memset(oss, 0, sizeof(stack_t));
4178                 oss->ss_sp = (void __user *) t->sas_ss_sp;
4179                 oss->ss_size = t->sas_ss_size;
4180                 oss->ss_flags = sas_ss_flags(sp) |
4181                         (current->sas_ss_flags & SS_FLAG_BITS);
4182         }
4183
4184         if (ss) {
4185                 void __user *ss_sp = ss->ss_sp;
4186                 size_t ss_size = ss->ss_size;
4187                 unsigned ss_flags = ss->ss_flags;
4188                 int ss_mode;
4189
4190                 if (unlikely(on_sig_stack(sp)))
4191                         return -EPERM;
4192
4193                 ss_mode = ss_flags & ~SS_FLAG_BITS;
4194                 if (unlikely(ss_mode != SS_DISABLE && ss_mode != SS_ONSTACK &&
4195                                 ss_mode != 0))
4196                         return -EINVAL;
4197
4198                 /*
4199                  * Return before taking any locks if no actual
4200                  * sigaltstack changes were requested.
4201                  */
4202                 if (t->sas_ss_sp == (unsigned long)ss_sp &&
4203                     t->sas_ss_size == ss_size &&
4204                     t->sas_ss_flags == ss_flags)
4205                         return 0;
4206
4207                 sigaltstack_lock();
4208                 if (ss_mode == SS_DISABLE) {
4209                         ss_size = 0;
4210                         ss_sp = NULL;
4211                 } else {
4212                         if (unlikely(ss_size < min_ss_size))
4213                                 ret = -ENOMEM;
4214                         if (!sigaltstack_size_valid(ss_size))
4215                                 ret = -ENOMEM;
4216                 }
4217                 if (!ret) {
4218                         t->sas_ss_sp = (unsigned long) ss_sp;
4219                         t->sas_ss_size = ss_size;
4220                         t->sas_ss_flags = ss_flags;
4221                 }
4222                 sigaltstack_unlock();
4223         }
4224         return ret;
4225 }
4226
4227 SYSCALL_DEFINE2(sigaltstack,const stack_t __user *,uss, stack_t __user *,uoss)
4228 {
4229         stack_t new, old;
4230         int err;
4231         if (uss && copy_from_user(&new, uss, sizeof(stack_t)))
4232                 return -EFAULT;
4233         err = do_sigaltstack(uss ? &new : NULL, uoss ? &old : NULL,
4234                               current_user_stack_pointer(),
4235                               MINSIGSTKSZ);
4236         if (!err && uoss && copy_to_user(uoss, &old, sizeof(stack_t)))
4237                 err = -EFAULT;
4238         return err;
4239 }
4240
4241 int restore_altstack(const stack_t __user *uss)
4242 {
4243         stack_t new;
4244         if (copy_from_user(&new, uss, sizeof(stack_t)))
4245                 return -EFAULT;
4246         (void)do_sigaltstack(&new, NULL, current_user_stack_pointer(),
4247                              MINSIGSTKSZ);
4248         /* squash all but EFAULT for now */
4249         return 0;
4250 }
4251
4252 int __save_altstack(stack_t __user *uss, unsigned long sp)
4253 {
4254         struct task_struct *t = current;
4255         int err = __put_user((void __user *)t->sas_ss_sp, &uss->ss_sp) |
4256                 __put_user(t->sas_ss_flags, &uss->ss_flags) |
4257                 __put_user(t->sas_ss_size, &uss->ss_size);
4258         return err;
4259 }
4260
4261 #ifdef CONFIG_COMPAT
4262 static int do_compat_sigaltstack(const compat_stack_t __user *uss_ptr,
4263                                  compat_stack_t __user *uoss_ptr)
4264 {
4265         stack_t uss, uoss;
4266         int ret;
4267
4268         if (uss_ptr) {
4269                 compat_stack_t uss32;
4270                 if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t)))
4271                         return -EFAULT;
4272                 uss.ss_sp = compat_ptr(uss32.ss_sp);
4273                 uss.ss_flags = uss32.ss_flags;
4274                 uss.ss_size = uss32.ss_size;
4275         }
4276         ret = do_sigaltstack(uss_ptr ? &uss : NULL, &uoss,
4277                              compat_user_stack_pointer(),
4278                              COMPAT_MINSIGSTKSZ);
4279         if (ret >= 0 && uoss_ptr)  {
4280                 compat_stack_t old;
4281                 memset(&old, 0, sizeof(old));
4282                 old.ss_sp = ptr_to_compat(uoss.ss_sp);
4283                 old.ss_flags = uoss.ss_flags;
4284                 old.ss_size = uoss.ss_size;
4285                 if (copy_to_user(uoss_ptr, &old, sizeof(compat_stack_t)))
4286                         ret = -EFAULT;
4287         }
4288         return ret;
4289 }
4290
4291 COMPAT_SYSCALL_DEFINE2(sigaltstack,
4292                         const compat_stack_t __user *, uss_ptr,
4293                         compat_stack_t __user *, uoss_ptr)
4294 {
4295         return do_compat_sigaltstack(uss_ptr, uoss_ptr);
4296 }
4297
4298 int compat_restore_altstack(const compat_stack_t __user *uss)
4299 {
4300         int err = do_compat_sigaltstack(uss, NULL);
4301         /* squash all but -EFAULT for now */
4302         return err == -EFAULT ? err : 0;
4303 }
4304
4305 int __compat_save_altstack(compat_stack_t __user *uss, unsigned long sp)
4306 {
4307         int err;
4308         struct task_struct *t = current;
4309         err = __put_user(ptr_to_compat((void __user *)t->sas_ss_sp),
4310                          &uss->ss_sp) |
4311                 __put_user(t->sas_ss_flags, &uss->ss_flags) |
4312                 __put_user(t->sas_ss_size, &uss->ss_size);
4313         return err;
4314 }
4315 #endif
4316
4317 #ifdef __ARCH_WANT_SYS_SIGPENDING
4318
4319 /**
4320  *  sys_sigpending - examine pending signals
4321  *  @uset: where mask of pending signal is returned
4322  */
4323 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, uset)
4324 {
4325         sigset_t set;
4326
4327         if (sizeof(old_sigset_t) > sizeof(*uset))
4328                 return -EINVAL;
4329
4330         do_sigpending(&set);
4331
4332         if (copy_to_user(uset, &set, sizeof(old_sigset_t)))
4333                 return -EFAULT;
4334
4335         return 0;
4336 }
4337
4338 #ifdef CONFIG_COMPAT
4339 COMPAT_SYSCALL_DEFINE1(sigpending, compat_old_sigset_t __user *, set32)
4340 {
4341         sigset_t set;
4342
4343         do_sigpending(&set);
4344
4345         return put_user(set.sig[0], set32);
4346 }
4347 #endif
4348
4349 #endif
4350
4351 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
4352 /**
4353  *  sys_sigprocmask - examine and change blocked signals
4354  *  @how: whether to add, remove, or set signals
4355  *  @nset: signals to add or remove (if non-null)
4356  *  @oset: previous value of signal mask if non-null
4357  *
4358  * Some platforms have their own version with special arguments;
4359  * others support only sys_rt_sigprocmask.
4360  */
4361
4362 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, nset,
4363                 old_sigset_t __user *, oset)
4364 {
4365         old_sigset_t old_set, new_set;
4366         sigset_t new_blocked;
4367
4368         old_set = current->blocked.sig[0];
4369
4370         if (nset) {
4371                 if (copy_from_user(&new_set, nset, sizeof(*nset)))
4372                         return -EFAULT;
4373
4374                 new_blocked = current->blocked;
4375
4376                 switch (how) {
4377                 case SIG_BLOCK:
4378                         sigaddsetmask(&new_blocked, new_set);
4379                         break;
4380                 case SIG_UNBLOCK:
4381                         sigdelsetmask(&new_blocked, new_set);
4382                         break;
4383                 case SIG_SETMASK:
4384                         new_blocked.sig[0] = new_set;
4385                         break;
4386                 default:
4387                         return -EINVAL;
4388                 }
4389
4390                 set_current_blocked(&new_blocked);
4391         }
4392
4393         if (oset) {
4394                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
4395                         return -EFAULT;
4396         }
4397
4398         return 0;
4399 }
4400 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
4401
4402 #ifndef CONFIG_ODD_RT_SIGACTION
4403 /**
4404  *  sys_rt_sigaction - alter an action taken by a process
4405  *  @sig: signal to be sent
4406  *  @act: new sigaction
4407  *  @oact: used to save the previous sigaction
4408  *  @sigsetsize: size of sigset_t type
4409  */
4410 SYSCALL_DEFINE4(rt_sigaction, int, sig,
4411                 const struct sigaction __user *, act,
4412                 struct sigaction __user *, oact,
4413                 size_t, sigsetsize)
4414 {
4415         struct k_sigaction new_sa, old_sa;
4416         int ret;
4417
4418         /* XXX: Don't preclude handling different sized sigset_t's.  */
4419         if (sigsetsize != sizeof(sigset_t))
4420                 return -EINVAL;
4421
4422         if (act && copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
4423                 return -EFAULT;
4424
4425         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
4426         if (ret)
4427                 return ret;
4428
4429         if (oact && copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
4430                 return -EFAULT;
4431
4432         return 0;
4433 }
4434 #ifdef CONFIG_COMPAT
4435 COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig,
4436                 const struct compat_sigaction __user *, act,
4437                 struct compat_sigaction __user *, oact,
4438                 compat_size_t, sigsetsize)
4439 {
4440         struct k_sigaction new_ka, old_ka;
4441 #ifdef __ARCH_HAS_SA_RESTORER
4442         compat_uptr_t restorer;
4443 #endif
4444         int ret;
4445
4446         /* XXX: Don't preclude handling different sized sigset_t's.  */
4447         if (sigsetsize != sizeof(compat_sigset_t))
4448                 return -EINVAL;
4449
4450         if (act) {
4451                 compat_uptr_t handler;
4452                 ret = get_user(handler, &act->sa_handler);
4453                 new_ka.sa.sa_handler = compat_ptr(handler);
4454 #ifdef __ARCH_HAS_SA_RESTORER
4455                 ret |= get_user(restorer, &act->sa_restorer);
4456                 new_ka.sa.sa_restorer = compat_ptr(restorer);
4457 #endif
4458                 ret |= get_compat_sigset(&new_ka.sa.sa_mask, &act->sa_mask);
4459                 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags);
4460                 if (ret)
4461                         return -EFAULT;
4462         }
4463
4464         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4465         if (!ret && oact) {
4466                 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), 
4467                                &oact->sa_handler);
4468                 ret |= put_compat_sigset(&oact->sa_mask, &old_ka.sa.sa_mask,
4469                                          sizeof(oact->sa_mask));
4470                 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags);
4471 #ifdef __ARCH_HAS_SA_RESTORER
4472                 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer),
4473                                 &oact->sa_restorer);
4474 #endif
4475         }
4476         return ret;
4477 }
4478 #endif
4479 #endif /* !CONFIG_ODD_RT_SIGACTION */
4480
4481 #ifdef CONFIG_OLD_SIGACTION
4482 SYSCALL_DEFINE3(sigaction, int, sig,
4483                 const struct old_sigaction __user *, act,
4484                 struct old_sigaction __user *, oact)
4485 {
4486         struct k_sigaction new_ka, old_ka;
4487         int ret;
4488
4489         if (act) {
4490                 old_sigset_t mask;
4491                 if (!access_ok(act, sizeof(*act)) ||
4492                     __get_user(new_ka.sa.sa_handler, &act->sa_handler) ||
4493                     __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) ||
4494                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
4495                     __get_user(mask, &act->sa_mask))
4496                         return -EFAULT;
4497 #ifdef __ARCH_HAS_KA_RESTORER
4498                 new_ka.ka_restorer = NULL;
4499 #endif
4500                 siginitset(&new_ka.sa.sa_mask, mask);
4501         }
4502
4503         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4504
4505         if (!ret && oact) {
4506                 if (!access_ok(oact, sizeof(*oact)) ||
4507                     __put_user(old_ka.sa.sa_handler, &oact->sa_handler) ||
4508                     __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) ||
4509                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
4510                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
4511                         return -EFAULT;
4512         }
4513
4514         return ret;
4515 }
4516 #endif
4517 #ifdef CONFIG_COMPAT_OLD_SIGACTION
4518 COMPAT_SYSCALL_DEFINE3(sigaction, int, sig,
4519                 const struct compat_old_sigaction __user *, act,
4520                 struct compat_old_sigaction __user *, oact)
4521 {
4522         struct k_sigaction new_ka, old_ka;
4523         int ret;
4524         compat_old_sigset_t mask;
4525         compat_uptr_t handler, restorer;
4526
4527         if (act) {
4528                 if (!access_ok(act, sizeof(*act)) ||
4529                     __get_user(handler, &act->sa_handler) ||
4530                     __get_user(restorer, &act->sa_restorer) ||
4531                     __get_user(new_ka.sa.sa_flags, &act->sa_flags) ||
4532                     __get_user(mask, &act->sa_mask))
4533                         return -EFAULT;
4534
4535 #ifdef __ARCH_HAS_KA_RESTORER
4536                 new_ka.ka_restorer = NULL;
4537 #endif
4538                 new_ka.sa.sa_handler = compat_ptr(handler);
4539                 new_ka.sa.sa_restorer = compat_ptr(restorer);
4540                 siginitset(&new_ka.sa.sa_mask, mask);
4541         }
4542
4543         ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL);
4544
4545         if (!ret && oact) {
4546                 if (!access_ok(oact, sizeof(*oact)) ||
4547                     __put_user(ptr_to_compat(old_ka.sa.sa_handler),
4548                                &oact->sa_handler) ||
4549                     __put_user(ptr_to_compat(old_ka.sa.sa_restorer),
4550                                &oact->sa_restorer) ||
4551                     __put_user(old_ka.sa.sa_flags, &oact->sa_flags) ||
4552                     __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask))
4553                         return -EFAULT;
4554         }
4555         return ret;
4556 }
4557 #endif
4558
4559 #ifdef CONFIG_SGETMASK_SYSCALL
4560
4561 /*
4562  * For backwards compatibility.  Functionality superseded by sigprocmask.
4563  */
4564 SYSCALL_DEFINE0(sgetmask)
4565 {
4566         /* SMP safe */
4567         return current->blocked.sig[0];
4568 }
4569
4570 SYSCALL_DEFINE1(ssetmask, int, newmask)
4571 {
4572         int old = current->blocked.sig[0];
4573         sigset_t newset;
4574
4575         siginitset(&newset, newmask);
4576         set_current_blocked(&newset);
4577
4578         return old;
4579 }
4580 #endif /* CONFIG_SGETMASK_SYSCALL */
4581
4582 #ifdef __ARCH_WANT_SYS_SIGNAL
4583 /*
4584  * For backwards compatibility.  Functionality superseded by sigaction.
4585  */
4586 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
4587 {
4588         struct k_sigaction new_sa, old_sa;
4589         int ret;
4590
4591         new_sa.sa.sa_handler = handler;
4592         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
4593         sigemptyset(&new_sa.sa.sa_mask);
4594
4595         ret = do_sigaction(sig, &new_sa, &old_sa);
4596
4597         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
4598 }
4599 #endif /* __ARCH_WANT_SYS_SIGNAL */
4600
4601 #ifdef __ARCH_WANT_SYS_PAUSE
4602
4603 SYSCALL_DEFINE0(pause)
4604 {
4605         while (!signal_pending(current)) {
4606                 __set_current_state(TASK_INTERRUPTIBLE);
4607                 schedule();
4608         }
4609         return -ERESTARTNOHAND;
4610 }
4611
4612 #endif
4613
4614 static int sigsuspend(sigset_t *set)
4615 {
4616         current->saved_sigmask = current->blocked;
4617         set_current_blocked(set);
4618
4619         while (!signal_pending(current)) {
4620                 __set_current_state(TASK_INTERRUPTIBLE);
4621                 schedule();
4622         }
4623         set_restore_sigmask();
4624         return -ERESTARTNOHAND;
4625 }
4626
4627 /**
4628  *  sys_rt_sigsuspend - replace the signal mask for a value with the
4629  *      @unewset value until a signal is received
4630  *  @unewset: new signal mask value
4631  *  @sigsetsize: size of sigset_t type
4632  */
4633 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
4634 {
4635         sigset_t newset;
4636
4637         /* XXX: Don't preclude handling different sized sigset_t's.  */
4638         if (sigsetsize != sizeof(sigset_t))
4639                 return -EINVAL;
4640
4641         if (copy_from_user(&newset, unewset, sizeof(newset)))
4642                 return -EFAULT;
4643         return sigsuspend(&newset);
4644 }
4645  
4646 #ifdef CONFIG_COMPAT
4647 COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user *, unewset, compat_size_t, sigsetsize)
4648 {
4649         sigset_t newset;
4650
4651         /* XXX: Don't preclude handling different sized sigset_t's.  */
4652         if (sigsetsize != sizeof(sigset_t))
4653                 return -EINVAL;
4654
4655         if (get_compat_sigset(&newset, unewset))
4656                 return -EFAULT;
4657         return sigsuspend(&newset);
4658 }
4659 #endif
4660
4661 #ifdef CONFIG_OLD_SIGSUSPEND
4662 SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask)
4663 {
4664         sigset_t blocked;
4665         siginitset(&blocked, mask);
4666         return sigsuspend(&blocked);
4667 }
4668 #endif
4669 #ifdef CONFIG_OLD_SIGSUSPEND3
4670 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask)
4671 {
4672         sigset_t blocked;
4673         siginitset(&blocked, mask);
4674         return sigsuspend(&blocked);
4675 }
4676 #endif
4677
4678 __weak const char *arch_vma_name(struct vm_area_struct *vma)
4679 {
4680         return NULL;
4681 }
4682
4683 static inline void siginfo_buildtime_checks(void)
4684 {
4685         BUILD_BUG_ON(sizeof(struct siginfo) != SI_MAX_SIZE);
4686
4687         /* Verify the offsets in the two siginfos match */
4688 #define CHECK_OFFSET(field) \
4689         BUILD_BUG_ON(offsetof(siginfo_t, field) != offsetof(kernel_siginfo_t, field))
4690
4691         /* kill */
4692         CHECK_OFFSET(si_pid);
4693         CHECK_OFFSET(si_uid);
4694
4695         /* timer */
4696         CHECK_OFFSET(si_tid);
4697         CHECK_OFFSET(si_overrun);
4698         CHECK_OFFSET(si_value);
4699
4700         /* rt */
4701         CHECK_OFFSET(si_pid);
4702         CHECK_OFFSET(si_uid);
4703         CHECK_OFFSET(si_value);
4704
4705         /* sigchld */
4706         CHECK_OFFSET(si_pid);
4707         CHECK_OFFSET(si_uid);
4708         CHECK_OFFSET(si_status);
4709         CHECK_OFFSET(si_utime);
4710         CHECK_OFFSET(si_stime);
4711
4712         /* sigfault */
4713         CHECK_OFFSET(si_addr);
4714         CHECK_OFFSET(si_trapno);
4715         CHECK_OFFSET(si_addr_lsb);
4716         CHECK_OFFSET(si_lower);
4717         CHECK_OFFSET(si_upper);
4718         CHECK_OFFSET(si_pkey);
4719         CHECK_OFFSET(si_perf_data);
4720         CHECK_OFFSET(si_perf_type);
4721         CHECK_OFFSET(si_perf_flags);
4722
4723         /* sigpoll */
4724         CHECK_OFFSET(si_band);
4725         CHECK_OFFSET(si_fd);
4726
4727         /* sigsys */
4728         CHECK_OFFSET(si_call_addr);
4729         CHECK_OFFSET(si_syscall);
4730         CHECK_OFFSET(si_arch);
4731 #undef CHECK_OFFSET
4732
4733         /* usb asyncio */
4734         BUILD_BUG_ON(offsetof(struct siginfo, si_pid) !=
4735                      offsetof(struct siginfo, si_addr));
4736         if (sizeof(int) == sizeof(void __user *)) {
4737                 BUILD_BUG_ON(sizeof_field(struct siginfo, si_pid) !=
4738                              sizeof(void __user *));
4739         } else {
4740                 BUILD_BUG_ON((sizeof_field(struct siginfo, si_pid) +
4741                               sizeof_field(struct siginfo, si_uid)) !=
4742                              sizeof(void __user *));
4743                 BUILD_BUG_ON(offsetofend(struct siginfo, si_pid) !=
4744                              offsetof(struct siginfo, si_uid));
4745         }
4746 #ifdef CONFIG_COMPAT
4747         BUILD_BUG_ON(offsetof(struct compat_siginfo, si_pid) !=
4748                      offsetof(struct compat_siginfo, si_addr));
4749         BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
4750                      sizeof(compat_uptr_t));
4751         BUILD_BUG_ON(sizeof_field(struct compat_siginfo, si_pid) !=
4752                      sizeof_field(struct siginfo, si_pid));
4753 #endif
4754 }
4755
4756 void __init signals_init(void)
4757 {
4758         siginfo_buildtime_checks();
4759
4760         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC | SLAB_ACCOUNT);
4761 }
4762
4763 #ifdef CONFIG_KGDB_KDB
4764 #include <linux/kdb.h>
4765 /*
4766  * kdb_send_sig - Allows kdb to send signals without exposing
4767  * signal internals.  This function checks if the required locks are
4768  * available before calling the main signal code, to avoid kdb
4769  * deadlocks.
4770  */
4771 void kdb_send_sig(struct task_struct *t, int sig)
4772 {
4773         static struct task_struct *kdb_prev_t;
4774         int new_t, ret;
4775         if (!spin_trylock(&t->sighand->siglock)) {
4776                 kdb_printf("Can't do kill command now.\n"
4777                            "The sigmask lock is held somewhere else in "
4778                            "kernel, try again later\n");
4779                 return;
4780         }
4781         new_t = kdb_prev_t != t;
4782         kdb_prev_t = t;
4783         if (!task_is_running(t) && new_t) {
4784                 spin_unlock(&t->sighand->siglock);
4785                 kdb_printf("Process is not RUNNING, sending a signal from "
4786                            "kdb risks deadlock\n"
4787                            "on the run queue locks. "
4788                            "The signal has _not_ been sent.\n"
4789                            "Reissue the kill command if you want to risk "
4790                            "the deadlock.\n");
4791                 return;
4792         }
4793         ret = send_signal_locked(sig, SEND_SIG_PRIV, t, PIDTYPE_PID);
4794         spin_unlock(&t->sighand->siglock);
4795         if (ret)
4796                 kdb_printf("Fail to deliver Signal %d to process %d.\n",
4797                            sig, t->pid);
4798         else
4799                 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
4800 }
4801 #endif  /* CONFIG_KGDB_KDB */