SEND_SIG_NOINFO: masquerade si_pid when crossing pid-ns boundary
[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_nr_ns(current,
862                                                         task_active_pid_ns(t));
863                         q->info.si_uid = current_uid();
864                         break;
865                 case (unsigned long) SEND_SIG_PRIV:
866                         q->info.si_signo = sig;
867                         q->info.si_errno = 0;
868                         q->info.si_code = SI_KERNEL;
869                         q->info.si_pid = 0;
870                         q->info.si_uid = 0;
871                         break;
872                 default:
873                         copy_siginfo(&q->info, info);
874                         break;
875                 }
876         } else if (!is_si_special(info)) {
877                 if (sig >= SIGRTMIN && info->si_code != SI_USER)
878                 /*
879                  * Queue overflow, abort.  We may abort if the signal was rt
880                  * and sent by user using something other than kill().
881                  */
882                         return -EAGAIN;
883         }
884
885 out_set:
886         signalfd_notify(t, sig);
887         sigaddset(&pending->signal, sig);
888         complete_signal(sig, t, group);
889         return 0;
890 }
891
892 int print_fatal_signals;
893
894 static void print_fatal_signal(struct pt_regs *regs, int signr)
895 {
896         printk("%s/%d: potentially unexpected fatal signal %d.\n",
897                 current->comm, task_pid_nr(current), signr);
898
899 #if defined(__i386__) && !defined(__arch_um__)
900         printk("code at %08lx: ", regs->ip);
901         {
902                 int i;
903                 for (i = 0; i < 16; i++) {
904                         unsigned char insn;
905
906                         __get_user(insn, (unsigned char *)(regs->ip + i));
907                         printk("%02x ", insn);
908                 }
909         }
910 #endif
911         printk("\n");
912         show_regs(regs);
913 }
914
915 static int __init setup_print_fatal_signals(char *str)
916 {
917         get_option (&str, &print_fatal_signals);
918
919         return 1;
920 }
921
922 __setup("print-fatal-signals=", setup_print_fatal_signals);
923
924 int
925 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
926 {
927         return send_signal(sig, info, p, 1);
928 }
929
930 static int
931 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
932 {
933         return send_signal(sig, info, t, 0);
934 }
935
936 /*
937  * Force a signal that the process can't ignore: if necessary
938  * we unblock the signal and change any SIG_IGN to SIG_DFL.
939  *
940  * Note: If we unblock the signal, we always reset it to SIG_DFL,
941  * since we do not want to have a signal handler that was blocked
942  * be invoked when user space had explicitly blocked it.
943  *
944  * We don't want to have recursive SIGSEGV's etc, for example,
945  * that is why we also clear SIGNAL_UNKILLABLE.
946  */
947 int
948 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
949 {
950         unsigned long int flags;
951         int ret, blocked, ignored;
952         struct k_sigaction *action;
953
954         spin_lock_irqsave(&t->sighand->siglock, flags);
955         action = &t->sighand->action[sig-1];
956         ignored = action->sa.sa_handler == SIG_IGN;
957         blocked = sigismember(&t->blocked, sig);
958         if (blocked || ignored) {
959                 action->sa.sa_handler = SIG_DFL;
960                 if (blocked) {
961                         sigdelset(&t->blocked, sig);
962                         recalc_sigpending_and_wake(t);
963                 }
964         }
965         if (action->sa.sa_handler == SIG_DFL)
966                 t->signal->flags &= ~SIGNAL_UNKILLABLE;
967         ret = specific_send_sig_info(sig, info, t);
968         spin_unlock_irqrestore(&t->sighand->siglock, flags);
969
970         return ret;
971 }
972
973 void
974 force_sig_specific(int sig, struct task_struct *t)
975 {
976         force_sig_info(sig, SEND_SIG_FORCED, t);
977 }
978
979 /*
980  * Nuke all other threads in the group.
981  */
982 void zap_other_threads(struct task_struct *p)
983 {
984         struct task_struct *t;
985
986         p->signal->group_stop_count = 0;
987
988         for (t = next_thread(p); t != p; t = next_thread(t)) {
989                 /*
990                  * Don't bother with already dead threads
991                  */
992                 if (t->exit_state)
993                         continue;
994
995                 /* SIGKILL will be handled before any pending SIGSTOP */
996                 sigaddset(&t->pending.signal, SIGKILL);
997                 signal_wake_up(t, 1);
998         }
999 }
1000
1001 int __fatal_signal_pending(struct task_struct *tsk)
1002 {
1003         return sigismember(&tsk->pending.signal, SIGKILL);
1004 }
1005 EXPORT_SYMBOL(__fatal_signal_pending);
1006
1007 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
1008 {
1009         struct sighand_struct *sighand;
1010
1011         rcu_read_lock();
1012         for (;;) {
1013                 sighand = rcu_dereference(tsk->sighand);
1014                 if (unlikely(sighand == NULL))
1015                         break;
1016
1017                 spin_lock_irqsave(&sighand->siglock, *flags);
1018                 if (likely(sighand == tsk->sighand))
1019                         break;
1020                 spin_unlock_irqrestore(&sighand->siglock, *flags);
1021         }
1022         rcu_read_unlock();
1023
1024         return sighand;
1025 }
1026
1027 /*
1028  * send signal info to all the members of a group
1029  * - the caller must hold the RCU read lock at least
1030  */
1031 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1032 {
1033         unsigned long flags;
1034         int ret;
1035
1036         ret = check_kill_permission(sig, info, p);
1037
1038         if (!ret && sig) {
1039                 ret = -ESRCH;
1040                 if (lock_task_sighand(p, &flags)) {
1041                         ret = __group_send_sig_info(sig, info, p);
1042                         unlock_task_sighand(p, &flags);
1043                 }
1044         }
1045
1046         return ret;
1047 }
1048
1049 /*
1050  * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1051  * control characters do (^C, ^Z etc)
1052  * - the caller must hold at least a readlock on tasklist_lock
1053  */
1054 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1055 {
1056         struct task_struct *p = NULL;
1057         int retval, success;
1058
1059         success = 0;
1060         retval = -ESRCH;
1061         do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1062                 int err = group_send_sig_info(sig, info, p);
1063                 success |= !err;
1064                 retval = err;
1065         } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1066         return success ? 0 : retval;
1067 }
1068
1069 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1070 {
1071         int error = -ESRCH;
1072         struct task_struct *p;
1073
1074         rcu_read_lock();
1075 retry:
1076         p = pid_task(pid, PIDTYPE_PID);
1077         if (p) {
1078                 error = group_send_sig_info(sig, info, p);
1079                 if (unlikely(error == -ESRCH))
1080                         /*
1081                          * The task was unhashed in between, try again.
1082                          * If it is dead, pid_task() will return NULL,
1083                          * if we race with de_thread() it will find the
1084                          * new leader.
1085                          */
1086                         goto retry;
1087         }
1088         rcu_read_unlock();
1089
1090         return error;
1091 }
1092
1093 int
1094 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1095 {
1096         int error;
1097         rcu_read_lock();
1098         error = kill_pid_info(sig, info, find_vpid(pid));
1099         rcu_read_unlock();
1100         return error;
1101 }
1102
1103 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1104 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1105                       uid_t uid, uid_t euid, u32 secid)
1106 {
1107         int ret = -EINVAL;
1108         struct task_struct *p;
1109         const struct cred *pcred;
1110
1111         if (!valid_signal(sig))
1112                 return ret;
1113
1114         read_lock(&tasklist_lock);
1115         p = pid_task(pid, PIDTYPE_PID);
1116         if (!p) {
1117                 ret = -ESRCH;
1118                 goto out_unlock;
1119         }
1120         pcred = __task_cred(p);
1121         if ((info == SEND_SIG_NOINFO ||
1122              (!is_si_special(info) && SI_FROMUSER(info))) &&
1123             euid != pcred->suid && euid != pcred->uid &&
1124             uid  != pcred->suid && uid  != pcred->uid) {
1125                 ret = -EPERM;
1126                 goto out_unlock;
1127         }
1128         ret = security_task_kill(p, info, sig, secid);
1129         if (ret)
1130                 goto out_unlock;
1131         if (sig && p->sighand) {
1132                 unsigned long flags;
1133                 spin_lock_irqsave(&p->sighand->siglock, flags);
1134                 ret = __group_send_sig_info(sig, info, p);
1135                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1136         }
1137 out_unlock:
1138         read_unlock(&tasklist_lock);
1139         return ret;
1140 }
1141 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1142
1143 /*
1144  * kill_something_info() interprets pid in interesting ways just like kill(2).
1145  *
1146  * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1147  * is probably wrong.  Should make it like BSD or SYSV.
1148  */
1149
1150 static int kill_something_info(int sig, struct siginfo *info, pid_t pid)
1151 {
1152         int ret;
1153
1154         if (pid > 0) {
1155                 rcu_read_lock();
1156                 ret = kill_pid_info(sig, info, find_vpid(pid));
1157                 rcu_read_unlock();
1158                 return ret;
1159         }
1160
1161         read_lock(&tasklist_lock);
1162         if (pid != -1) {
1163                 ret = __kill_pgrp_info(sig, info,
1164                                 pid ? find_vpid(-pid) : task_pgrp(current));
1165         } else {
1166                 int retval = 0, count = 0;
1167                 struct task_struct * p;
1168
1169                 for_each_process(p) {
1170                         if (task_pid_vnr(p) > 1 &&
1171                                         !same_thread_group(p, current)) {
1172                                 int err = group_send_sig_info(sig, info, p);
1173                                 ++count;
1174                                 if (err != -EPERM)
1175                                         retval = err;
1176                         }
1177                 }
1178                 ret = count ? retval : -ESRCH;
1179         }
1180         read_unlock(&tasklist_lock);
1181
1182         return ret;
1183 }
1184
1185 /*
1186  * These are for backward compatibility with the rest of the kernel source.
1187  */
1188
1189 /*
1190  * The caller must ensure the task can't exit.
1191  */
1192 int
1193 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1194 {
1195         int ret;
1196         unsigned long flags;
1197
1198         /*
1199          * Make sure legacy kernel users don't send in bad values
1200          * (normal paths check this in check_kill_permission).
1201          */
1202         if (!valid_signal(sig))
1203                 return -EINVAL;
1204
1205         spin_lock_irqsave(&p->sighand->siglock, flags);
1206         ret = specific_send_sig_info(sig, info, p);
1207         spin_unlock_irqrestore(&p->sighand->siglock, flags);
1208         return ret;
1209 }
1210
1211 #define __si_special(priv) \
1212         ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1213
1214 int
1215 send_sig(int sig, struct task_struct *p, int priv)
1216 {
1217         return send_sig_info(sig, __si_special(priv), p);
1218 }
1219
1220 void
1221 force_sig(int sig, struct task_struct *p)
1222 {
1223         force_sig_info(sig, SEND_SIG_PRIV, p);
1224 }
1225
1226 /*
1227  * When things go south during signal handling, we
1228  * will force a SIGSEGV. And if the signal that caused
1229  * the problem was already a SIGSEGV, we'll want to
1230  * make sure we don't even try to deliver the signal..
1231  */
1232 int
1233 force_sigsegv(int sig, struct task_struct *p)
1234 {
1235         if (sig == SIGSEGV) {
1236                 unsigned long flags;
1237                 spin_lock_irqsave(&p->sighand->siglock, flags);
1238                 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1239                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1240         }
1241         force_sig(SIGSEGV, p);
1242         return 0;
1243 }
1244
1245 int kill_pgrp(struct pid *pid, int sig, int priv)
1246 {
1247         int ret;
1248
1249         read_lock(&tasklist_lock);
1250         ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1251         read_unlock(&tasklist_lock);
1252
1253         return ret;
1254 }
1255 EXPORT_SYMBOL(kill_pgrp);
1256
1257 int kill_pid(struct pid *pid, int sig, int priv)
1258 {
1259         return kill_pid_info(sig, __si_special(priv), pid);
1260 }
1261 EXPORT_SYMBOL(kill_pid);
1262
1263 /*
1264  * These functions support sending signals using preallocated sigqueue
1265  * structures.  This is needed "because realtime applications cannot
1266  * afford to lose notifications of asynchronous events, like timer
1267  * expirations or I/O completions".  In the case of Posix Timers 
1268  * we allocate the sigqueue structure from the timer_create.  If this
1269  * allocation fails we are able to report the failure to the application
1270  * with an EAGAIN error.
1271  */
1272  
1273 struct sigqueue *sigqueue_alloc(void)
1274 {
1275         struct sigqueue *q;
1276
1277         if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1278                 q->flags |= SIGQUEUE_PREALLOC;
1279         return(q);
1280 }
1281
1282 void sigqueue_free(struct sigqueue *q)
1283 {
1284         unsigned long flags;
1285         spinlock_t *lock = &current->sighand->siglock;
1286
1287         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1288         /*
1289          * We must hold ->siglock while testing q->list
1290          * to serialize with collect_signal() or with
1291          * __exit_signal()->flush_sigqueue().
1292          */
1293         spin_lock_irqsave(lock, flags);
1294         q->flags &= ~SIGQUEUE_PREALLOC;
1295         /*
1296          * If it is queued it will be freed when dequeued,
1297          * like the "regular" sigqueue.
1298          */
1299         if (!list_empty(&q->list))
1300                 q = NULL;
1301         spin_unlock_irqrestore(lock, flags);
1302
1303         if (q)
1304                 __sigqueue_free(q);
1305 }
1306
1307 int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
1308 {
1309         int sig = q->info.si_signo;
1310         struct sigpending *pending;
1311         unsigned long flags;
1312         int ret;
1313
1314         BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1315
1316         ret = -1;
1317         if (!likely(lock_task_sighand(t, &flags)))
1318                 goto ret;
1319
1320         ret = 1; /* the signal is ignored */
1321         if (!prepare_signal(sig, t))
1322                 goto out;
1323
1324         ret = 0;
1325         if (unlikely(!list_empty(&q->list))) {
1326                 /*
1327                  * If an SI_TIMER entry is already queue just increment
1328                  * the overrun count.
1329                  */
1330                 BUG_ON(q->info.si_code != SI_TIMER);
1331                 q->info.si_overrun++;
1332                 goto out;
1333         }
1334         q->info.si_overrun = 0;
1335
1336         signalfd_notify(t, sig);
1337         pending = group ? &t->signal->shared_pending : &t->pending;
1338         list_add_tail(&q->list, &pending->list);
1339         sigaddset(&pending->signal, sig);
1340         complete_signal(sig, t, group);
1341 out:
1342         unlock_task_sighand(t, &flags);
1343 ret:
1344         return ret;
1345 }
1346
1347 /*
1348  * Wake up any threads in the parent blocked in wait* syscalls.
1349  */
1350 static inline void __wake_up_parent(struct task_struct *p,
1351                                     struct task_struct *parent)
1352 {
1353         wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1354 }
1355
1356 /*
1357  * Let a parent know about the death of a child.
1358  * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1359  *
1360  * Returns -1 if our parent ignored us and so we've switched to
1361  * self-reaping, or else @sig.
1362  */
1363 int do_notify_parent(struct task_struct *tsk, int sig)
1364 {
1365         struct siginfo info;
1366         unsigned long flags;
1367         struct sighand_struct *psig;
1368         struct task_cputime cputime;
1369         int ret = sig;
1370
1371         BUG_ON(sig == -1);
1372
1373         /* do_notify_parent_cldstop should have been called instead.  */
1374         BUG_ON(task_is_stopped_or_traced(tsk));
1375
1376         BUG_ON(!tsk->ptrace &&
1377                (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1378
1379         info.si_signo = sig;
1380         info.si_errno = 0;
1381         /*
1382          * we are under tasklist_lock here so our parent is tied to
1383          * us and cannot exit and release its namespace.
1384          *
1385          * the only it can is to switch its nsproxy with sys_unshare,
1386          * bu uncharing pid namespaces is not allowed, so we'll always
1387          * see relevant namespace
1388          *
1389          * write_lock() currently calls preempt_disable() which is the
1390          * same as rcu_read_lock(), but according to Oleg, this is not
1391          * correct to rely on this
1392          */
1393         rcu_read_lock();
1394         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1395         info.si_uid = __task_cred(tsk)->uid;
1396         rcu_read_unlock();
1397
1398         thread_group_cputime(tsk, &cputime);
1399         info.si_utime = cputime_to_jiffies(cputime.utime);
1400         info.si_stime = cputime_to_jiffies(cputime.stime);
1401
1402         info.si_status = tsk->exit_code & 0x7f;
1403         if (tsk->exit_code & 0x80)
1404                 info.si_code = CLD_DUMPED;
1405         else if (tsk->exit_code & 0x7f)
1406                 info.si_code = CLD_KILLED;
1407         else {
1408                 info.si_code = CLD_EXITED;
1409                 info.si_status = tsk->exit_code >> 8;
1410         }
1411
1412         psig = tsk->parent->sighand;
1413         spin_lock_irqsave(&psig->siglock, flags);
1414         if (!tsk->ptrace && sig == SIGCHLD &&
1415             (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1416              (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1417                 /*
1418                  * We are exiting and our parent doesn't care.  POSIX.1
1419                  * defines special semantics for setting SIGCHLD to SIG_IGN
1420                  * or setting the SA_NOCLDWAIT flag: we should be reaped
1421                  * automatically and not left for our parent's wait4 call.
1422                  * Rather than having the parent do it as a magic kind of
1423                  * signal handler, we just set this to tell do_exit that we
1424                  * can be cleaned up without becoming a zombie.  Note that
1425                  * we still call __wake_up_parent in this case, because a
1426                  * blocked sys_wait4 might now return -ECHILD.
1427                  *
1428                  * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1429                  * is implementation-defined: we do (if you don't want
1430                  * it, just use SIG_IGN instead).
1431                  */
1432                 ret = tsk->exit_signal = -1;
1433                 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1434                         sig = -1;
1435         }
1436         if (valid_signal(sig) && sig > 0)
1437                 __group_send_sig_info(sig, &info, tsk->parent);
1438         __wake_up_parent(tsk, tsk->parent);
1439         spin_unlock_irqrestore(&psig->siglock, flags);
1440
1441         return ret;
1442 }
1443
1444 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1445 {
1446         struct siginfo info;
1447         unsigned long flags;
1448         struct task_struct *parent;
1449         struct sighand_struct *sighand;
1450
1451         if (tsk->ptrace & PT_PTRACED)
1452                 parent = tsk->parent;
1453         else {
1454                 tsk = tsk->group_leader;
1455                 parent = tsk->real_parent;
1456         }
1457
1458         info.si_signo = SIGCHLD;
1459         info.si_errno = 0;
1460         /*
1461          * see comment in do_notify_parent() abot the following 3 lines
1462          */
1463         rcu_read_lock();
1464         info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1465         info.si_uid = __task_cred(tsk)->uid;
1466         rcu_read_unlock();
1467
1468         info.si_utime = cputime_to_clock_t(tsk->utime);
1469         info.si_stime = cputime_to_clock_t(tsk->stime);
1470
1471         info.si_code = why;
1472         switch (why) {
1473         case CLD_CONTINUED:
1474                 info.si_status = SIGCONT;
1475                 break;
1476         case CLD_STOPPED:
1477                 info.si_status = tsk->signal->group_exit_code & 0x7f;
1478                 break;
1479         case CLD_TRAPPED:
1480                 info.si_status = tsk->exit_code & 0x7f;
1481                 break;
1482         default:
1483                 BUG();
1484         }
1485
1486         sighand = parent->sighand;
1487         spin_lock_irqsave(&sighand->siglock, flags);
1488         if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1489             !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1490                 __group_send_sig_info(SIGCHLD, &info, parent);
1491         /*
1492          * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1493          */
1494         __wake_up_parent(tsk, parent);
1495         spin_unlock_irqrestore(&sighand->siglock, flags);
1496 }
1497
1498 static inline int may_ptrace_stop(void)
1499 {
1500         if (!likely(current->ptrace & PT_PTRACED))
1501                 return 0;
1502         /*
1503          * Are we in the middle of do_coredump?
1504          * If so and our tracer is also part of the coredump stopping
1505          * is a deadlock situation, and pointless because our tracer
1506          * is dead so don't allow us to stop.
1507          * If SIGKILL was already sent before the caller unlocked
1508          * ->siglock we must see ->core_state != NULL. Otherwise it
1509          * is safe to enter schedule().
1510          */
1511         if (unlikely(current->mm->core_state) &&
1512             unlikely(current->mm == current->parent->mm))
1513                 return 0;
1514
1515         return 1;
1516 }
1517
1518 /*
1519  * Return nonzero if there is a SIGKILL that should be waking us up.
1520  * Called with the siglock held.
1521  */
1522 static int sigkill_pending(struct task_struct *tsk)
1523 {
1524         return  sigismember(&tsk->pending.signal, SIGKILL) ||
1525                 sigismember(&tsk->signal->shared_pending.signal, SIGKILL);
1526 }
1527
1528 /*
1529  * This must be called with current->sighand->siglock held.
1530  *
1531  * This should be the path for all ptrace stops.
1532  * We always set current->last_siginfo while stopped here.
1533  * That makes it a way to test a stopped process for
1534  * being ptrace-stopped vs being job-control-stopped.
1535  *
1536  * If we actually decide not to stop at all because the tracer
1537  * is gone, we keep current->exit_code unless clear_code.
1538  */
1539 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1540 {
1541         if (arch_ptrace_stop_needed(exit_code, info)) {
1542                 /*
1543                  * The arch code has something special to do before a
1544                  * ptrace stop.  This is allowed to block, e.g. for faults
1545                  * on user stack pages.  We can't keep the siglock while
1546                  * calling arch_ptrace_stop, so we must release it now.
1547                  * To preserve proper semantics, we must do this before
1548                  * any signal bookkeeping like checking group_stop_count.
1549                  * Meanwhile, a SIGKILL could come in before we retake the
1550                  * siglock.  That must prevent us from sleeping in TASK_TRACED.
1551                  * So after regaining the lock, we must check for SIGKILL.
1552                  */
1553                 spin_unlock_irq(&current->sighand->siglock);
1554                 arch_ptrace_stop(exit_code, info);
1555                 spin_lock_irq(&current->sighand->siglock);
1556                 if (sigkill_pending(current))
1557                         return;
1558         }
1559
1560         /*
1561          * If there is a group stop in progress,
1562          * we must participate in the bookkeeping.
1563          */
1564         if (current->signal->group_stop_count > 0)
1565                 --current->signal->group_stop_count;
1566
1567         current->last_siginfo = info;
1568         current->exit_code = exit_code;
1569
1570         /* Let the debugger run.  */
1571         __set_current_state(TASK_TRACED);
1572         spin_unlock_irq(&current->sighand->siglock);
1573         read_lock(&tasklist_lock);
1574         if (may_ptrace_stop()) {
1575                 do_notify_parent_cldstop(current, CLD_TRAPPED);
1576                 read_unlock(&tasklist_lock);
1577                 schedule();
1578         } else {
1579                 /*
1580                  * By the time we got the lock, our tracer went away.
1581                  * Don't drop the lock yet, another tracer may come.
1582                  */
1583                 __set_current_state(TASK_RUNNING);
1584                 if (clear_code)
1585                         current->exit_code = 0;
1586                 read_unlock(&tasklist_lock);
1587         }
1588
1589         /*
1590          * While in TASK_TRACED, we were considered "frozen enough".
1591          * Now that we woke up, it's crucial if we're supposed to be
1592          * frozen that we freeze now before running anything substantial.
1593          */
1594         try_to_freeze();
1595
1596         /*
1597          * We are back.  Now reacquire the siglock before touching
1598          * last_siginfo, so that we are sure to have synchronized with
1599          * any signal-sending on another CPU that wants to examine it.
1600          */
1601         spin_lock_irq(&current->sighand->siglock);
1602         current->last_siginfo = NULL;
1603
1604         /*
1605          * Queued signals ignored us while we were stopped for tracing.
1606          * So check for any that we should take before resuming user mode.
1607          * This sets TIF_SIGPENDING, but never clears it.
1608          */
1609         recalc_sigpending_tsk(current);
1610 }
1611
1612 void ptrace_notify(int exit_code)
1613 {
1614         siginfo_t info;
1615
1616         BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1617
1618         memset(&info, 0, sizeof info);
1619         info.si_signo = SIGTRAP;
1620         info.si_code = exit_code;
1621         info.si_pid = task_pid_vnr(current);
1622         info.si_uid = current_uid();
1623
1624         /* Let the debugger run.  */
1625         spin_lock_irq(&current->sighand->siglock);
1626         ptrace_stop(exit_code, 1, &info);
1627         spin_unlock_irq(&current->sighand->siglock);
1628 }
1629
1630 static void
1631 finish_stop(int stop_count)
1632 {
1633         /*
1634          * If there are no other threads in the group, or if there is
1635          * a group stop in progress and we are the last to stop,
1636          * report to the parent.  When ptraced, every thread reports itself.
1637          */
1638         if (tracehook_notify_jctl(stop_count == 0, CLD_STOPPED)) {
1639                 read_lock(&tasklist_lock);
1640                 do_notify_parent_cldstop(current, CLD_STOPPED);
1641                 read_unlock(&tasklist_lock);
1642         }
1643
1644         do {
1645                 schedule();
1646         } while (try_to_freeze());
1647         /*
1648          * Now we don't run again until continued.
1649          */
1650         current->exit_code = 0;
1651 }
1652
1653 /*
1654  * This performs the stopping for SIGSTOP and other stop signals.
1655  * We have to stop all threads in the thread group.
1656  * Returns nonzero if we've actually stopped and released the siglock.
1657  * Returns zero if we didn't stop and still hold the siglock.
1658  */
1659 static int do_signal_stop(int signr)
1660 {
1661         struct signal_struct *sig = current->signal;
1662         int stop_count;
1663
1664         if (sig->group_stop_count > 0) {
1665                 /*
1666                  * There is a group stop in progress.  We don't need to
1667                  * start another one.
1668                  */
1669                 stop_count = --sig->group_stop_count;
1670         } else {
1671                 struct task_struct *t;
1672
1673                 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1674                     unlikely(signal_group_exit(sig)))
1675                         return 0;
1676                 /*
1677                  * There is no group stop already in progress.
1678                  * We must initiate one now.
1679                  */
1680                 sig->group_exit_code = signr;
1681
1682                 stop_count = 0;
1683                 for (t = next_thread(current); t != current; t = next_thread(t))
1684                         /*
1685                          * Setting state to TASK_STOPPED for a group
1686                          * stop is always done with the siglock held,
1687                          * so this check has no races.
1688                          */
1689                         if (!(t->flags & PF_EXITING) &&
1690                             !task_is_stopped_or_traced(t)) {
1691                                 stop_count++;
1692                                 signal_wake_up(t, 0);
1693                         }
1694                 sig->group_stop_count = stop_count;
1695         }
1696
1697         if (stop_count == 0)
1698                 sig->flags = SIGNAL_STOP_STOPPED;
1699         current->exit_code = sig->group_exit_code;
1700         __set_current_state(TASK_STOPPED);
1701
1702         spin_unlock_irq(&current->sighand->siglock);
1703         finish_stop(stop_count);
1704         return 1;
1705 }
1706
1707 static int ptrace_signal(int signr, siginfo_t *info,
1708                          struct pt_regs *regs, void *cookie)
1709 {
1710         if (!(current->ptrace & PT_PTRACED))
1711                 return signr;
1712
1713         ptrace_signal_deliver(regs, cookie);
1714
1715         /* Let the debugger run.  */
1716         ptrace_stop(signr, 0, info);
1717
1718         /* We're back.  Did the debugger cancel the sig?  */
1719         signr = current->exit_code;
1720         if (signr == 0)
1721                 return signr;
1722
1723         current->exit_code = 0;
1724
1725         /* Update the siginfo structure if the signal has
1726            changed.  If the debugger wanted something
1727            specific in the siginfo structure then it should
1728            have updated *info via PTRACE_SETSIGINFO.  */
1729         if (signr != info->si_signo) {
1730                 info->si_signo = signr;
1731                 info->si_errno = 0;
1732                 info->si_code = SI_USER;
1733                 info->si_pid = task_pid_vnr(current->parent);
1734                 info->si_uid = task_uid(current->parent);
1735         }
1736
1737         /* If the (new) signal is now blocked, requeue it.  */
1738         if (sigismember(&current->blocked, signr)) {
1739                 specific_send_sig_info(signr, info, current);
1740                 signr = 0;
1741         }
1742
1743         return signr;
1744 }
1745
1746 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1747                           struct pt_regs *regs, void *cookie)
1748 {
1749         struct sighand_struct *sighand = current->sighand;
1750         struct signal_struct *signal = current->signal;
1751         int signr;
1752
1753 relock:
1754         /*
1755          * We'll jump back here after any time we were stopped in TASK_STOPPED.
1756          * While in TASK_STOPPED, we were considered "frozen enough".
1757          * Now that we woke up, it's crucial if we're supposed to be
1758          * frozen that we freeze now before running anything substantial.
1759          */
1760         try_to_freeze();
1761
1762         spin_lock_irq(&sighand->siglock);
1763         /*
1764          * Every stopped thread goes here after wakeup. Check to see if
1765          * we should notify the parent, prepare_signal(SIGCONT) encodes
1766          * the CLD_ si_code into SIGNAL_CLD_MASK bits.
1767          */
1768         if (unlikely(signal->flags & SIGNAL_CLD_MASK)) {
1769                 int why = (signal->flags & SIGNAL_STOP_CONTINUED)
1770                                 ? CLD_CONTINUED : CLD_STOPPED;
1771                 signal->flags &= ~SIGNAL_CLD_MASK;
1772                 spin_unlock_irq(&sighand->siglock);
1773
1774                 if (unlikely(!tracehook_notify_jctl(1, why)))
1775                         goto relock;
1776
1777                 read_lock(&tasklist_lock);
1778                 do_notify_parent_cldstop(current->group_leader, why);
1779                 read_unlock(&tasklist_lock);
1780                 goto relock;
1781         }
1782
1783         for (;;) {
1784                 struct k_sigaction *ka;
1785
1786                 if (unlikely(signal->group_stop_count > 0) &&
1787                     do_signal_stop(0))
1788                         goto relock;
1789
1790                 /*
1791                  * Tracing can induce an artifical signal and choose sigaction.
1792                  * The return value in @signr determines the default action,
1793                  * but @info->si_signo is the signal number we will report.
1794                  */
1795                 signr = tracehook_get_signal(current, regs, info, return_ka);
1796                 if (unlikely(signr < 0))
1797                         goto relock;
1798                 if (unlikely(signr != 0))
1799                         ka = return_ka;
1800                 else {
1801                         signr = dequeue_signal(current, &current->blocked,
1802                                                info);
1803
1804                         if (!signr)
1805                                 break; /* will return 0 */
1806
1807                         if (signr != SIGKILL) {
1808                                 signr = ptrace_signal(signr, info,
1809                                                       regs, cookie);
1810                                 if (!signr)
1811                                         continue;
1812                         }
1813
1814                         ka = &sighand->action[signr-1];
1815                 }
1816
1817                 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing.  */
1818                         continue;
1819                 if (ka->sa.sa_handler != SIG_DFL) {
1820                         /* Run the handler.  */
1821                         *return_ka = *ka;
1822
1823                         if (ka->sa.sa_flags & SA_ONESHOT)
1824                                 ka->sa.sa_handler = SIG_DFL;
1825
1826                         break; /* will return non-zero "signr" value */
1827                 }
1828
1829                 /*
1830                  * Now we are doing the default action for this signal.
1831                  */
1832                 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1833                         continue;
1834
1835                 /*
1836                  * Global init gets no signals it doesn't want.
1837                  */
1838                 if (unlikely(signal->flags & SIGNAL_UNKILLABLE) &&
1839                     !signal_group_exit(signal))
1840                         continue;
1841
1842                 if (sig_kernel_stop(signr)) {
1843                         /*
1844                          * The default action is to stop all threads in
1845                          * the thread group.  The job control signals
1846                          * do nothing in an orphaned pgrp, but SIGSTOP
1847                          * always works.  Note that siglock needs to be
1848                          * dropped during the call to is_orphaned_pgrp()
1849                          * because of lock ordering with tasklist_lock.
1850                          * This allows an intervening SIGCONT to be posted.
1851                          * We need to check for that and bail out if necessary.
1852                          */
1853                         if (signr != SIGSTOP) {
1854                                 spin_unlock_irq(&sighand->siglock);
1855
1856                                 /* signals can be posted during this window */
1857
1858                                 if (is_current_pgrp_orphaned())
1859                                         goto relock;
1860
1861                                 spin_lock_irq(&sighand->siglock);
1862                         }
1863
1864                         if (likely(do_signal_stop(info->si_signo))) {
1865                                 /* It released the siglock.  */
1866                                 goto relock;
1867                         }
1868
1869                         /*
1870                          * We didn't actually stop, due to a race
1871                          * with SIGCONT or something like that.
1872                          */
1873                         continue;
1874                 }
1875
1876                 spin_unlock_irq(&sighand->siglock);
1877
1878                 /*
1879                  * Anything else is fatal, maybe with a core dump.
1880                  */
1881                 current->flags |= PF_SIGNALED;
1882
1883                 if (sig_kernel_coredump(signr)) {
1884                         if (print_fatal_signals)
1885                                 print_fatal_signal(regs, info->si_signo);
1886                         /*
1887                          * If it was able to dump core, this kills all
1888                          * other threads in the group and synchronizes with
1889                          * their demise.  If we lost the race with another
1890                          * thread getting here, it set group_exit_code
1891                          * first and our do_group_exit call below will use
1892                          * that value and ignore the one we pass it.
1893                          */
1894                         do_coredump(info->si_signo, info->si_signo, regs);
1895                 }
1896
1897                 /*
1898                  * Death signals, no core dump.
1899                  */
1900                 do_group_exit(info->si_signo);
1901                 /* NOTREACHED */
1902         }
1903         spin_unlock_irq(&sighand->siglock);
1904         return signr;
1905 }
1906
1907 void exit_signals(struct task_struct *tsk)
1908 {
1909         int group_stop = 0;
1910         struct task_struct *t;
1911
1912         if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1913                 tsk->flags |= PF_EXITING;
1914                 return;
1915         }
1916
1917         spin_lock_irq(&tsk->sighand->siglock);
1918         /*
1919          * From now this task is not visible for group-wide signals,
1920          * see wants_signal(), do_signal_stop().
1921          */
1922         tsk->flags |= PF_EXITING;
1923         if (!signal_pending(tsk))
1924                 goto out;
1925
1926         /* It could be that __group_complete_signal() choose us to
1927          * notify about group-wide signal. Another thread should be
1928          * woken now to take the signal since we will not.
1929          */
1930         for (t = tsk; (t = next_thread(t)) != tsk; )
1931                 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1932                         recalc_sigpending_and_wake(t);
1933
1934         if (unlikely(tsk->signal->group_stop_count) &&
1935                         !--tsk->signal->group_stop_count) {
1936                 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1937                 group_stop = 1;
1938         }
1939 out:
1940         spin_unlock_irq(&tsk->sighand->siglock);
1941
1942         if (unlikely(group_stop) && tracehook_notify_jctl(1, CLD_STOPPED)) {
1943                 read_lock(&tasklist_lock);
1944                 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1945                 read_unlock(&tasklist_lock);
1946         }
1947 }
1948
1949 EXPORT_SYMBOL(recalc_sigpending);
1950 EXPORT_SYMBOL_GPL(dequeue_signal);
1951 EXPORT_SYMBOL(flush_signals);
1952 EXPORT_SYMBOL(force_sig);
1953 EXPORT_SYMBOL(send_sig);
1954 EXPORT_SYMBOL(send_sig_info);
1955 EXPORT_SYMBOL(sigprocmask);
1956 EXPORT_SYMBOL(block_all_signals);
1957 EXPORT_SYMBOL(unblock_all_signals);
1958
1959
1960 /*
1961  * System call entry points.
1962  */
1963
1964 asmlinkage long sys_restart_syscall(void)
1965 {
1966         struct restart_block *restart = &current_thread_info()->restart_block;
1967         return restart->fn(restart);
1968 }
1969
1970 long do_no_restart_syscall(struct restart_block *param)
1971 {
1972         return -EINTR;
1973 }
1974
1975 /*
1976  * We don't need to get the kernel lock - this is all local to this
1977  * particular thread.. (and that's good, because this is _heavily_
1978  * used by various programs)
1979  */
1980
1981 /*
1982  * This is also useful for kernel threads that want to temporarily
1983  * (or permanently) block certain signals.
1984  *
1985  * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1986  * interface happily blocks "unblockable" signals like SIGKILL
1987  * and friends.
1988  */
1989 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
1990 {
1991         int error;
1992
1993         spin_lock_irq(&current->sighand->siglock);
1994         if (oldset)
1995                 *oldset = current->blocked;
1996
1997         error = 0;
1998         switch (how) {
1999         case SIG_BLOCK:
2000                 sigorsets(&current->blocked, &current->blocked, set);
2001                 break;
2002         case SIG_UNBLOCK:
2003                 signandsets(&current->blocked, &current->blocked, set);
2004                 break;
2005         case SIG_SETMASK:
2006                 current->blocked = *set;
2007                 break;
2008         default:
2009                 error = -EINVAL;
2010         }
2011         recalc_sigpending();
2012         spin_unlock_irq(&current->sighand->siglock);
2013
2014         return error;
2015 }
2016
2017 asmlinkage long
2018 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2019 {
2020         int error = -EINVAL;
2021         sigset_t old_set, new_set;
2022
2023         /* XXX: Don't preclude handling different sized sigset_t's.  */
2024         if (sigsetsize != sizeof(sigset_t))
2025                 goto out;
2026
2027         if (set) {
2028                 error = -EFAULT;
2029                 if (copy_from_user(&new_set, set, sizeof(*set)))
2030                         goto out;
2031                 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2032
2033                 error = sigprocmask(how, &new_set, &old_set);
2034                 if (error)
2035                         goto out;
2036                 if (oset)
2037                         goto set_old;
2038         } else if (oset) {
2039                 spin_lock_irq(&current->sighand->siglock);
2040                 old_set = current->blocked;
2041                 spin_unlock_irq(&current->sighand->siglock);
2042
2043         set_old:
2044                 error = -EFAULT;
2045                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2046                         goto out;
2047         }
2048         error = 0;
2049 out:
2050         return error;
2051 }
2052
2053 long do_sigpending(void __user *set, unsigned long sigsetsize)
2054 {
2055         long error = -EINVAL;
2056         sigset_t pending;
2057
2058         if (sigsetsize > sizeof(sigset_t))
2059                 goto out;
2060
2061         spin_lock_irq(&current->sighand->siglock);
2062         sigorsets(&pending, &current->pending.signal,
2063                   &current->signal->shared_pending.signal);
2064         spin_unlock_irq(&current->sighand->siglock);
2065
2066         /* Outside the lock because only this thread touches it.  */
2067         sigandsets(&pending, &current->blocked, &pending);
2068
2069         error = -EFAULT;
2070         if (!copy_to_user(set, &pending, sigsetsize))
2071                 error = 0;
2072
2073 out:
2074         return error;
2075 }       
2076
2077 asmlinkage long
2078 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2079 {
2080         return do_sigpending(set, sigsetsize);
2081 }
2082
2083 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2084
2085 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2086 {
2087         int err;
2088
2089         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2090                 return -EFAULT;
2091         if (from->si_code < 0)
2092                 return __copy_to_user(to, from, sizeof(siginfo_t))
2093                         ? -EFAULT : 0;
2094         /*
2095          * If you change siginfo_t structure, please be sure
2096          * this code is fixed accordingly.
2097          * Please remember to update the signalfd_copyinfo() function
2098          * inside fs/signalfd.c too, in case siginfo_t changes.
2099          * It should never copy any pad contained in the structure
2100          * to avoid security leaks, but must copy the generic
2101          * 3 ints plus the relevant union member.
2102          */
2103         err = __put_user(from->si_signo, &to->si_signo);
2104         err |= __put_user(from->si_errno, &to->si_errno);
2105         err |= __put_user((short)from->si_code, &to->si_code);
2106         switch (from->si_code & __SI_MASK) {
2107         case __SI_KILL:
2108                 err |= __put_user(from->si_pid, &to->si_pid);
2109                 err |= __put_user(from->si_uid, &to->si_uid);
2110                 break;
2111         case __SI_TIMER:
2112                  err |= __put_user(from->si_tid, &to->si_tid);
2113                  err |= __put_user(from->si_overrun, &to->si_overrun);
2114                  err |= __put_user(from->si_ptr, &to->si_ptr);
2115                 break;
2116         case __SI_POLL:
2117                 err |= __put_user(from->si_band, &to->si_band);
2118                 err |= __put_user(from->si_fd, &to->si_fd);
2119                 break;
2120         case __SI_FAULT:
2121                 err |= __put_user(from->si_addr, &to->si_addr);
2122 #ifdef __ARCH_SI_TRAPNO
2123                 err |= __put_user(from->si_trapno, &to->si_trapno);
2124 #endif
2125                 break;
2126         case __SI_CHLD:
2127                 err |= __put_user(from->si_pid, &to->si_pid);
2128                 err |= __put_user(from->si_uid, &to->si_uid);
2129                 err |= __put_user(from->si_status, &to->si_status);
2130                 err |= __put_user(from->si_utime, &to->si_utime);
2131                 err |= __put_user(from->si_stime, &to->si_stime);
2132                 break;
2133         case __SI_RT: /* This is not generated by the kernel as of now. */
2134         case __SI_MESGQ: /* But this is */
2135                 err |= __put_user(from->si_pid, &to->si_pid);
2136                 err |= __put_user(from->si_uid, &to->si_uid);
2137                 err |= __put_user(from->si_ptr, &to->si_ptr);
2138                 break;
2139         default: /* this is just in case for now ... */
2140                 err |= __put_user(from->si_pid, &to->si_pid);
2141                 err |= __put_user(from->si_uid, &to->si_uid);
2142                 break;
2143         }
2144         return err;
2145 }
2146
2147 #endif
2148
2149 asmlinkage long
2150 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2151                     siginfo_t __user *uinfo,
2152                     const struct timespec __user *uts,
2153                     size_t sigsetsize)
2154 {
2155         int ret, sig;
2156         sigset_t these;
2157         struct timespec ts;
2158         siginfo_t info;
2159         long timeout = 0;
2160
2161         /* XXX: Don't preclude handling different sized sigset_t's.  */
2162         if (sigsetsize != sizeof(sigset_t))
2163                 return -EINVAL;
2164
2165         if (copy_from_user(&these, uthese, sizeof(these)))
2166                 return -EFAULT;
2167                 
2168         /*
2169          * Invert the set of allowed signals to get those we
2170          * want to block.
2171          */
2172         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2173         signotset(&these);
2174
2175         if (uts) {
2176                 if (copy_from_user(&ts, uts, sizeof(ts)))
2177                         return -EFAULT;
2178                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2179                     || ts.tv_sec < 0)
2180                         return -EINVAL;
2181         }
2182
2183         spin_lock_irq(&current->sighand->siglock);
2184         sig = dequeue_signal(current, &these, &info);
2185         if (!sig) {
2186                 timeout = MAX_SCHEDULE_TIMEOUT;
2187                 if (uts)
2188                         timeout = (timespec_to_jiffies(&ts)
2189                                    + (ts.tv_sec || ts.tv_nsec));
2190
2191                 if (timeout) {
2192                         /* None ready -- temporarily unblock those we're
2193                          * interested while we are sleeping in so that we'll
2194                          * be awakened when they arrive.  */
2195                         current->real_blocked = current->blocked;
2196                         sigandsets(&current->blocked, &current->blocked, &these);
2197                         recalc_sigpending();
2198                         spin_unlock_irq(&current->sighand->siglock);
2199
2200                         timeout = schedule_timeout_interruptible(timeout);
2201
2202                         spin_lock_irq(&current->sighand->siglock);
2203                         sig = dequeue_signal(current, &these, &info);
2204                         current->blocked = current->real_blocked;
2205                         siginitset(&current->real_blocked, 0);
2206                         recalc_sigpending();
2207                 }
2208         }
2209         spin_unlock_irq(&current->sighand->siglock);
2210
2211         if (sig) {
2212                 ret = sig;
2213                 if (uinfo) {
2214                         if (copy_siginfo_to_user(uinfo, &info))
2215                                 ret = -EFAULT;
2216                 }
2217         } else {
2218                 ret = -EAGAIN;
2219                 if (timeout)
2220                         ret = -EINTR;
2221         }
2222
2223         return ret;
2224 }
2225
2226 asmlinkage long
2227 sys_kill(pid_t pid, int sig)
2228 {
2229         struct siginfo info;
2230
2231         info.si_signo = sig;
2232         info.si_errno = 0;
2233         info.si_code = SI_USER;
2234         info.si_pid = task_tgid_vnr(current);
2235         info.si_uid = current_uid();
2236
2237         return kill_something_info(sig, &info, pid);
2238 }
2239
2240 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2241 {
2242         int error;
2243         struct siginfo info;
2244         struct task_struct *p;
2245         unsigned long flags;
2246
2247         error = -ESRCH;
2248         info.si_signo = sig;
2249         info.si_errno = 0;
2250         info.si_code = SI_TKILL;
2251         info.si_pid = task_tgid_vnr(current);
2252         info.si_uid = current_uid();
2253
2254         rcu_read_lock();
2255         p = find_task_by_vpid(pid);
2256         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2257                 error = check_kill_permission(sig, &info, p);
2258                 /*
2259                  * The null signal is a permissions and process existence
2260                  * probe.  No signal is actually delivered.
2261                  *
2262                  * If lock_task_sighand() fails we pretend the task dies
2263                  * after receiving the signal. The window is tiny, and the
2264                  * signal is private anyway.
2265                  */
2266                 if (!error && sig && lock_task_sighand(p, &flags)) {
2267                         error = specific_send_sig_info(sig, &info, p);
2268                         unlock_task_sighand(p, &flags);
2269                 }
2270         }
2271         rcu_read_unlock();
2272
2273         return error;
2274 }
2275
2276 /**
2277  *  sys_tgkill - send signal to one specific thread
2278  *  @tgid: the thread group ID of the thread
2279  *  @pid: the PID of the thread
2280  *  @sig: signal to be sent
2281  *
2282  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2283  *  exists but it's not belonging to the target process anymore. This
2284  *  method solves the problem of threads exiting and PIDs getting reused.
2285  */
2286 asmlinkage long sys_tgkill(pid_t tgid, pid_t pid, int sig)
2287 {
2288         /* This is only valid for single tasks */
2289         if (pid <= 0 || tgid <= 0)
2290                 return -EINVAL;
2291
2292         return do_tkill(tgid, pid, sig);
2293 }
2294
2295 /*
2296  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2297  */
2298 asmlinkage long
2299 sys_tkill(pid_t pid, int sig)
2300 {
2301         /* This is only valid for single tasks */
2302         if (pid <= 0)
2303                 return -EINVAL;
2304
2305         return do_tkill(0, pid, sig);
2306 }
2307
2308 asmlinkage long
2309 sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo)
2310 {
2311         siginfo_t info;
2312
2313         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2314                 return -EFAULT;
2315
2316         /* Not even root can pretend to send signals from the kernel.
2317            Nor can they impersonate a kill(), which adds source info.  */
2318         if (info.si_code >= 0)
2319                 return -EPERM;
2320         info.si_signo = sig;
2321
2322         /* POSIX.1b doesn't mention process groups.  */
2323         return kill_proc_info(sig, &info, pid);
2324 }
2325
2326 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2327 {
2328         struct task_struct *t = current;
2329         struct k_sigaction *k;
2330         sigset_t mask;
2331
2332         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2333                 return -EINVAL;
2334
2335         k = &t->sighand->action[sig-1];
2336
2337         spin_lock_irq(&current->sighand->siglock);
2338         if (oact)
2339                 *oact = *k;
2340
2341         if (act) {
2342                 sigdelsetmask(&act->sa.sa_mask,
2343                               sigmask(SIGKILL) | sigmask(SIGSTOP));
2344                 *k = *act;
2345                 /*
2346                  * POSIX 3.3.1.3:
2347                  *  "Setting a signal action to SIG_IGN for a signal that is
2348                  *   pending shall cause the pending signal to be discarded,
2349                  *   whether or not it is blocked."
2350                  *
2351                  *  "Setting a signal action to SIG_DFL for a signal that is
2352                  *   pending and whose default action is to ignore the signal
2353                  *   (for example, SIGCHLD), shall cause the pending signal to
2354                  *   be discarded, whether or not it is blocked"
2355                  */
2356                 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2357                         sigemptyset(&mask);
2358                         sigaddset(&mask, sig);
2359                         rm_from_queue_full(&mask, &t->signal->shared_pending);
2360                         do {
2361                                 rm_from_queue_full(&mask, &t->pending);
2362                                 t = next_thread(t);
2363                         } while (t != current);
2364                 }
2365         }
2366
2367         spin_unlock_irq(&current->sighand->siglock);
2368         return 0;
2369 }
2370
2371 int 
2372 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2373 {
2374         stack_t oss;
2375         int error;
2376
2377         if (uoss) {
2378                 oss.ss_sp = (void __user *) current->sas_ss_sp;
2379                 oss.ss_size = current->sas_ss_size;
2380                 oss.ss_flags = sas_ss_flags(sp);
2381         }
2382
2383         if (uss) {
2384                 void __user *ss_sp;
2385                 size_t ss_size;
2386                 int ss_flags;
2387
2388                 error = -EFAULT;
2389                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2390                     || __get_user(ss_sp, &uss->ss_sp)
2391                     || __get_user(ss_flags, &uss->ss_flags)
2392                     || __get_user(ss_size, &uss->ss_size))
2393                         goto out;
2394
2395                 error = -EPERM;
2396                 if (on_sig_stack(sp))
2397                         goto out;
2398
2399                 error = -EINVAL;
2400                 /*
2401                  *
2402                  * Note - this code used to test ss_flags incorrectly
2403                  *        old code may have been written using ss_flags==0
2404                  *        to mean ss_flags==SS_ONSTACK (as this was the only
2405                  *        way that worked) - this fix preserves that older
2406                  *        mechanism
2407                  */
2408                 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2409                         goto out;
2410
2411                 if (ss_flags == SS_DISABLE) {
2412                         ss_size = 0;
2413                         ss_sp = NULL;
2414                 } else {
2415                         error = -ENOMEM;
2416                         if (ss_size < MINSIGSTKSZ)
2417                                 goto out;
2418                 }
2419
2420                 current->sas_ss_sp = (unsigned long) ss_sp;
2421                 current->sas_ss_size = ss_size;
2422         }
2423
2424         if (uoss) {
2425                 error = -EFAULT;
2426                 if (copy_to_user(uoss, &oss, sizeof(oss)))
2427                         goto out;
2428         }
2429
2430         error = 0;
2431 out:
2432         return error;
2433 }
2434
2435 #ifdef __ARCH_WANT_SYS_SIGPENDING
2436
2437 asmlinkage long
2438 sys_sigpending(old_sigset_t __user *set)
2439 {
2440         return do_sigpending(set, sizeof(*set));
2441 }
2442
2443 #endif
2444
2445 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2446 /* Some platforms have their own version with special arguments others
2447    support only sys_rt_sigprocmask.  */
2448
2449 asmlinkage long
2450 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2451 {
2452         int error;
2453         old_sigset_t old_set, new_set;
2454
2455         if (set) {
2456                 error = -EFAULT;
2457                 if (copy_from_user(&new_set, set, sizeof(*set)))
2458                         goto out;
2459                 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2460
2461                 spin_lock_irq(&current->sighand->siglock);
2462                 old_set = current->blocked.sig[0];
2463
2464                 error = 0;
2465                 switch (how) {
2466                 default:
2467                         error = -EINVAL;
2468                         break;
2469                 case SIG_BLOCK:
2470                         sigaddsetmask(&current->blocked, new_set);
2471                         break;
2472                 case SIG_UNBLOCK:
2473                         sigdelsetmask(&current->blocked, new_set);
2474                         break;
2475                 case SIG_SETMASK:
2476                         current->blocked.sig[0] = new_set;
2477                         break;
2478                 }
2479
2480                 recalc_sigpending();
2481                 spin_unlock_irq(&current->sighand->siglock);
2482                 if (error)
2483                         goto out;
2484                 if (oset)
2485                         goto set_old;
2486         } else if (oset) {
2487                 old_set = current->blocked.sig[0];
2488         set_old:
2489                 error = -EFAULT;
2490                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2491                         goto out;
2492         }
2493         error = 0;
2494 out:
2495         return error;
2496 }
2497 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2498
2499 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2500 asmlinkage long
2501 sys_rt_sigaction(int sig,
2502                  const struct sigaction __user *act,
2503                  struct sigaction __user *oact,
2504                  size_t sigsetsize)
2505 {
2506         struct k_sigaction new_sa, old_sa;
2507         int ret = -EINVAL;
2508
2509         /* XXX: Don't preclude handling different sized sigset_t's.  */
2510         if (sigsetsize != sizeof(sigset_t))
2511                 goto out;
2512
2513         if (act) {
2514                 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2515                         return -EFAULT;
2516         }
2517
2518         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2519
2520         if (!ret && oact) {
2521                 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2522                         return -EFAULT;
2523         }
2524 out:
2525         return ret;
2526 }
2527 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2528
2529 #ifdef __ARCH_WANT_SYS_SGETMASK
2530
2531 /*
2532  * For backwards compatibility.  Functionality superseded by sigprocmask.
2533  */
2534 asmlinkage long
2535 sys_sgetmask(void)
2536 {
2537         /* SMP safe */
2538         return current->blocked.sig[0];
2539 }
2540
2541 asmlinkage long
2542 sys_ssetmask(int newmask)
2543 {
2544         int old;
2545
2546         spin_lock_irq(&current->sighand->siglock);
2547         old = current->blocked.sig[0];
2548
2549         siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2550                                                   sigmask(SIGSTOP)));
2551         recalc_sigpending();
2552         spin_unlock_irq(&current->sighand->siglock);
2553
2554         return old;
2555 }
2556 #endif /* __ARCH_WANT_SGETMASK */
2557
2558 #ifdef __ARCH_WANT_SYS_SIGNAL
2559 /*
2560  * For backwards compatibility.  Functionality superseded by sigaction.
2561  */
2562 asmlinkage unsigned long
2563 sys_signal(int sig, __sighandler_t handler)
2564 {
2565         struct k_sigaction new_sa, old_sa;
2566         int ret;
2567
2568         new_sa.sa.sa_handler = handler;
2569         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2570         sigemptyset(&new_sa.sa.sa_mask);
2571
2572         ret = do_sigaction(sig, &new_sa, &old_sa);
2573
2574         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2575 }
2576 #endif /* __ARCH_WANT_SYS_SIGNAL */
2577
2578 #ifdef __ARCH_WANT_SYS_PAUSE
2579
2580 asmlinkage long
2581 sys_pause(void)
2582 {
2583         current->state = TASK_INTERRUPTIBLE;
2584         schedule();
2585         return -ERESTARTNOHAND;
2586 }
2587
2588 #endif
2589
2590 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2591 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2592 {
2593         sigset_t newset;
2594
2595         /* XXX: Don't preclude handling different sized sigset_t's.  */
2596         if (sigsetsize != sizeof(sigset_t))
2597                 return -EINVAL;
2598
2599         if (copy_from_user(&newset, unewset, sizeof(newset)))
2600                 return -EFAULT;
2601         sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2602
2603         spin_lock_irq(&current->sighand->siglock);
2604         current->saved_sigmask = current->blocked;
2605         current->blocked = newset;
2606         recalc_sigpending();
2607         spin_unlock_irq(&current->sighand->siglock);
2608
2609         current->state = TASK_INTERRUPTIBLE;
2610         schedule();
2611         set_restore_sigmask();
2612         return -ERESTARTNOHAND;
2613 }
2614 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2615
2616 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2617 {
2618         return NULL;
2619 }
2620
2621 void __init signals_init(void)
2622 {
2623         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
2624 }