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