perf: Validate cpu early in perf_event_alloc()
[linux-2.6.git] / kernel / signal.c
1 /*
2  *  linux/kernel/signal.c
3  *
4  *  Copyright (C) 1991, 1992  Linus Torvalds
5  *
6  *  1997-11-02  Modified for POSIX.1b signals by Richard Henderson
7  *
8  *  2003-06-02  Jim Houston - Concurrent Computer Corp.
9  *              Changes to use preallocated sigqueue structures
10  *              to allow signals to be sent reliably.
11  */
12
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/sched.h>
17 #include <linux/fs.h>
18 #include <linux/tty.h>
19 #include <linux/binfmts.h>
20 #include <linux/security.h>
21 #include <linux/syscalls.h>
22 #include <linux/ptrace.h>
23 #include <linux/signal.h>
24 #include <linux/signalfd.h>
25 #include <linux/ratelimit.h>
26 #include <linux/tracehook.h>
27 #include <linux/capability.h>
28 #include <linux/freezer.h>
29 #include <linux/pid_namespace.h>
30 #include <linux/nsproxy.h>
31 #define CREATE_TRACE_POINTS
32 #include <trace/events/signal.h>
33
34 #include <asm/param.h>
35 #include <asm/uaccess.h>
36 #include <asm/unistd.h>
37 #include <asm/siginfo.h>
38 #include "audit.h"      /* audit_signal_info() */
39
40 /*
41  * SLAB caches for signal bits.
42  */
43
44 static struct kmem_cache *sigqueue_cachep;
45
46 int print_fatal_signals __read_mostly;
47
48 static void __user *sig_handler(struct task_struct *t, int sig)
49 {
50         return t->sighand->action[sig - 1].sa.sa_handler;
51 }
52
53 static int sig_handler_ignored(void __user *handler, int sig)
54 {
55         /* Is it explicitly or implicitly ignored? */
56         return handler == SIG_IGN ||
57                 (handler == SIG_DFL && sig_kernel_ignore(sig));
58 }
59
60 static int sig_task_ignored(struct task_struct *t, int sig,
61                 int from_ancestor_ns)
62 {
63         void __user *handler;
64
65         handler = sig_handler(t, sig);
66
67         if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) &&
68                         handler == SIG_DFL && !from_ancestor_ns)
69                 return 1;
70
71         return sig_handler_ignored(handler, sig);
72 }
73
74 static int sig_ignored(struct task_struct *t, int sig, int from_ancestor_ns)
75 {
76         /*
77          * Blocked signals are never ignored, since the
78          * signal handler may change by the time it is
79          * unblocked.
80          */
81         if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
82                 return 0;
83
84         if (!sig_task_ignored(t, sig, from_ancestor_ns))
85                 return 0;
86
87         /*
88          * Tracers may want to know about even ignored signals.
89          */
90         return !tracehook_consider_ignored_signal(t, sig);
91 }
92
93 /*
94  * Re-calculate pending state from the set of locally pending
95  * signals, globally pending signals, and blocked signals.
96  */
97 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
98 {
99         unsigned long ready;
100         long i;
101
102         switch (_NSIG_WORDS) {
103         default:
104                 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
105                         ready |= signal->sig[i] &~ blocked->sig[i];
106                 break;
107
108         case 4: ready  = signal->sig[3] &~ blocked->sig[3];
109                 ready |= signal->sig[2] &~ blocked->sig[2];
110                 ready |= signal->sig[1] &~ blocked->sig[1];
111                 ready |= signal->sig[0] &~ blocked->sig[0];
112                 break;
113
114         case 2: ready  = signal->sig[1] &~ blocked->sig[1];
115                 ready |= signal->sig[0] &~ blocked->sig[0];
116                 break;
117
118         case 1: ready  = signal->sig[0] &~ blocked->sig[0];
119         }
120         return ready != 0;
121 }
122
123 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
124
125 static int recalc_sigpending_tsk(struct task_struct *t)
126 {
127         if (t->signal->group_stop_count > 0 ||
128             PENDING(&t->pending, &t->blocked) ||
129             PENDING(&t->signal->shared_pending, &t->blocked)) {
130                 set_tsk_thread_flag(t, TIF_SIGPENDING);
131                 return 1;
132         }
133         /*
134          * We must never clear the flag in another thread, or in current
135          * when it's possible the current syscall is returning -ERESTART*.
136          * So we don't clear it here, and only callers who know they should do.
137          */
138         return 0;
139 }
140
141 /*
142  * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
143  * This is superfluous when called on current, the wakeup is a harmless no-op.
144  */
145 void recalc_sigpending_and_wake(struct task_struct *t)
146 {
147         if (recalc_sigpending_tsk(t))
148                 signal_wake_up(t, 0);
149 }
150
151 void recalc_sigpending(void)
152 {
153         if (unlikely(tracehook_force_sigpending()))
154                 set_thread_flag(TIF_SIGPENDING);
155         else if (!recalc_sigpending_tsk(current) && !freezing(current))
156                 clear_thread_flag(TIF_SIGPENDING);
157
158 }
159
160 /* Given the mask, find the first available signal that should be serviced. */
161
162 #define SYNCHRONOUS_MASK \
163         (sigmask(SIGSEGV) | sigmask(SIGBUS) | sigmask(SIGILL) | \
164          sigmask(SIGTRAP) | sigmask(SIGFPE))
165
166 int next_signal(struct sigpending *pending, sigset_t *mask)
167 {
168         unsigned long i, *s, *m, x;
169         int sig = 0;
170
171         s = pending->signal.sig;
172         m = mask->sig;
173
174         /*
175          * Handle the first word specially: it contains the
176          * synchronous signals that need to be dequeued first.
177          */
178         x = *s &~ *m;
179         if (x) {
180                 if (x & SYNCHRONOUS_MASK)
181                         x &= SYNCHRONOUS_MASK;
182                 sig = ffz(~x) + 1;
183                 return sig;
184         }
185
186         switch (_NSIG_WORDS) {
187         default:
188                 for (i = 1; i < _NSIG_WORDS; ++i) {
189                         x = *++s &~ *++m;
190                         if (!x)
191                                 continue;
192                         sig = ffz(~x) + i*_NSIG_BPW + 1;
193                         break;
194                 }
195                 break;
196
197         case 2:
198                 x = s[1] &~ m[1];
199                 if (!x)
200                         break;
201                 sig = ffz(~x) + _NSIG_BPW + 1;
202                 break;
203
204         case 1:
205                 /* Nothing to do */
206                 break;
207         }
208
209         return sig;
210 }
211
212 static inline void print_dropped_signal(int sig)
213 {
214         static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 * HZ, 10);
215
216         if (!print_fatal_signals)
217                 return;
218
219         if (!__ratelimit(&ratelimit_state))
220                 return;
221
222         printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n",
223                                 current->comm, current->pid, sig);
224 }
225
226 /*
227  * allocate a new signal queue record
228  * - this may be called without locks if and only if t == current, otherwise an
229  *   appopriate lock must be held to stop the target task from exiting
230  */
231 static struct sigqueue *
232 __sigqueue_alloc(int sig, struct task_struct *t, gfp_t flags, int override_rlimit)
233 {
234         struct sigqueue *q = NULL;
235         struct user_struct *user;
236
237         /*
238          * Protect access to @t credentials. This can go away when all
239          * callers hold rcu read lock.
240          */
241         rcu_read_lock();
242         user = get_uid(__task_cred(t)->user);
243         atomic_inc(&user->sigpending);
244         rcu_read_unlock();
245
246         if (override_rlimit ||
247             atomic_read(&user->sigpending) <=
248                         task_rlimit(t, RLIMIT_SIGPENDING)) {
249                 q = kmem_cache_alloc(sigqueue_cachep, flags);
250         } else {
251                 print_dropped_signal(sig);
252         }
253
254         if (unlikely(q == NULL)) {
255                 atomic_dec(&user->sigpending);
256                 free_uid(user);
257         } else {
258                 INIT_LIST_HEAD(&q->list);
259                 q->flags = 0;
260                 q->user = user;
261         }
262
263         return q;
264 }
265
266 static void __sigqueue_free(struct sigqueue *q)
267 {
268         if (q->flags & SIGQUEUE_PREALLOC)
269                 return;
270         atomic_dec(&q->user->sigpending);
271         free_uid(q->user);
272         kmem_cache_free(sigqueue_cachep, q);
273 }
274
275 void flush_sigqueue(struct sigpending *queue)
276 {
277         struct sigqueue *q;
278
279         sigemptyset(&queue->signal);
280         while (!list_empty(&queue->list)) {
281                 q = list_entry(queue->list.next, struct sigqueue , list);
282                 list_del_init(&q->list);
283                 __sigqueue_free(q);
284         }
285 }
286
287 /*
288  * Flush all pending signals for a task.
289  */
290 void __flush_signals(struct task_struct *t)
291 {
292         clear_tsk_thread_flag(t, TIF_SIGPENDING);
293         flush_sigqueue(&t->pending);
294         flush_sigqueue(&t->signal->shared_pending);
295 }
296
297 void flush_signals(struct task_struct *t)
298 {
299         unsigned long flags;
300
301         spin_lock_irqsave(&t->sighand->siglock, flags);
302         __flush_signals(t);
303         spin_unlock_irqrestore(&t->sighand->siglock, flags);
304 }
305
306 static void __flush_itimer_signals(struct sigpending *pending)
307 {
308         sigset_t signal, retain;
309         struct sigqueue *q, *n;
310
311         signal = pending->signal;
312         sigemptyset(&retain);
313
314         list_for_each_entry_safe(q, n, &pending->list, list) {
315                 int sig = q->info.si_signo;
316
317                 if (likely(q->info.si_code != SI_TIMER)) {
318                         sigaddset(&retain, sig);
319                 } else {
320                         sigdelset(&signal, sig);
321                         list_del_init(&q->list);
322                         __sigqueue_free(q);
323                 }
324         }
325
326         sigorsets(&pending->signal, &signal, &retain);
327 }
328
329 void flush_itimer_signals(void)
330 {
331         struct task_struct *tsk = current;
332         unsigned long flags;
333
334         spin_lock_irqsave(&tsk->sighand->siglock, flags);
335         __flush_itimer_signals(&tsk->pending);
336         __flush_itimer_signals(&tsk->signal->shared_pending);
337         spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
338 }
339
340 void ignore_signals(struct task_struct *t)
341 {
342         int i;
343
344         for (i = 0; i < _NSIG; ++i)
345                 t->sighand->action[i].sa.sa_handler = SIG_IGN;
346
347         flush_signals(t);
348 }
349
350 /*
351  * Flush all handlers for a task.
352  */
353
354 void
355 flush_signal_handlers(struct task_struct *t, int force_default)
356 {
357         int i;
358         struct k_sigaction *ka = &t->sighand->action[0];
359         for (i = _NSIG ; i != 0 ; i--) {
360                 if (force_default || ka->sa.sa_handler != SIG_IGN)
361                         ka->sa.sa_handler = SIG_DFL;
362                 ka->sa.sa_flags = 0;
363                 sigemptyset(&ka->sa.sa_mask);
364                 ka++;
365         }
366 }
367
368 int unhandled_signal(struct task_struct *tsk, int sig)
369 {
370         void __user *handler = tsk->sighand->action[sig-1].sa.sa_handler;
371         if (is_global_init(tsk))
372                 return 1;
373         if (handler != SIG_IGN && handler != SIG_DFL)
374                 return 0;
375         return !tracehook_consider_fatal_signal(tsk, sig);
376 }
377
378
379 /* Notify the system that a driver wants to block all signals for this
380  * process, and wants to be notified if any signals at all were to be
381  * sent/acted upon.  If the notifier routine returns non-zero, then the
382  * signal will be acted upon after all.  If the notifier routine returns 0,
383  * then then signal will be blocked.  Only one block per process is
384  * allowed.  priv is a pointer to private data that the notifier routine
385  * can use to determine if the signal should be blocked or not.  */
386
387 void
388 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
389 {
390         unsigned long flags;
391
392         spin_lock_irqsave(&current->sighand->siglock, flags);
393         current->notifier_mask = mask;
394         current->notifier_data = priv;
395         current->notifier = notifier;
396         spin_unlock_irqrestore(&current->sighand->siglock, flags);
397 }
398
399 /* Notify the system that blocking has ended. */
400
401 void
402 unblock_all_signals(void)
403 {
404         unsigned long flags;
405
406         spin_lock_irqsave(&current->sighand->siglock, flags);
407         current->notifier = NULL;
408         current->notifier_data = NULL;
409         recalc_sigpending();
410         spin_unlock_irqrestore(&current->sighand->siglock, flags);
411 }
412
413 static void collect_signal(int sig, struct sigpending *list, siginfo_t *info)
414 {
415         struct sigqueue *q, *first = NULL;
416
417         /*
418          * Collect the siginfo appropriate to this signal.  Check if
419          * there is another siginfo for the same signal.
420         */
421         list_for_each_entry(q, &list->list, list) {
422                 if (q->info.si_signo == sig) {
423                         if (first)
424                                 goto still_pending;
425                         first = q;
426                 }
427         }
428
429         sigdelset(&list->signal, sig);
430
431         if (first) {
432 still_pending:
433                 list_del_init(&first->list);
434                 copy_siginfo(info, &first->info);
435                 __sigqueue_free(first);
436         } else {
437                 /* Ok, it wasn't in the queue.  This must be
438                    a fast-pathed signal or we must have been
439                    out of queue space.  So zero out the info.
440                  */
441                 info->si_signo = sig;
442                 info->si_errno = 0;
443                 info->si_code = SI_USER;
444                 info->si_pid = 0;
445                 info->si_uid = 0;
446         }
447 }
448
449 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
450                         siginfo_t *info)
451 {
452         int sig = next_signal(pending, mask);
453
454         if (sig) {
455                 if (current->notifier) {
456                         if (sigismember(current->notifier_mask, sig)) {
457                                 if (!(current->notifier)(current->notifier_data)) {
458                                         clear_thread_flag(TIF_SIGPENDING);
459                                         return 0;
460                                 }
461                         }
462                 }
463
464                 collect_signal(sig, pending, info);
465         }
466
467         return sig;
468 }
469
470 /*
471  * Dequeue a signal and return the element to the caller, which is 
472  * expected to free it.
473  *
474  * All callers have to hold the siglock.
475  */
476 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
477 {
478         int signr;
479
480         /* We only dequeue private signals from ourselves, we don't let
481          * signalfd steal them
482          */
483         signr = __dequeue_signal(&tsk->pending, mask, info);
484         if (!signr) {
485                 signr = __dequeue_signal(&tsk->signal->shared_pending,
486                                          mask, info);
487                 /*
488                  * itimer signal ?
489                  *
490                  * itimers are process shared and we restart periodic
491                  * itimers in the signal delivery path to prevent DoS
492                  * attacks in the high resolution timer case. This is
493                  * compliant with the old way of self restarting
494                  * itimers, as the SIGALRM is a legacy signal and only
495                  * queued once. Changing the restart behaviour to
496                  * restart the timer in the signal dequeue path is
497                  * reducing the timer noise on heavy loaded !highres
498                  * systems too.
499                  */
500                 if (unlikely(signr == SIGALRM)) {
501                         struct hrtimer *tmr = &tsk->signal->real_timer;
502
503                         if (!hrtimer_is_queued(tmr) &&
504                             tsk->signal->it_real_incr.tv64 != 0) {
505                                 hrtimer_forward(tmr, tmr->base->get_time(),
506                                                 tsk->signal->it_real_incr);
507                                 hrtimer_restart(tmr);
508                         }
509                 }
510         }
511
512         recalc_sigpending();
513         if (!signr)
514                 return 0;
515
516         if (unlikely(sig_kernel_stop(signr))) {
517                 /*
518                  * Set a marker that we have dequeued a stop signal.  Our
519                  * caller might release the siglock and then the pending
520                  * stop signal it is about to process is no longer in the
521                  * pending bitmasks, but must still be cleared by a SIGCONT
522                  * (and overruled by a SIGKILL).  So those cases clear this
523                  * shared flag after we've set it.  Note that this flag may
524                  * remain set after the signal we return is ignored or
525                  * handled.  That doesn't matter because its only purpose
526                  * is to alert stop-signal processing code when another
527                  * processor has come along and cleared the flag.
528                  */
529                 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
530         }
531         if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) {
532                 /*
533                  * Release the siglock to ensure proper locking order
534                  * of timer locks outside of siglocks.  Note, we leave
535                  * irqs disabled here, since the posix-timers code is
536                  * about to disable them again anyway.
537                  */
538                 spin_unlock(&tsk->sighand->siglock);
539                 do_schedule_next_timer(info);
540                 spin_lock(&tsk->sighand->siglock);
541         }
542         return signr;
543 }
544
545 /*
546  * Tell a process that it has a new active signal..
547  *
548  * NOTE! we rely on the previous spin_lock to
549  * lock interrupts for us! We can only be called with
550  * "siglock" held, and the local interrupt must
551  * have been disabled when that got acquired!
552  *
553  * No need to set need_resched since signal event passing
554  * goes through ->blocked
555  */
556 void signal_wake_up(struct task_struct *t, int resume)
557 {
558         unsigned int mask;
559
560         set_tsk_thread_flag(t, TIF_SIGPENDING);
561
562         /*
563          * For SIGKILL, we want to wake it up in the stopped/traced/killable
564          * case. We don't check t->state here because there is a race with it
565          * executing another processor and just now entering stopped state.
566          * By using wake_up_state, we ensure the process will wake up and
567          * handle its death signal.
568          */
569         mask = TASK_INTERRUPTIBLE;
570         if (resume)
571                 mask |= TASK_WAKEKILL;
572         if (!wake_up_state(t, mask))
573                 kick_process(t);
574 }
575
576 /*
577  * Remove signals in mask from the pending set and queue.
578  * Returns 1 if any signals were found.
579  *
580  * All callers must be holding the siglock.
581  *
582  * This version takes a sigset mask and looks at all signals,
583  * not just those in the first mask word.
584  */
585 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
586 {
587         struct sigqueue *q, *n;
588         sigset_t m;
589
590         sigandsets(&m, mask, &s->signal);
591         if (sigisemptyset(&m))
592                 return 0;
593
594         signandsets(&s->signal, &s->signal, mask);
595         list_for_each_entry_safe(q, n, &s->list, list) {
596                 if (sigismember(mask, q->info.si_signo)) {
597                         list_del_init(&q->list);
598                         __sigqueue_free(q);
599                 }
600         }
601         return 1;
602 }
603 /*
604  * Remove signals in mask from the pending set and queue.
605  * Returns 1 if any signals were found.
606  *
607  * All callers must be holding the siglock.
608  */
609 static int rm_from_queue(unsigned long mask, struct sigpending *s)
610 {
611         struct sigqueue *q, *n;
612
613         if (!sigtestsetmask(&s->signal, mask))
614                 return 0;
615
616         sigdelsetmask(&s->signal, mask);
617         list_for_each_entry_safe(q, n, &s->list, list) {
618                 if (q->info.si_signo < SIGRTMIN &&
619                     (mask & sigmask(q->info.si_signo))) {
620                         list_del_init(&q->list);
621                         __sigqueue_free(q);
622                 }
623         }
624         return 1;
625 }
626
627 static inline int is_si_special(const struct siginfo *info)
628 {
629         return info <= SEND_SIG_FORCED;
630 }
631
632 static inline bool si_fromuser(const struct siginfo *info)
633 {
634         return info == SEND_SIG_NOINFO ||
635                 (!is_si_special(info) && SI_FROMUSER(info));
636 }
637
638 /*
639  * Bad permissions for sending the signal
640  * - the caller must hold the RCU read lock
641  */
642 static int check_kill_permission(int sig, struct siginfo *info,
643                                  struct task_struct *t)
644 {
645         const struct cred *cred, *tcred;
646         struct pid *sid;
647         int error;
648
649         if (!valid_signal(sig))
650                 return -EINVAL;
651
652         if (!si_fromuser(info))
653                 return 0;
654
655         error = audit_signal_info(sig, t); /* Let audit system see the signal */
656         if (error)
657                 return error;
658
659         cred = current_cred();
660         tcred = __task_cred(t);
661         if (!same_thread_group(current, t) &&
662             (cred->euid ^ tcred->suid) &&
663             (cred->euid ^ tcred->uid) &&
664             (cred->uid  ^ tcred->suid) &&
665             (cred->uid  ^ tcred->uid) &&
666             !capable(CAP_KILL)) {
667                 switch (sig) {
668                 case SIGCONT:
669                         sid = task_session(t);
670                         /*
671                          * We don't return the error if sid == NULL. The
672                          * task was unhashed, the caller must notice this.
673                          */
674                         if (!sid || sid == task_session(current))
675                                 break;
676                 default:
677                         return -EPERM;
678                 }
679         }
680
681         return security_task_kill(t, info, sig, 0);
682 }
683
684 /*
685  * Handle magic process-wide effects of stop/continue signals. Unlike
686  * the signal actions, these happen immediately at signal-generation
687  * time regardless of blocking, ignoring, or handling.  This does the
688  * actual continuing for SIGCONT, but not the actual stopping for stop
689  * signals. The process stop is done as a signal action for SIG_DFL.
690  *
691  * Returns true if the signal should be actually delivered, otherwise
692  * it should be dropped.
693  */
694 static int prepare_signal(int sig, struct task_struct *p, int from_ancestor_ns)
695 {
696         struct signal_struct *signal = p->signal;
697         struct task_struct *t;
698
699         if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) {
700                 /*
701                  * The process is in the middle of dying, nothing to do.
702                  */
703         } else if (sig_kernel_stop(sig)) {
704                 /*
705                  * This is a stop signal.  Remove SIGCONT from all queues.
706                  */
707                 rm_from_queue(sigmask(SIGCONT), &signal->shared_pending);
708                 t = p;
709                 do {
710                         rm_from_queue(sigmask(SIGCONT), &t->pending);
711                 } while_each_thread(p, t);
712         } else if (sig == SIGCONT) {
713                 unsigned int why;
714                 /*
715                  * Remove all stop signals from all queues,
716                  * and wake all threads.
717                  */
718                 rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending);
719                 t = p;
720                 do {
721                         unsigned int state;
722                         rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
723                         /*
724                          * If there is a handler for SIGCONT, we must make
725                          * sure that no thread returns to user mode before
726                          * we post the signal, in case it was the only
727                          * thread eligible to run the signal handler--then
728                          * it must not do anything between resuming and
729                          * running the handler.  With the TIF_SIGPENDING
730                          * flag set, the thread will pause and acquire the
731                          * siglock that we hold now and until we've queued
732                          * the pending signal.
733                          *
734                          * Wake up the stopped thread _after_ setting
735                          * TIF_SIGPENDING
736                          */
737                         state = __TASK_STOPPED;
738                         if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
739                                 set_tsk_thread_flag(t, TIF_SIGPENDING);
740                                 state |= TASK_INTERRUPTIBLE;
741                         }
742                         wake_up_state(t, state);
743                 } while_each_thread(p, t);
744
745                 /*
746                  * Notify the parent with CLD_CONTINUED if we were stopped.
747                  *
748                  * If we were in the middle of a group stop, we pretend it
749                  * was already finished, and then continued. Since SIGCHLD
750                  * doesn't queue we report only CLD_STOPPED, as if the next
751                  * CLD_CONTINUED was dropped.
752                  */
753                 why = 0;
754                 if (signal->flags & SIGNAL_STOP_STOPPED)
755                         why |= SIGNAL_CLD_CONTINUED;
756                 else if (signal->group_stop_count)
757                         why |= SIGNAL_CLD_STOPPED;
758
759                 if (why) {
760                         /*
761                          * The first thread which returns from do_signal_stop()
762                          * will take ->siglock, notice SIGNAL_CLD_MASK, and
763                          * notify its parent. See get_signal_to_deliver().
764                          */
765                         signal->flags = why | SIGNAL_STOP_CONTINUED;
766                         signal->group_stop_count = 0;
767                         signal->group_exit_code = 0;
768                 } else {
769                         /*
770                          * We are not stopped, but there could be a stop
771                          * signal in the middle of being processed after
772                          * being removed from the queue.  Clear that too.
773                          */
774                         signal->flags &= ~SIGNAL_STOP_DEQUEUED;
775                 }
776         }
777
778         return !sig_ignored(p, sig, from_ancestor_ns);
779 }
780
781 /*
782  * Test if P wants to take SIG.  After we've checked all threads with this,
783  * it's equivalent to finding no threads not blocking SIG.  Any threads not
784  * blocking SIG were ruled out because they are not running and already
785  * have pending signals.  Such threads will dequeue from the shared queue
786  * as soon as they're available, so putting the signal on the shared queue
787  * will be equivalent to sending it to one such thread.
788  */
789 static inline int wants_signal(int sig, struct task_struct *p)
790 {
791         if (sigismember(&p->blocked, sig))
792                 return 0;
793         if (p->flags & PF_EXITING)
794                 return 0;
795         if (sig == SIGKILL)
796                 return 1;
797         if (task_is_stopped_or_traced(p))
798                 return 0;
799         return task_curr(p) || !signal_pending(p);
800 }
801
802 static void complete_signal(int sig, struct task_struct *p, int group)
803 {
804         struct signal_struct *signal = p->signal;
805         struct task_struct *t;
806
807         /*
808          * Now find a thread we can wake up to take the signal off the queue.
809          *
810          * If the main thread wants the signal, it gets first crack.
811          * Probably the least surprising to the average bear.
812          */
813         if (wants_signal(sig, p))
814                 t = p;
815         else if (!group || thread_group_empty(p))
816                 /*
817                  * There is just one thread and it does not need to be woken.
818                  * It will dequeue unblocked signals before it runs again.
819                  */
820                 return;
821         else {
822                 /*
823                  * Otherwise try to find a suitable thread.
824                  */
825                 t = signal->curr_target;
826                 while (!wants_signal(sig, t)) {
827                         t = next_thread(t);
828                         if (t == signal->curr_target)
829                                 /*
830                                  * No thread needs to be woken.
831                                  * Any eligible threads will see
832                                  * the signal in the queue soon.
833                                  */
834                                 return;
835                 }
836                 signal->curr_target = t;
837         }
838
839         /*
840          * Found a killable thread.  If the signal will be fatal,
841          * then start taking the whole group down immediately.
842          */
843         if (sig_fatal(p, sig) &&
844             !(signal->flags & (SIGNAL_UNKILLABLE | SIGNAL_GROUP_EXIT)) &&
845             !sigismember(&t->real_blocked, sig) &&
846             (sig == SIGKILL ||
847              !tracehook_consider_fatal_signal(t, sig))) {
848                 /*
849                  * This signal will be fatal to the whole group.
850                  */
851                 if (!sig_kernel_coredump(sig)) {
852                         /*
853                          * Start a group exit and wake everybody up.
854                          * This way we don't have other threads
855                          * running and doing things after a slower
856                          * thread has the fatal signal pending.
857                          */
858                         signal->flags = SIGNAL_GROUP_EXIT;
859                         signal->group_exit_code = sig;
860                         signal->group_stop_count = 0;
861                         t = p;
862                         do {
863                                 sigaddset(&t->pending.signal, SIGKILL);
864                                 signal_wake_up(t, 1);
865                         } while_each_thread(p, t);
866                         return;
867                 }
868         }
869
870         /*
871          * The signal is already in the shared-pending queue.
872          * Tell the chosen thread to wake up and dequeue it.
873          */
874         signal_wake_up(t, sig == SIGKILL);
875         return;
876 }
877
878 static inline int legacy_queue(struct sigpending *signals, int sig)
879 {
880         return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
881 }
882
883 static int __send_signal(int sig, struct siginfo *info, struct task_struct *t,
884                         int group, int from_ancestor_ns)
885 {
886         struct sigpending *pending;
887         struct sigqueue *q;
888         int override_rlimit;
889
890         trace_signal_generate(sig, info, t);
891
892         assert_spin_locked(&t->sighand->siglock);
893
894         if (!prepare_signal(sig, t, from_ancestor_ns))
895                 return 0;
896
897         pending = group ? &t->signal->shared_pending : &t->pending;
898         /*
899          * Short-circuit ignored signals and support queuing
900          * exactly one non-rt signal, so that we can get more
901          * detailed information about the cause of the signal.
902          */
903         if (legacy_queue(pending, sig))
904                 return 0;
905         /*
906          * fast-pathed signals for kernel-internal things like SIGSTOP
907          * or SIGKILL.
908          */
909         if (info == SEND_SIG_FORCED)
910                 goto out_set;
911
912         /* Real-time signals must be queued if sent by sigqueue, or
913            some other real-time mechanism.  It is implementation
914            defined whether kill() does so.  We attempt to do so, on
915            the principle of least surprise, but since kill is not
916            allowed to fail with EAGAIN when low on memory we just
917            make sure at least one signal gets delivered and don't
918            pass on the info struct.  */
919
920         if (sig < SIGRTMIN)
921                 override_rlimit = (is_si_special(info) || info->si_code >= 0);
922         else
923                 override_rlimit = 0;
924
925         q = __sigqueue_alloc(sig, t, GFP_ATOMIC | __GFP_NOTRACK_FALSE_POSITIVE,
926                 override_rlimit);
927         if (q) {
928                 list_add_tail(&q->list, &pending->list);
929                 switch ((unsigned long) info) {
930                 case (unsigned long) SEND_SIG_NOINFO:
931                         q->info.si_signo = sig;
932                         q->info.si_errno = 0;
933                         q->info.si_code = SI_USER;
934                         q->info.si_pid = task_tgid_nr_ns(current,
935                                                         task_active_pid_ns(t));
936                         q->info.si_uid = current_uid();
937                         break;
938                 case (unsigned long) SEND_SIG_PRIV:
939                         q->info.si_signo = sig;
940                         q->info.si_errno = 0;
941                         q->info.si_code = SI_KERNEL;
942                         q->info.si_pid = 0;
943                         q->info.si_uid = 0;
944                         break;
945                 default:
946                         copy_siginfo(&q->info, info);
947                         if (from_ancestor_ns)
948                                 q->info.si_pid = 0;
949                         break;
950                 }
951         } else if (!is_si_special(info)) {
952                 if (sig >= SIGRTMIN && info->si_code != SI_USER) {
953                         /*
954                          * Queue overflow, abort.  We may abort if the
955                          * signal was rt and sent by user using something
956                          * other than kill().
957                          */
958                         trace_signal_overflow_fail(sig, group, info);
959                         return -EAGAIN;
960                 } else {
961                         /*
962                          * This is a silent loss of information.  We still
963                          * send the signal, but the *info bits are lost.
964                          */
965                         trace_signal_lose_info(sig, group, info);
966                 }
967         }
968
969 out_set:
970         signalfd_notify(t, sig);
971         sigaddset(&pending->signal, sig);
972         complete_signal(sig, t, group);
973         return 0;
974 }
975
976 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
977                         int group)
978 {
979         int from_ancestor_ns = 0;
980
981 #ifdef CONFIG_PID_NS
982         from_ancestor_ns = si_fromuser(info) &&
983                            !task_pid_nr_ns(current, task_active_pid_ns(t));
984 #endif
985
986         return __send_signal(sig, info, t, group, from_ancestor_ns);
987 }
988
989 static void print_fatal_signal(struct pt_regs *regs, int signr)
990 {
991         printk("%s/%d: potentially unexpected fatal signal %d.\n",
992                 current->comm, task_pid_nr(current), signr);
993
994 #if defined(__i386__) && !defined(__arch_um__)
995         printk("code at %08lx: ", regs->ip);
996         {
997                 int i;
998                 for (i = 0; i < 16; i++) {
999                         unsigned char insn;
1000
1001                         if (get_user(insn, (unsigned char *)(regs->ip + i)))
1002                                 break;
1003                         printk("%02x ", insn);
1004                 }
1005         }
1006 #endif
1007         printk("\n");
1008         preempt_disable();
1009         show_regs(regs);
1010         preempt_enable();
1011 }
1012
1013 static int __init setup_print_fatal_signals(char *str)
1014 {
1015         get_option (&str, &print_fatal_signals);
1016
1017         return 1;
1018 }
1019
1020 __setup("print-fatal-signals=", setup_print_fatal_signals);
1021
1022 int
1023 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1024 {
1025         return send_signal(sig, info, p, 1);
1026 }
1027
1028 static int
1029 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1030 {
1031         return send_signal(sig, info, t, 0);
1032 }
1033
1034 int do_send_sig_info(int sig, struct siginfo *info, struct task_struct *p,
1035                         bool group)
1036 {
1037         unsigned long flags;
1038         int ret = -ESRCH;
1039
1040         if (lock_task_sighand(p, &flags)) {
1041                 ret = send_signal(sig, info, p, group);
1042                 unlock_task_sighand(p, &flags);
1043         }
1044
1045         return ret;
1046 }
1047
1048 /*
1049  * Force a signal that the process can't ignore: if necessary
1050  * we unblock the signal and change any SIG_IGN to SIG_DFL.
1051  *
1052  * Note: If we unblock the signal, we always reset it to SIG_DFL,
1053  * since we do not want to have a signal handler that was blocked
1054  * be invoked when user space had explicitly blocked it.
1055  *
1056  * We don't want to have recursive SIGSEGV's etc, for example,
1057  * that is why we also clear SIGNAL_UNKILLABLE.
1058  */
1059 int
1060 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
1061 {
1062         unsigned long int flags;
1063         int ret, blocked, ignored;
1064         struct k_sigaction *action;
1065
1066         spin_lock_irqsave(&t->sighand->siglock, flags);
1067         action = &t->sighand->action[sig-1];
1068         ignored = action->sa.sa_handler == SIG_IGN;
1069         blocked = sigismember(&t->blocked, sig);
1070         if (blocked || ignored) {
1071                 action->sa.sa_handler = SIG_DFL;
1072                 if (blocked) {
1073                         sigdelset(&t->blocked, sig);
1074                         recalc_sigpending_and_wake(t);
1075                 }
1076         }
1077         if (action->sa.sa_handler == SIG_DFL)
1078                 t->signal->flags &= ~SIGNAL_UNKILLABLE;
1079         ret = specific_send_sig_info(sig, info, t);
1080         spin_unlock_irqrestore(&t->sighand->siglock, flags);
1081
1082         return ret;
1083 }
1084
1085 /*
1086  * Nuke all other threads in the group.
1087  */
1088 int zap_other_threads(struct task_struct *p)
1089 {
1090         struct task_struct *t = p;
1091         int count = 0;
1092
1093         p->signal->group_stop_count = 0;
1094
1095         while_each_thread(p, t) {
1096                 count++;
1097
1098                 /* Don't bother with already dead threads */
1099                 if (t->exit_state)
1100                         continue;
1101                 sigaddset(&t->pending.signal, SIGKILL);
1102                 signal_wake_up(t, 1);
1103         }
1104
1105         return count;
1106 }
1107
1108 struct sighand_struct *__lock_task_sighand(struct task_struct *tsk,
1109                                            unsigned long *flags)
1110 {
1111         struct sighand_struct *sighand;
1112
1113         rcu_read_lock();
1114         for (;;) {
1115                 sighand = rcu_dereference(tsk->sighand);
1116                 if (unlikely(sighand == NULL))
1117                         break;
1118
1119                 spin_lock_irqsave(&sighand->siglock, *flags);
1120                 if (likely(sighand == tsk->sighand))
1121                         break;
1122                 spin_unlock_irqrestore(&sighand->siglock, *flags);
1123         }
1124         rcu_read_unlock();
1125
1126         return sighand;
1127 }
1128
1129 /*
1130  * send signal info to all the members of a group
1131  */
1132 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1133 {
1134         int ret;
1135
1136         rcu_read_lock();
1137         ret = check_kill_permission(sig, info, p);
1138         rcu_read_unlock();
1139
1140         if (!ret && sig)
1141                 ret = do_send_sig_info(sig, info, p, true);
1142
1143         return ret;
1144 }
1145
1146 /*
1147  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1148  * control characters do (^C, ^Z etc)
1149  * - the caller must hold at least a readlock on tasklist_lock
1150  */
1151 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1152 {
1153         struct task_struct *p = NULL;
1154         int retval, success;
1155
1156         success = 0;
1157         retval = -ESRCH;
1158         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1159                 int err = group_send_sig_info(sig, info, p);
1160                 success |= !err;
1161                 retval = err;
1162         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1163         return success ? 0 : retval;
1164 }
1165
1166 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1167 {
1168         int error = -ESRCH;
1169         struct task_struct *p;
1170
1171         rcu_read_lock();
1172 retry:
1173         p = pid_task(pid, PIDTYPE_PID);
1174         if (p) {
1175                 error = group_send_sig_info(sig, info, p);
1176                 if (unlikely(error == -ESRCH))
1177                         /*
1178                          * The task was unhashed in between, try again.
1179                          * If it is dead, pid_task() will return NULL,
1180                          * if we race with de_thread() it will find the
1181                          * new leader.
1182                          */
1183                         goto retry;
1184         }
1185         rcu_read_unlock();
1186
1187         return error;
1188 }
1189
1190 int
1191 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1192 {
1193         int error;
1194         rcu_read_lock();
1195         error = kill_pid_info(sig, info, find_vpid(pid));
1196         rcu_read_unlock();
1197         return error;
1198 }
1199
1200 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1201 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1202                       uid_t uid, uid_t euid, u32 secid)
1203 {
1204         int ret = -EINVAL;
1205         struct task_struct *p;
1206         const struct cred *pcred;
1207         unsigned long flags;
1208
1209         if (!valid_signal(sig))
1210                 return ret;
1211
1212         rcu_read_lock();
1213         p = pid_task(pid, PIDTYPE_PID);
1214         if (!p) {
1215                 ret = -ESRCH;
1216                 goto out_unlock;
1217         }
1218         pcred = __task_cred(p);
1219         if (si_fromuser(info) &&
1220             euid != pcred->suid && euid != pcred->uid &&
1221             uid  != pcred->suid && uid  != pcred->uid) {
1222                 ret = -EPERM;
1223                 goto out_unlock;
1224         }
1225         ret = security_task_kill(p, info, sig, secid);
1226         if (ret)
1227                 goto out_unlock;
1228
1229         if (sig) {
1230                 if (lock_task_sighand(p, &flags)) {
1231                         ret = __send_signal(sig, info, p, 1, 0);
1232                         unlock_task_sighand(p, &flags);
1233                 } else
1234                         ret = -ESRCH;
1235         }
1236 out_unlock:
1237         rcu_read_unlock();
1238         return ret;
1239 }
1240 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1241
1242 /*
1243  * kill_something_info() interprets pid in interesting ways just like kill(2).
1244  *
1245  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1246  * is probably wrong.  Should make it like BSD or SYSV.
1247  */
1248
1249 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1250 {
1251         int ret;
1252
1253         if (pid > 0) {
1254                 rcu_read_lock();
1255                 ret = kill_pid_info(sig, info, find_vpid(pid));
1256                 rcu_read_unlock();
1257                 return ret;
1258         }
1259
1260         read_lock(&tasklist_lock);
1261         if (pid != -1) {
1262                 ret = __kill_pgrp_info(sig, info,
1263                                 pid ? find_vpid(-pid) : task_pgrp(current));
1264         } else {
1265                 int retval = 0, count = 0;
1266                 struct task_struct * p;
1267
1268                 for_each_process(p) {
1269                         if (task_pid_vnr(p) > 1 &&
1270                                         !same_thread_group(p, current)) {
1271                                 int err = group_send_sig_info(sig, info, p);
1272                                 ++count;
1273                                 if (err != -EPERM)
1274                                         retval = err;
1275                         }
1276                 }
1277                 ret = count ? retval : -ESRCH;
1278         }
1279         read_unlock(&tasklist_lock);
1280
1281         return ret;
1282 }
1283
1284 /*
1285  * These are for backward compatibility with the rest of the kernel source.
1286  */
1287
1288 int
1289 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1290 {
1291         /*
1292          * Make sure legacy kernel users don't send in bad values
1293          * (normal paths check this in check_kill_permission).
1294          */
1295         if (!valid_signal(sig))
1296                 return -EINVAL;
1297
1298         return do_send_sig_info(sig, info, p, false);
1299 }
1300
1301 #define __si_special(priv) \
1302         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1303
1304 int
1305 send_sig(int sig, struct task_struct *p, int priv)
1306 {
1307         return send_sig_info(sig, __si_special(priv), p);
1308 }
1309
1310 void
1311 force_sig(int sig, struct task_struct *p)
1312 {
1313         force_sig_info(sig, SEND_SIG_PRIV, p);
1314 }
1315
1316 /*
1317  * When things go south during signal handling, we
1318  * will force a SIGSEGV. And if the signal that caused
1319  * the problem was already a SIGSEGV, we'll want to
1320  * make sure we don't even try to deliver the signal..
1321  */
1322 int
1323 force_sigsegv(int sig, struct task_struct *p)
1324 {
1325         if (sig == SIGSEGV) {
1326                 unsigned long flags;
1327                 spin_lock_irqsave(&p->sighand->siglock, flags);
1328                 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1329                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1330         }
1331         force_sig(SIGSEGV, p);
1332         return 0;
1333 }
1334
1335 int kill_pgrp(struct pid *pid, int sig, int priv)
1336 {
1337         int ret;
1338
1339         read_lock(&tasklist_lock);
1340         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1341         read_unlock(&tasklist_lock);
1342
1343         return ret;
1344 }
1345 EXPORT_SYMBOL(kill_pgrp);
1346
1347 int kill_pid(struct pid *pid, int sig, int priv)
1348 {
1349         return kill_pid_info(sig, __si_special(priv), pid);
1350 }
1351 EXPORT_SYMBOL(kill_pid);
1352
1353 /*
1354  * These functions support sending signals using preallocated sigqueue
1355  * structures.  This is needed "because realtime applications cannot
1356  * afford to lose notifications of asynchronous events, like timer
1357  * expirations or I/O completions".  In the case of Posix Timers
1358  * we allocate the sigqueue structure from the timer_create.  If this
1359  * allocation fails we are able to report the failure to the application
1360  * with an EAGAIN error.
1361  */
1362 struct sigqueue *sigqueue_alloc(void)
1363 {
1364         struct sigqueue *q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0);
1365
1366         if (q)
1367                 q->flags |= SIGQUEUE_PREALLOC;
1368
1369         return q;
1370 }
1371
1372 void sigqueue_free(struct sigqueue *q)
1373 {
1374         unsigned long flags;
1375         spinlock_t *lock = &current->sighand->siglock;
1376
1377         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1378         /*
1379          * We must hold ->siglock while testing q->list
1380          * to serialize with collect_signal() or with
1381          * __exit_signal()->flush_sigqueue().
1382          */
1383         spin_lock_irqsave(lock, flags);
1384         q->flags &= ~SIGQUEUE_PREALLOC;
1385         /*
1386          * If it is queued it will be freed when dequeued,
1387          * like the "regular" sigqueue.
1388          */
1389         if (!list_empty(&q->list))
1390                 q = NULL;
1391         spin_unlock_irqrestore(lock, flags);
1392
1393         if (q)
1394                 __sigqueue_free(q);
1395 }
1396
1397 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1398 {
1399         int sig = q->info.si_signo;
1400         struct sigpending *pending;
1401         unsigned long flags;
1402         int ret;
1403
1404         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1405
1406         ret = -1;
1407         if (!likely(lock_task_sighand(t, &flags)))
1408                 goto ret;
1409
1410         ret = 1; /* the signal is ignored */
1411         if (!prepare_signal(sig, t, 0))
1412                 goto out;
1413
1414         ret = 0;
1415         if (unlikely(!list_empty(&q->list))) {
1416                 /*
1417                  * If an SI_TIMER entry is already queue just increment
1418                  * the overrun count.
1419                  */
1420                 BUG_ON(q->info.si_code != SI_TIMER);
1421                 q->info.si_overrun++;
1422                 goto out;
1423         }
1424         q->info.si_overrun = 0;
1425
1426         signalfd_notify(t, sig);
1427         pending = group ? &t->signal->shared_pending : &t->pending;
1428         list_add_tail(&q->list, &pending->list);
1429         sigaddset(&pending->signal, sig);
1430         complete_signal(sig, t, group);
1431 out:
1432         unlock_task_sighand(t, &flags);
1433 ret:
1434         return ret;
1435 }
1436
1437 /*
1438  * Let a parent know about the death of a child.
1439  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1440  *
1441  * Returns -1 if our parent ignored us and so we've switched to
1442  * self-reaping, or else @sig.
1443  */
1444 int do_notify_parent(struct task_struct *tsk, int sig)
1445 {
1446         struct siginfo info;
1447         unsigned long flags;
1448         struct sighand_struct *psig;
1449         int ret = sig;
1450
1451         BUG_ON(sig == -1);
1452
1453         /* do_notify_parent_cldstop should have been called instead.  */
1454         BUG_ON(task_is_stopped_or_traced(tsk));
1455
1456         BUG_ON(!task_ptrace(tsk) &&
1457                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1458
1459         info.si_signo = sig;
1460         info.si_errno = 0;
1461         /*
1462          * we are under tasklist_lock here so our parent is tied to
1463          * us and cannot exit and release its namespace.
1464          *
1465          * the only it can is to switch its nsproxy with sys_unshare,
1466          * bu uncharing pid namespaces is not allowed, so we'll always
1467          * see relevant namespace
1468          *
1469          * write_lock() currently calls preempt_disable() which is the
1470          * same as rcu_read_lock(), but according to Oleg, this is not
1471          * correct to rely on this
1472          */
1473         rcu_read_lock();
1474         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1475         info.si_uid = __task_cred(tsk)->uid;
1476         rcu_read_unlock();
1477
1478         info.si_utime = cputime_to_clock_t(cputime_add(tsk->utime,
1479                                 tsk->signal->utime));
1480         info.si_stime = cputime_to_clock_t(cputime_add(tsk->stime,
1481                                 tsk->signal->stime));
1482
1483         info.si_status = tsk->exit_code & 0x7f;
1484         if (tsk->exit_code & 0x80)
1485                 info.si_code = CLD_DUMPED;
1486         else if (tsk->exit_code & 0x7f)
1487                 info.si_code = CLD_KILLED;
1488         else {
1489                 info.si_code = CLD_EXITED;
1490                 info.si_status = tsk->exit_code >> 8;
1491         }
1492
1493         psig = tsk->parent->sighand;
1494         spin_lock_irqsave(&psig->siglock, flags);
1495         if (!task_ptrace(tsk) && sig == SIGCHLD &&
1496             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1497              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1498                 /*
1499                  * We are exiting and our parent doesn't care.  POSIX.1
1500                  * defines special semantics for setting SIGCHLD to SIG_IGN
1501                  * or setting the SA_NOCLDWAIT flag: we should be reaped
1502                  * automatically and not left for our parent's wait4 call.
1503                  * Rather than having the parent do it as a magic kind of
1504                  * signal handler, we just set this to tell do_exit that we
1505                  * can be cleaned up without becoming a zombie.  Note that
1506                  * we still call __wake_up_parent in this case, because a
1507                  * blocked sys_wait4 might now return -ECHILD.
1508                  *
1509                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1510                  * is implementation-defined: we do (if you don't want
1511                  * it, just use SIG_IGN instead).
1512                  */
1513                 ret = tsk->exit_signal = -1;
1514                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1515                         sig = -1;
1516         }
1517         if (valid_signal(sig) && sig > 0)
1518                 __group_send_sig_info(sig, &info, tsk->parent);
1519         __wake_up_parent(tsk, tsk->parent);
1520         spin_unlock_irqrestore(&psig->siglock, flags);
1521
1522         return ret;
1523 }
1524
1525 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1526 {
1527         struct siginfo info;
1528         unsigned long flags;
1529         struct task_struct *parent;
1530         struct sighand_struct *sighand;
1531
1532         if (task_ptrace(tsk))
1533                 parent = tsk->parent;
1534         else {
1535                 tsk = tsk->group_leader;
1536                 parent = tsk->real_parent;
1537         }
1538
1539         info.si_signo = SIGCHLD;
1540         info.si_errno = 0;
1541         /*
1542          * see comment in do_notify_parent() abot the following 3 lines
1543          */
1544         rcu_read_lock();
1545         info.si_pid = task_pid_nr_ns(tsk, parent->nsproxy->pid_ns);
1546         info.si_uid = __task_cred(tsk)->uid;
1547         rcu_read_unlock();
1548
1549         info.si_utime = cputime_to_clock_t(tsk->utime);
1550         info.si_stime = cputime_to_clock_t(tsk->stime);
1551
1552         info.si_code = why;
1553         switch (why) {
1554         case CLD_CONTINUED:
1555                 info.si_status = SIGCONT;
1556                 break;
1557         case CLD_STOPPED:
1558                 info.si_status = tsk->signal->group_exit_code & 0x7f;
1559                 break;
1560         case CLD_TRAPPED:
1561                 info.si_status = tsk->exit_code & 0x7f;
1562                 break;
1563         default:
1564                 BUG();
1565         }
1566
1567         sighand = parent->sighand;
1568         spin_lock_irqsave(&sighand->siglock, flags);
1569         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1570             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1571                 __group_send_sig_info(SIGCHLD, &info, parent);
1572         /*
1573          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1574          */
1575         __wake_up_parent(tsk, parent);
1576         spin_unlock_irqrestore(&sighand->siglock, flags);
1577 }
1578
1579 static inline int may_ptrace_stop(void)
1580 {
1581         if (!likely(task_ptrace(current)))
1582                 return 0;
1583         /*
1584          * Are we in the middle of do_coredump?
1585          * If so and our tracer is also part of the coredump stopping
1586          * is a deadlock situation, and pointless because our tracer
1587          * is dead so don't allow us to stop.
1588          * If SIGKILL was already sent before the caller unlocked
1589          * ->siglock we must see ->core_state != NULL. Otherwise it
1590          * is safe to enter schedule().
1591          */
1592         if (unlikely(current->mm->core_state) &&
1593             unlikely(current->mm == current->parent->mm))
1594                 return 0;
1595
1596         return 1;
1597 }
1598
1599 /*
1600  * Return nonzero if there is a SIGKILL that should be waking us up.
1601  * Called with the siglock held.
1602  */
1603 static int sigkill_pending(struct task_struct *tsk)
1604 {
1605         return  sigismember(&tsk->pending.signal, SIGKILL) ||
1606                 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1607 }
1608
1609 /*
1610  * This must be called with current->sighand->siglock held.
1611  *
1612  * This should be the path for all ptrace stops.
1613  * We always set current->last_siginfo while stopped here.
1614  * That makes it a way to test a stopped process for
1615  * being ptrace-stopped vs being job-control-stopped.
1616  *
1617  * If we actually decide not to stop at all because the tracer
1618  * is gone, we keep current->exit_code unless clear_code.
1619  */
1620 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1621         __releases(&current->sighand->siglock)
1622         __acquires(&current->sighand->siglock)
1623 {
1624         if (arch_ptrace_stop_needed(exit_code, info)) {
1625                 /*
1626                  * The arch code has something special to do before a
1627                  * ptrace stop.  This is allowed to block, e.g. for faults
1628                  * on user stack pages.  We can't keep the siglock while
1629                  * calling arch_ptrace_stop, so we must release it now.
1630                  * To preserve proper semantics, we must do this before
1631                  * any signal bookkeeping like checking group_stop_count.
1632                  * Meanwhile, a SIGKILL could come in before we retake the
1633                  * siglock.  That must prevent us from sleeping in TASK_TRACED.
1634                  * So after regaining the lock, we must check for SIGKILL.
1635                  */
1636                 spin_unlock_irq(&current->sighand->siglock);
1637                 arch_ptrace_stop(exit_code, info);
1638                 spin_lock_irq(&current->sighand->siglock);
1639                 if (sigkill_pending(current))
1640                         return;
1641         }
1642
1643         /*
1644          * If there is a group stop in progress,
1645          * we must participate in the bookkeeping.
1646          */
1647         if (current->signal->group_stop_count > 0)
1648                 --current->signal->group_stop_count;
1649
1650         current->last_siginfo = info;
1651         current->exit_code = exit_code;
1652
1653         /* Let the debugger run.  */
1654         __set_current_state(TASK_TRACED);
1655         spin_unlock_irq(&current->sighand->siglock);
1656         read_lock(&tasklist_lock);
1657         if (may_ptrace_stop()) {
1658                 do_notify_parent_cldstop(current, CLD_TRAPPED);
1659                 /*
1660                  * Don't want to allow preemption here, because
1661                  * sys_ptrace() needs this task to be inactive.
1662                  *
1663                  * XXX: implement read_unlock_no_resched().
1664                  */
1665                 preempt_disable();
1666                 read_unlock(&tasklist_lock);
1667                 preempt_enable_no_resched();
1668                 schedule();
1669         } else {
1670                 /*
1671                  * By the time we got the lock, our tracer went away.
1672                  * Don't drop the lock yet, another tracer may come.
1673                  */
1674                 __set_current_state(TASK_RUNNING);
1675                 if (clear_code)
1676                         current->exit_code = 0;
1677                 read_unlock(&tasklist_lock);
1678         }
1679
1680         /*
1681          * While in TASK_TRACED, we were considered "frozen enough".
1682          * Now that we woke up, it's crucial if we're supposed to be
1683          * frozen that we freeze now before running anything substantial.
1684          */
1685         try_to_freeze();
1686
1687         /*
1688          * We are back.  Now reacquire the siglock before touching
1689          * last_siginfo, so that we are sure to have synchronized with
1690          * any signal-sending on another CPU that wants to examine it.
1691          */
1692         spin_lock_irq(&current->sighand->siglock);
1693         current->last_siginfo = NULL;
1694
1695         /*
1696          * Queued signals ignored us while we were stopped for tracing.
1697          * So check for any that we should take before resuming user mode.
1698          * This sets TIF_SIGPENDING, but never clears it.
1699          */
1700         recalc_sigpending_tsk(current);
1701 }
1702
1703 void ptrace_notify(int exit_code)
1704 {
1705         siginfo_t info;
1706
1707         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1708
1709         memset(&info, 0, sizeof info);
1710         info.si_signo = SIGTRAP;
1711         info.si_code = exit_code;
1712         info.si_pid = task_pid_vnr(current);
1713         info.si_uid = current_uid();
1714
1715         /* Let the debugger run.  */
1716         spin_lock_irq(&current->sighand->siglock);
1717         ptrace_stop(exit_code, 1, &info);
1718         spin_unlock_irq(&current->sighand->siglock);
1719 }
1720
1721 /*
1722  * This performs the stopping for SIGSTOP and other stop signals.
1723  * We have to stop all threads in the thread group.
1724  * Returns nonzero if we've actually stopped and released the siglock.
1725  * Returns zero if we didn't stop and still hold the siglock.
1726  */
1727 static int do_signal_stop(int signr)
1728 {
1729         struct signal_struct *sig = current->signal;
1730         int notify;
1731
1732         if (!sig->group_stop_count) {
1733                 struct task_struct *t;
1734
1735                 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1736                     unlikely(signal_group_exit(sig)))
1737                         return 0;
1738                 /*
1739                  * There is no group stop already in progress.
1740                  * We must initiate one now.
1741                  */
1742                 sig->group_exit_code = signr;
1743
1744                 sig->group_stop_count = 1;
1745                 for (t = next_thread(current); t != current; t = next_thread(t))
1746                         /*
1747                          * Setting state to TASK_STOPPED for a group
1748                          * stop is always done with the siglock held,
1749                          * so this check has no races.
1750                          */
1751                         if (!(t->flags & PF_EXITING) &&
1752                             !task_is_stopped_or_traced(t)) {
1753                                 sig->group_stop_count++;
1754                                 signal_wake_up(t, 0);
1755                         }
1756         }
1757         /*
1758          * If there are no other threads in the group, or if there is
1759          * a group stop in progress and we are the last to stop, report
1760          * to the parent.  When ptraced, every thread reports itself.
1761          */
1762         notify = sig->group_stop_count == 1 ? CLD_STOPPED : 0;
1763         notify = tracehook_notify_jctl(notify, CLD_STOPPED);
1764         /*
1765          * tracehook_notify_jctl() can drop and reacquire siglock, so
1766          * we keep ->group_stop_count != 0 before the call. If SIGCONT
1767          * or SIGKILL comes in between ->group_stop_count == 0.
1768          */
1769         if (sig->group_stop_count) {
1770                 if (!--sig->group_stop_count)
1771                         sig->flags = SIGNAL_STOP_STOPPED;
1772                 current->exit_code = sig->group_exit_code;
1773                 __set_current_state(TASK_STOPPED);
1774         }
1775         spin_unlock_irq(&current->sighand->siglock);
1776
1777         if (notify) {
1778                 read_lock(&tasklist_lock);
1779                 do_notify_parent_cldstop(current, notify);
1780                 read_unlock(&tasklist_lock);
1781         }
1782
1783         /* Now we don't run again until woken by SIGCONT or SIGKILL */
1784         do {
1785                 schedule();
1786         } while (try_to_freeze());
1787
1788         tracehook_finish_jctl();
1789         current->exit_code = 0;
1790
1791         return 1;
1792 }
1793
1794 static int ptrace_signal(int signr, siginfo_t *info,
1795                          struct pt_regs *regs, void *cookie)
1796 {
1797         if (!task_ptrace(current))
1798                 return signr;
1799
1800         ptrace_signal_deliver(regs, cookie);
1801
1802         /* Let the debugger run.  */
1803         ptrace_stop(signr, 0, info);
1804
1805         /* We're back.  Did the debugger cancel the sig?  */
1806         signr = current->exit_code;
1807         if (signr == 0)
1808                 return signr;
1809
1810         current->exit_code = 0;
1811
1812         /* Update the siginfo structure if the signal has
1813            changed.  If the debugger wanted something
1814            specific in the siginfo structure then it should
1815            have updated *info via PTRACE_SETSIGINFO.  */
1816         if (signr != info->si_signo) {
1817                 info->si_signo = signr;
1818                 info->si_errno = 0;
1819                 info->si_code = SI_USER;
1820                 info->si_pid = task_pid_vnr(current->parent);
1821                 info->si_uid = task_uid(current->parent);
1822         }
1823
1824         /* If the (new) signal is now blocked, requeue it.  */
1825         if (sigismember(&current->blocked, signr)) {
1826                 specific_send_sig_info(signr, info, current);
1827                 signr = 0;
1828         }
1829
1830         return signr;
1831 }
1832
1833 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1834                           struct pt_regs *regs, void *cookie)
1835 {
1836         struct sighand_struct *sighand = current->sighand;
1837         struct signal_struct *signal = current->signal;
1838         int signr;
1839
1840 relock:
1841         /*
1842          * We'll jump back here after any time we were stopped in TASK_STOPPED.
1843          * While in TASK_STOPPED, we were considered "frozen enough".
1844          * Now that we woke up, it's crucial if we're supposed to be
1845          * frozen that we freeze now before running anything substantial.
1846          */
1847         try_to_freeze();
1848
1849         spin_lock_irq(&sighand->siglock);
1850         /*
1851          * Every stopped thread goes here after wakeup. Check to see if
1852          * we should notify the parent, prepare_signal(SIGCONT) encodes
1853          * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1854          */
1855         if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1856                 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1857                                 ? CLD_CONTINUED : CLD_STOPPED;
1858                 signal->flags &= ~SIGNAL_CLD_MASK;
1859
1860                 why = tracehook_notify_jctl(why, CLD_CONTINUED);
1861                 spin_unlock_irq(&sighand->siglock);
1862
1863                 if (why) {
1864                         read_lock(&tasklist_lock);
1865                         do_notify_parent_cldstop(current->group_leader, why);
1866                         read_unlock(&tasklist_lock);
1867                 }
1868                 goto relock;
1869         }
1870
1871         for (;;) {
1872                 struct k_sigaction *ka;
1873                 /*
1874                  * Tracing can induce an artifical signal and choose sigaction.
1875                  * The return value in @signr determines the default action,
1876                  * but @info->si_signo is the signal number we will report.
1877                  */
1878                 signr = tracehook_get_signal(current, regs, info, return_ka);
1879                 if (unlikely(signr < 0))
1880                         goto relock;
1881                 if (unlikely(signr != 0))
1882                         ka = return_ka;
1883                 else {
1884                         if (unlikely(signal->group_stop_count > 0) &&
1885                             do_signal_stop(0))
1886                                 goto relock;
1887
1888                         signr = dequeue_signal(current, &current->blocked,
1889                                                info);
1890
1891                         if (!signr)
1892                                 break; /* will return 0 */
1893
1894                         if (signr != SIGKILL) {
1895                                 signr = ptrace_signal(signr, info,
1896                                                       regs, cookie);
1897                                 if (!signr)
1898                                         continue;
1899                         }
1900
1901                         ka = &sighand->action[signr-1];
1902                 }
1903
1904                 /* Trace actually delivered signals. */
1905                 trace_signal_deliver(signr, info, ka);
1906
1907                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
1908                         continue;
1909                 if (ka->sa.sa_handler != SIG_DFL) {
1910                         /* Run the handler.  */
1911                         *return_ka = *ka;
1912
1913                         if (ka->sa.sa_flags & SA_ONESHOT)
1914                                 ka->sa.sa_handler = SIG_DFL;
1915
1916                         break; /* will return non-zero "signr" value */
1917                 }
1918
1919                 /*
1920                  * Now we are doing the default action for this signal.
1921                  */
1922                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1923                         continue;
1924
1925                 /*
1926                  * Global init gets no signals it doesn't want.
1927                  * Container-init gets no signals it doesn't want from same
1928                  * container.
1929                  *
1930                  * Note that if global/container-init sees a sig_kernel_only()
1931                  * signal here, the signal must have been generated internally
1932                  * or must have come from an ancestor namespace. In either
1933                  * case, the signal cannot be dropped.
1934                  */
1935                 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1936                                 !sig_kernel_only(signr))
1937                         continue;
1938
1939                 if (sig_kernel_stop(signr)) {
1940                         /*
1941                          * The default action is to stop all threads in
1942                          * the thread group.  The job control signals
1943                          * do nothing in an orphaned pgrp, but SIGSTOP
1944                          * always works.  Note that siglock needs to be
1945                          * dropped during the call to is_orphaned_pgrp()
1946                          * because of lock ordering with tasklist_lock.
1947                          * This allows an intervening SIGCONT to be posted.
1948                          * We need to check for that and bail out if necessary.
1949                          */
1950                         if (signr != SIGSTOP) {
1951                                 spin_unlock_irq(&sighand->siglock);
1952
1953                                 /* signals can be posted during this window */
1954
1955                                 if (is_current_pgrp_orphaned())
1956                                         goto relock;
1957
1958                                 spin_lock_irq(&sighand->siglock);
1959                         }
1960
1961                         if (likely(do_signal_stop(info->si_signo))) {
1962                                 /* It released the siglock.  */
1963                                 goto relock;
1964                         }
1965
1966                         /*
1967                          * We didn't actually stop, due to a race
1968                          * with SIGCONT or something like that.
1969                          */
1970                         continue;
1971                 }
1972
1973                 spin_unlock_irq(&sighand->siglock);
1974
1975                 /*
1976                  * Anything else is fatal, maybe with a core dump.
1977                  */
1978                 current->flags |= PF_SIGNALED;
1979
1980                 if (sig_kernel_coredump(signr)) {
1981                         if (print_fatal_signals)
1982                                 print_fatal_signal(regs, info->si_signo);
1983                         /*
1984                          * If it was able to dump core, this kills all
1985                          * other threads in the group and synchronizes with
1986                          * their demise.  If we lost the race with another
1987                          * thread getting here, it set group_exit_code
1988                          * first and our do_group_exit call below will use
1989                          * that value and ignore the one we pass it.
1990                          */
1991                         do_coredump(info->si_signo, info->si_signo, regs);
1992                 }
1993
1994                 /*
1995                  * Death signals, no core dump.
1996                  */
1997                 do_group_exit(info->si_signo);
1998                 /* NOTREACHED */
1999         }
2000         spin_unlock_irq(&sighand->siglock);
2001         return signr;
2002 }
2003
2004 void exit_signals(struct task_struct *tsk)
2005 {
2006         int group_stop = 0;
2007         struct task_struct *t;
2008
2009         if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
2010                 tsk->flags |= PF_EXITING;
2011                 return;
2012         }
2013
2014         spin_lock_irq(&tsk->sighand->siglock);
2015         /*
2016          * From now this task is not visible for group-wide signals,
2017          * see wants_signal(), do_signal_stop().
2018          */
2019         tsk->flags |= PF_EXITING;
2020         if (!signal_pending(tsk))
2021                 goto out;
2022
2023         /* It could be that __group_complete_signal() choose us to
2024          * notify about group-wide signal. Another thread should be
2025          * woken now to take the signal since we will not.
2026          */
2027         for (t = tsk; (t = next_thread(t)) != tsk; )
2028                 if (!signal_pending(t) && !(t->flags & PF_EXITING))
2029                         recalc_sigpending_and_wake(t);
2030
2031         if (unlikely(tsk->signal->group_stop_count) &&
2032                         !--tsk->signal->group_stop_count) {
2033                 tsk->signal->flags = SIGNAL_STOP_STOPPED;
2034                 group_stop = tracehook_notify_jctl(CLD_STOPPED, CLD_STOPPED);
2035         }
2036 out:
2037         spin_unlock_irq(&tsk->sighand->siglock);
2038
2039         if (unlikely(group_stop)) {
2040                 read_lock(&tasklist_lock);
2041                 do_notify_parent_cldstop(tsk, group_stop);
2042                 read_unlock(&tasklist_lock);
2043         }
2044 }
2045
2046 EXPORT_SYMBOL(recalc_sigpending);
2047 EXPORT_SYMBOL_GPL(dequeue_signal);
2048 EXPORT_SYMBOL(flush_signals);
2049 EXPORT_SYMBOL(force_sig);
2050 EXPORT_SYMBOL(send_sig);
2051 EXPORT_SYMBOL(send_sig_info);
2052 EXPORT_SYMBOL(sigprocmask);
2053 EXPORT_SYMBOL(block_all_signals);
2054 EXPORT_SYMBOL(unblock_all_signals);
2055
2056
2057 /*
2058  * System call entry points.
2059  */
2060
2061 SYSCALL_DEFINE0(restart_syscall)
2062 {
2063         struct restart_block *restart = &current_thread_info()->restart_block;
2064         return restart->fn(restart);
2065 }
2066
2067 long do_no_restart_syscall(struct restart_block *param)
2068 {
2069         return -EINTR;
2070 }
2071
2072 /*
2073  * We don't need to get the kernel lock - this is all local to this
2074  * particular thread.. (and that's good, because this is _heavily_
2075  * used by various programs)
2076  */
2077
2078 /*
2079  * This is also useful for kernel threads that want to temporarily
2080  * (or permanently) block certain signals.
2081  *
2082  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2083  * interface happily blocks "unblockable" signals like SIGKILL
2084  * and friends.
2085  */
2086 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2087 {
2088         int error;
2089
2090         spin_lock_irq(&current->sighand->siglock);
2091         if (oldset)
2092                 *oldset = current->blocked;
2093
2094         error = 0;
2095         switch (how) {
2096         case SIG_BLOCK:
2097                 sigorsets(&current->blocked, &current->blocked, set);
2098                 break;
2099         case SIG_UNBLOCK:
2100                 signandsets(&current->blocked, &current->blocked, set);
2101                 break;
2102         case SIG_SETMASK:
2103                 current->blocked = *set;
2104                 break;
2105         default:
2106                 error = -EINVAL;
2107         }
2108         recalc_sigpending();
2109         spin_unlock_irq(&current->sighand->siglock);
2110
2111         return error;
2112 }
2113
2114 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
2115                 sigset_t __user *, oset, size_t, sigsetsize)
2116 {
2117         int error = -EINVAL;
2118         sigset_t old_set, new_set;
2119
2120         /* XXX: Don't preclude handling different sized sigset_t's.  */
2121         if (sigsetsize != sizeof(sigset_t))
2122                 goto out;
2123
2124         if (set) {
2125                 error = -EFAULT;
2126                 if (copy_from_user(&new_set, set, sizeof(*set)))
2127                         goto out;
2128                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2129
2130                 error = sigprocmask(how, &new_set, &old_set);
2131                 if (error)
2132                         goto out;
2133                 if (oset)
2134                         goto set_old;
2135         } else if (oset) {
2136                 spin_lock_irq(&current->sighand->siglock);
2137                 old_set = current->blocked;
2138                 spin_unlock_irq(&current->sighand->siglock);
2139
2140         set_old:
2141                 error = -EFAULT;
2142                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2143                         goto out;
2144         }
2145         error = 0;
2146 out:
2147         return error;
2148 }
2149
2150 long do_sigpending(void __user *set, unsigned long sigsetsize)
2151 {
2152         long error = -EINVAL;
2153         sigset_t pending;
2154
2155         if (sigsetsize > sizeof(sigset_t))
2156                 goto out;
2157
2158         spin_lock_irq(&current->sighand->siglock);
2159         sigorsets(&pending, &current->pending.signal,
2160                   &current->signal->shared_pending.signal);
2161         spin_unlock_irq(&current->sighand->siglock);
2162
2163         /* Outside the lock because only this thread touches it.  */
2164         sigandsets(&pending, &current->blocked, &pending);
2165
2166         error = -EFAULT;
2167         if (!copy_to_user(set, &pending, sigsetsize))
2168                 error = 0;
2169
2170 out:
2171         return error;
2172 }       
2173
2174 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
2175 {
2176         return do_sigpending(set, sigsetsize);
2177 }
2178
2179 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2180
2181 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2182 {
2183         int err;
2184
2185         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2186                 return -EFAULT;
2187         if (from->si_code < 0)
2188                 return __copy_to_user(to, from, sizeof(siginfo_t))
2189                         ? -EFAULT : 0;
2190         /*
2191          * If you change siginfo_t structure, please be sure
2192          * this code is fixed accordingly.
2193          * Please remember to update the signalfd_copyinfo() function
2194          * inside fs/signalfd.c too, in case siginfo_t changes.
2195          * It should never copy any pad contained in the structure
2196          * to avoid security leaks, but must copy the generic
2197          * 3 ints plus the relevant union member.
2198          */
2199         err = __put_user(from->si_signo, &to->si_signo);
2200         err |= __put_user(from->si_errno, &to->si_errno);
2201         err |= __put_user((short)from->si_code, &to->si_code);
2202         switch (from->si_code & __SI_MASK) {
2203         case __SI_KILL:
2204                 err |= __put_user(from->si_pid, &to->si_pid);
2205                 err |= __put_user(from->si_uid, &to->si_uid);
2206                 break;
2207         case __SI_TIMER:
2208                  err |= __put_user(from->si_tid, &to->si_tid);
2209                  err |= __put_user(from->si_overrun, &to->si_overrun);
2210                  err |= __put_user(from->si_ptr, &to->si_ptr);
2211                 break;
2212         case __SI_POLL:
2213                 err |= __put_user(from->si_band, &to->si_band);
2214                 err |= __put_user(from->si_fd, &to->si_fd);
2215                 break;
2216         case __SI_FAULT:
2217                 err |= __put_user(from->si_addr, &to->si_addr);
2218 #ifdef __ARCH_SI_TRAPNO
2219                 err |= __put_user(from->si_trapno, &to->si_trapno);
2220 #endif
2221 #ifdef BUS_MCEERR_AO
2222                 /* 
2223                  * Other callers might not initialize the si_lsb field,
2224                  * so check explicitely for the right codes here.
2225                  */
2226                 if (from->si_code == BUS_MCEERR_AR || from->si_code == BUS_MCEERR_AO)
2227                         err |= __put_user(from->si_addr_lsb, &to->si_addr_lsb);
2228 #endif
2229                 break;
2230         case __SI_CHLD:
2231                 err |= __put_user(from->si_pid, &to->si_pid);
2232                 err |= __put_user(from->si_uid, &to->si_uid);
2233                 err |= __put_user(from->si_status, &to->si_status);
2234                 err |= __put_user(from->si_utime, &to->si_utime);
2235                 err |= __put_user(from->si_stime, &to->si_stime);
2236                 break;
2237         case __SI_RT: /* This is not generated by the kernel as of now. */
2238         case __SI_MESGQ: /* But this is */
2239                 err |= __put_user(from->si_pid, &to->si_pid);
2240                 err |= __put_user(from->si_uid, &to->si_uid);
2241                 err |= __put_user(from->si_ptr, &to->si_ptr);
2242                 break;
2243         default: /* this is just in case for now ... */
2244                 err |= __put_user(from->si_pid, &to->si_pid);
2245                 err |= __put_user(from->si_uid, &to->si_uid);
2246                 break;
2247         }
2248         return err;
2249 }
2250
2251 #endif
2252
2253 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2254                 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2255                 size_t, sigsetsize)
2256 {
2257         int ret, sig;
2258         sigset_t these;
2259         struct timespec ts;
2260         siginfo_t info;
2261         long timeout = 0;
2262
2263         /* XXX: Don't preclude handling different sized sigset_t's.  */
2264         if (sigsetsize != sizeof(sigset_t))
2265                 return -EINVAL;
2266
2267         if (copy_from_user(&these, uthese, sizeof(these)))
2268                 return -EFAULT;
2269                 
2270         /*
2271          * Invert the set of allowed signals to get those we
2272          * want to block.
2273          */
2274         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2275         signotset(&these);
2276
2277         if (uts) {
2278                 if (copy_from_user(&ts, uts, sizeof(ts)))
2279                         return -EFAULT;
2280                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2281                     || ts.tv_sec < 0)
2282                         return -EINVAL;
2283         }
2284
2285         spin_lock_irq(&current->sighand->siglock);
2286         sig = dequeue_signal(current, &these, &info);
2287         if (!sig) {
2288                 timeout = MAX_SCHEDULE_TIMEOUT;
2289                 if (uts)
2290                         timeout = (timespec_to_jiffies(&ts)
2291                                    + (ts.tv_sec || ts.tv_nsec));
2292
2293                 if (timeout) {
2294                         /* None ready -- temporarily unblock those we're
2295                          * interested while we are sleeping in so that we'll
2296                          * be awakened when they arrive.  */
2297                         current->real_blocked = current->blocked;
2298                         sigandsets(&current->blocked, &current->blocked, &these);
2299                         recalc_sigpending();
2300                         spin_unlock_irq(&current->sighand->siglock);
2301
2302                         timeout = schedule_timeout_interruptible(timeout);
2303
2304                         spin_lock_irq(&current->sighand->siglock);
2305                         sig = dequeue_signal(current, &these, &info);
2306                         current->blocked = current->real_blocked;
2307                         siginitset(&current->real_blocked, 0);
2308                         recalc_sigpending();
2309                 }
2310         }
2311         spin_unlock_irq(&current->sighand->siglock);
2312
2313         if (sig) {
2314                 ret = sig;
2315                 if (uinfo) {
2316                         if (copy_siginfo_to_user(uinfo, &info))
2317                                 ret = -EFAULT;
2318                 }
2319         } else {
2320                 ret = -EAGAIN;
2321                 if (timeout)
2322                         ret = -EINTR;
2323         }
2324
2325         return ret;
2326 }
2327
2328 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2329 {
2330         struct siginfo info;
2331
2332         info.si_signo = sig;
2333         info.si_errno = 0;
2334         info.si_code = SI_USER;
2335         info.si_pid = task_tgid_vnr(current);
2336         info.si_uid = current_uid();
2337
2338         return kill_something_info(sig, &info, pid);
2339 }
2340
2341 static int
2342 do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo *info)
2343 {
2344         struct task_struct *p;
2345         int error = -ESRCH;
2346
2347         rcu_read_lock();
2348         p = find_task_by_vpid(pid);
2349         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2350                 error = check_kill_permission(sig, info, p);
2351                 /*
2352                  * The null signal is a permissions and process existence
2353                  * probe.  No signal is actually delivered.
2354                  */
2355                 if (!error && sig) {
2356                         error = do_send_sig_info(sig, info, p, false);
2357                         /*
2358                          * If lock_task_sighand() failed we pretend the task
2359                          * dies after receiving the signal. The window is tiny,
2360                          * and the signal is private anyway.
2361                          */
2362                         if (unlikely(error == -ESRCH))
2363                                 error = 0;
2364                 }
2365         }
2366         rcu_read_unlock();
2367
2368         return error;
2369 }
2370
2371 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2372 {
2373         struct siginfo info;
2374
2375         info.si_signo = sig;
2376         info.si_errno = 0;
2377         info.si_code = SI_TKILL;
2378         info.si_pid = task_tgid_vnr(current);
2379         info.si_uid = current_uid();
2380
2381         return do_send_specific(tgid, pid, sig, &info);
2382 }
2383
2384 /**
2385  *  sys_tgkill - send signal to one specific thread
2386  *  @tgid: the thread group ID of the thread
2387  *  @pid: the PID of the thread
2388  *  @sig: signal to be sent
2389  *
2390  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2391  *  exists but it's not belonging to the target process anymore. This
2392  *  method solves the problem of threads exiting and PIDs getting reused.
2393  */
2394 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2395 {
2396         /* This is only valid for single tasks */
2397         if (pid <= 0 || tgid <= 0)
2398                 return -EINVAL;
2399
2400         return do_tkill(tgid, pid, sig);
2401 }
2402
2403 /*
2404  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2405  */
2406 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2407 {
2408         /* This is only valid for single tasks */
2409         if (pid <= 0)
2410                 return -EINVAL;
2411
2412         return do_tkill(0, pid, sig);
2413 }
2414
2415 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2416                 siginfo_t __user *, uinfo)
2417 {
2418         siginfo_t info;
2419
2420         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2421                 return -EFAULT;
2422
2423         /* Not even root can pretend to send signals from the kernel.
2424            Nor can they impersonate a kill(), which adds source info.  */
2425         if (info.si_code >= 0)
2426                 return -EPERM;
2427         info.si_signo = sig;
2428
2429         /* POSIX.1b doesn't mention process groups.  */
2430         return kill_proc_info(sig, &info, pid);
2431 }
2432
2433 long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t *info)
2434 {
2435         /* This is only valid for single tasks */
2436         if (pid <= 0 || tgid <= 0)
2437                 return -EINVAL;
2438
2439         /* Not even root can pretend to send signals from the kernel.
2440            Nor can they impersonate a kill(), which adds source info.  */
2441         if (info->si_code >= 0)
2442                 return -EPERM;
2443         info->si_signo = sig;
2444
2445         return do_send_specific(tgid, pid, sig, info);
2446 }
2447
2448 SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig,
2449                 siginfo_t __user *, uinfo)
2450 {
2451         siginfo_t info;
2452
2453         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2454                 return -EFAULT;
2455
2456         return do_rt_tgsigqueueinfo(tgid, pid, sig, &info);
2457 }
2458
2459 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2460 {
2461         struct task_struct *t = current;
2462         struct k_sigaction *k;
2463         sigset_t mask;
2464
2465         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2466                 return -EINVAL;
2467
2468         k = &t->sighand->action[sig-1];
2469
2470         spin_lock_irq(&current->sighand->siglock);
2471         if (oact)
2472                 *oact = *k;
2473
2474         if (act) {
2475                 sigdelsetmask(&act->sa.sa_mask,
2476                               sigmask(SIGKILL) | sigmask(SIGSTOP));
2477                 *k = *act;
2478                 /*
2479                  * POSIX 3.3.1.3:
2480                  *  "Setting a signal action to SIG_IGN for a signal that is
2481                  *   pending shall cause the pending signal to be discarded,
2482                  *   whether or not it is blocked."
2483                  *
2484                  *  "Setting a signal action to SIG_DFL for a signal that is
2485                  *   pending and whose default action is to ignore the signal
2486                  *   (for example, SIGCHLD), shall cause the pending signal to
2487                  *   be discarded, whether or not it is blocked"
2488                  */
2489                 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2490                         sigemptyset(&mask);
2491                         sigaddset(&mask, sig);
2492                         rm_from_queue_full(&mask, &t->signal->shared_pending);
2493                         do {
2494                                 rm_from_queue_full(&mask, &t->pending);
2495                                 t = next_thread(t);
2496                         } while (t != current);
2497                 }
2498         }
2499
2500         spin_unlock_irq(&current->sighand->siglock);
2501         return 0;
2502 }
2503
2504 int 
2505 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2506 {
2507         stack_t oss;
2508         int error;
2509
2510         oss.ss_sp = (void __user *) current->sas_ss_sp;
2511         oss.ss_size = current->sas_ss_size;
2512         oss.ss_flags = sas_ss_flags(sp);
2513
2514         if (uss) {
2515                 void __user *ss_sp;
2516                 size_t ss_size;
2517                 int ss_flags;
2518
2519                 error = -EFAULT;
2520                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss)))
2521                         goto out;
2522                 error = __get_user(ss_sp, &uss->ss_sp) |
2523                         __get_user(ss_flags, &uss->ss_flags) |
2524                         __get_user(ss_size, &uss->ss_size);
2525                 if (error)
2526                         goto out;
2527
2528                 error = -EPERM;
2529                 if (on_sig_stack(sp))
2530                         goto out;
2531
2532                 error = -EINVAL;
2533                 /*
2534                  *
2535                  * Note - this code used to test ss_flags incorrectly
2536                  *        old code may have been written using ss_flags==0
2537                  *        to mean ss_flags==SS_ONSTACK (as this was the only
2538                  *        way that worked) - this fix preserves that older
2539                  *        mechanism
2540                  */
2541                 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2542                         goto out;
2543
2544                 if (ss_flags == SS_DISABLE) {
2545                         ss_size = 0;
2546                         ss_sp = NULL;
2547                 } else {
2548                         error = -ENOMEM;
2549                         if (ss_size < MINSIGSTKSZ)
2550                                 goto out;
2551                 }
2552
2553                 current->sas_ss_sp = (unsigned long) ss_sp;
2554                 current->sas_ss_size = ss_size;
2555         }
2556
2557         error = 0;
2558         if (uoss) {
2559                 error = -EFAULT;
2560                 if (!access_ok(VERIFY_WRITE, uoss, sizeof(*uoss)))
2561                         goto out;
2562                 error = __put_user(oss.ss_sp, &uoss->ss_sp) |
2563                         __put_user(oss.ss_size, &uoss->ss_size) |
2564                         __put_user(oss.ss_flags, &uoss->ss_flags);
2565         }
2566
2567 out:
2568         return error;
2569 }
2570
2571 #ifdef __ARCH_WANT_SYS_SIGPENDING
2572
2573 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
2574 {
2575         return do_sigpending(set, sizeof(*set));
2576 }
2577
2578 #endif
2579
2580 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2581 /* Some platforms have their own version with special arguments others
2582    support only sys_rt_sigprocmask.  */
2583
2584 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
2585                 old_sigset_t __user *, oset)
2586 {
2587         int error;
2588         old_sigset_t old_set, new_set;
2589
2590         if (set) {
2591                 error = -EFAULT;
2592                 if (copy_from_user(&new_set, set, sizeof(*set)))
2593                         goto out;
2594                 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2595
2596                 spin_lock_irq(&current->sighand->siglock);
2597                 old_set = current->blocked.sig[0];
2598
2599                 error = 0;
2600                 switch (how) {
2601                 default:
2602                         error = -EINVAL;
2603                         break;
2604                 case SIG_BLOCK:
2605                         sigaddsetmask(&current->blocked, new_set);
2606                         break;
2607                 case SIG_UNBLOCK:
2608                         sigdelsetmask(&current->blocked, new_set);
2609                         break;
2610                 case SIG_SETMASK:
2611                         current->blocked.sig[0] = new_set;
2612                         break;
2613                 }
2614
2615                 recalc_sigpending();
2616                 spin_unlock_irq(&current->sighand->siglock);
2617                 if (error)
2618                         goto out;
2619                 if (oset)
2620                         goto set_old;
2621         } else if (oset) {
2622                 old_set = current->blocked.sig[0];
2623         set_old:
2624                 error = -EFAULT;
2625                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2626                         goto out;
2627         }
2628         error = 0;
2629 out:
2630         return error;
2631 }
2632 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2633
2634 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2635 SYSCALL_DEFINE4(rt_sigaction, int, sig,
2636                 const struct sigaction __user *, act,
2637                 struct sigaction __user *, oact,
2638                 size_t, sigsetsize)
2639 {
2640         struct k_sigaction new_sa, old_sa;
2641         int ret = -EINVAL;
2642
2643         /* XXX: Don't preclude handling different sized sigset_t's.  */
2644         if (sigsetsize != sizeof(sigset_t))
2645                 goto out;
2646
2647         if (act) {
2648                 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2649                         return -EFAULT;
2650         }
2651
2652         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2653
2654         if (!ret && oact) {
2655                 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2656                         return -EFAULT;
2657         }
2658 out:
2659         return ret;
2660 }
2661 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2662
2663 #ifdef __ARCH_WANT_SYS_SGETMASK
2664
2665 /*
2666  * For backwards compatibility.  Functionality superseded by sigprocmask.
2667  */
2668 SYSCALL_DEFINE0(sgetmask)
2669 {
2670         /* SMP safe */
2671         return current->blocked.sig[0];
2672 }
2673
2674 SYSCALL_DEFINE1(ssetmask, int, newmask)
2675 {
2676         int old;
2677
2678         spin_lock_irq(&current->sighand->siglock);
2679         old = current->blocked.sig[0];
2680
2681         siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2682                                                   sigmask(SIGSTOP)));
2683         recalc_sigpending();
2684         spin_unlock_irq(&current->sighand->siglock);
2685
2686         return old;
2687 }
2688 #endif /* __ARCH_WANT_SGETMASK */
2689
2690 #ifdef __ARCH_WANT_SYS_SIGNAL
2691 /*
2692  * For backwards compatibility.  Functionality superseded by sigaction.
2693  */
2694 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
2695 {
2696         struct k_sigaction new_sa, old_sa;
2697         int ret;
2698
2699         new_sa.sa.sa_handler = handler;
2700         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2701         sigemptyset(&new_sa.sa.sa_mask);
2702
2703         ret = do_sigaction(sig, &new_sa, &old_sa);
2704
2705         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2706 }
2707 #endif /* __ARCH_WANT_SYS_SIGNAL */
2708
2709 #ifdef __ARCH_WANT_SYS_PAUSE
2710
2711 SYSCALL_DEFINE0(pause)
2712 {
2713         current->state = TASK_INTERRUPTIBLE;
2714         schedule();
2715         return -ERESTARTNOHAND;
2716 }
2717
2718 #endif
2719
2720 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2721 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
2722 {
2723         sigset_t newset;
2724
2725         /* XXX: Don't preclude handling different sized sigset_t's.  */
2726         if (sigsetsize != sizeof(sigset_t))
2727                 return -EINVAL;
2728
2729         if (copy_from_user(&newset, unewset, sizeof(newset)))
2730                 return -EFAULT;
2731         sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2732
2733         spin_lock_irq(&current->sighand->siglock);
2734         current->saved_sigmask = current->blocked;
2735         current->blocked = newset;
2736         recalc_sigpending();
2737         spin_unlock_irq(&current->sighand->siglock);
2738
2739         current->state = TASK_INTERRUPTIBLE;
2740         schedule();
2741         set_restore_sigmask();
2742         return -ERESTARTNOHAND;
2743 }
2744 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2745
2746 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2747 {
2748         return NULL;
2749 }
2750
2751 void __init signals_init(void)
2752 {
2753         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
2754 }
2755
2756 #ifdef CONFIG_KGDB_KDB
2757 #include <linux/kdb.h>
2758 /*
2759  * kdb_send_sig_info - Allows kdb to send signals without exposing
2760  * signal internals.  This function checks if the required locks are
2761  * available before calling the main signal code, to avoid kdb
2762  * deadlocks.
2763  */
2764 void
2765 kdb_send_sig_info(struct task_struct *t, struct siginfo *info)
2766 {
2767         static struct task_struct *kdb_prev_t;
2768         int sig, new_t;
2769         if (!spin_trylock(&t->sighand->siglock)) {
2770                 kdb_printf("Can't do kill command now.\n"
2771                            "The sigmask lock is held somewhere else in "
2772                            "kernel, try again later\n");
2773                 return;
2774         }
2775         spin_unlock(&t->sighand->siglock);
2776         new_t = kdb_prev_t != t;
2777         kdb_prev_t = t;
2778         if (t->state != TASK_RUNNING && new_t) {
2779                 kdb_printf("Process is not RUNNING, sending a signal from "
2780                            "kdb risks deadlock\n"
2781                            "on the run queue locks. "
2782                            "The signal has _not_ been sent.\n"
2783                            "Reissue the kill command if you want to risk "
2784                            "the deadlock.\n");
2785                 return;
2786         }
2787         sig = info->si_signo;
2788         if (send_sig_info(sig, info, t))
2789                 kdb_printf("Fail to deliver Signal %d to process %d.\n",
2790                            sig, t->pid);
2791         else
2792                 kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid);
2793 }
2794 #endif  /* CONFIG_KGDB_KDB */