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