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