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