Merge branch 'irq-fixes-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...
[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_tgid_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 SYSCALL_DEFINE0(restart_syscall)
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 SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user *, set,
2018                 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 SYSCALL_DEFINE2(rt_sigpending, sigset_t __user *, set, size_t, sigsetsize)
2078 {
2079         return do_sigpending(set, sigsetsize);
2080 }
2081
2082 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2083
2084 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2085 {
2086         int err;
2087
2088         if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2089                 return -EFAULT;
2090         if (from->si_code < 0)
2091                 return __copy_to_user(to, from, sizeof(siginfo_t))
2092                         ? -EFAULT : 0;
2093         /*
2094          * If you change siginfo_t structure, please be sure
2095          * this code is fixed accordingly.
2096          * Please remember to update the signalfd_copyinfo() function
2097          * inside fs/signalfd.c too, in case siginfo_t changes.
2098          * It should never copy any pad contained in the structure
2099          * to avoid security leaks, but must copy the generic
2100          * 3 ints plus the relevant union member.
2101          */
2102         err = __put_user(from->si_signo, &to->si_signo);
2103         err |= __put_user(from->si_errno, &to->si_errno);
2104         err |= __put_user((short)from->si_code, &to->si_code);
2105         switch (from->si_code & __SI_MASK) {
2106         case __SI_KILL:
2107                 err |= __put_user(from->si_pid, &to->si_pid);
2108                 err |= __put_user(from->si_uid, &to->si_uid);
2109                 break;
2110         case __SI_TIMER:
2111                  err |= __put_user(from->si_tid, &to->si_tid);
2112                  err |= __put_user(from->si_overrun, &to->si_overrun);
2113                  err |= __put_user(from->si_ptr, &to->si_ptr);
2114                 break;
2115         case __SI_POLL:
2116                 err |= __put_user(from->si_band, &to->si_band);
2117                 err |= __put_user(from->si_fd, &to->si_fd);
2118                 break;
2119         case __SI_FAULT:
2120                 err |= __put_user(from->si_addr, &to->si_addr);
2121 #ifdef __ARCH_SI_TRAPNO
2122                 err |= __put_user(from->si_trapno, &to->si_trapno);
2123 #endif
2124                 break;
2125         case __SI_CHLD:
2126                 err |= __put_user(from->si_pid, &to->si_pid);
2127                 err |= __put_user(from->si_uid, &to->si_uid);
2128                 err |= __put_user(from->si_status, &to->si_status);
2129                 err |= __put_user(from->si_utime, &to->si_utime);
2130                 err |= __put_user(from->si_stime, &to->si_stime);
2131                 break;
2132         case __SI_RT: /* This is not generated by the kernel as of now. */
2133         case __SI_MESGQ: /* But this is */
2134                 err |= __put_user(from->si_pid, &to->si_pid);
2135                 err |= __put_user(from->si_uid, &to->si_uid);
2136                 err |= __put_user(from->si_ptr, &to->si_ptr);
2137                 break;
2138         default: /* this is just in case for now ... */
2139                 err |= __put_user(from->si_pid, &to->si_pid);
2140                 err |= __put_user(from->si_uid, &to->si_uid);
2141                 break;
2142         }
2143         return err;
2144 }
2145
2146 #endif
2147
2148 SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user *, uthese,
2149                 siginfo_t __user *, uinfo, const struct timespec __user *, uts,
2150                 size_t, sigsetsize)
2151 {
2152         int ret, sig;
2153         sigset_t these;
2154         struct timespec ts;
2155         siginfo_t info;
2156         long timeout = 0;
2157
2158         /* XXX: Don't preclude handling different sized sigset_t's.  */
2159         if (sigsetsize != sizeof(sigset_t))
2160                 return -EINVAL;
2161
2162         if (copy_from_user(&these, uthese, sizeof(these)))
2163                 return -EFAULT;
2164                 
2165         /*
2166          * Invert the set of allowed signals to get those we
2167          * want to block.
2168          */
2169         sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2170         signotset(&these);
2171
2172         if (uts) {
2173                 if (copy_from_user(&ts, uts, sizeof(ts)))
2174                         return -EFAULT;
2175                 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2176                     || ts.tv_sec < 0)
2177                         return -EINVAL;
2178         }
2179
2180         spin_lock_irq(&current->sighand->siglock);
2181         sig = dequeue_signal(current, &these, &info);
2182         if (!sig) {
2183                 timeout = MAX_SCHEDULE_TIMEOUT;
2184                 if (uts)
2185                         timeout = (timespec_to_jiffies(&ts)
2186                                    + (ts.tv_sec || ts.tv_nsec));
2187
2188                 if (timeout) {
2189                         /* None ready -- temporarily unblock those we're
2190                          * interested while we are sleeping in so that we'll
2191                          * be awakened when they arrive.  */
2192                         current->real_blocked = current->blocked;
2193                         sigandsets(&current->blocked, &current->blocked, &these);
2194                         recalc_sigpending();
2195                         spin_unlock_irq(&current->sighand->siglock);
2196
2197                         timeout = schedule_timeout_interruptible(timeout);
2198
2199                         spin_lock_irq(&current->sighand->siglock);
2200                         sig = dequeue_signal(current, &these, &info);
2201                         current->blocked = current->real_blocked;
2202                         siginitset(&current->real_blocked, 0);
2203                         recalc_sigpending();
2204                 }
2205         }
2206         spin_unlock_irq(&current->sighand->siglock);
2207
2208         if (sig) {
2209                 ret = sig;
2210                 if (uinfo) {
2211                         if (copy_siginfo_to_user(uinfo, &info))
2212                                 ret = -EFAULT;
2213                 }
2214         } else {
2215                 ret = -EAGAIN;
2216                 if (timeout)
2217                         ret = -EINTR;
2218         }
2219
2220         return ret;
2221 }
2222
2223 SYSCALL_DEFINE2(kill, pid_t, pid, int, sig)
2224 {
2225         struct siginfo info;
2226
2227         info.si_signo = sig;
2228         info.si_errno = 0;
2229         info.si_code = SI_USER;
2230         info.si_pid = task_tgid_vnr(current);
2231         info.si_uid = current_uid();
2232
2233         return kill_something_info(sig, &info, pid);
2234 }
2235
2236 static int do_tkill(pid_t tgid, pid_t pid, int sig)
2237 {
2238         int error;
2239         struct siginfo info;
2240         struct task_struct *p;
2241         unsigned long flags;
2242
2243         error = -ESRCH;
2244         info.si_signo = sig;
2245         info.si_errno = 0;
2246         info.si_code = SI_TKILL;
2247         info.si_pid = task_tgid_vnr(current);
2248         info.si_uid = current_uid();
2249
2250         rcu_read_lock();
2251         p = find_task_by_vpid(pid);
2252         if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2253                 error = check_kill_permission(sig, &info, p);
2254                 /*
2255                  * The null signal is a permissions and process existence
2256                  * probe.  No signal is actually delivered.
2257                  *
2258                  * If lock_task_sighand() fails we pretend the task dies
2259                  * after receiving the signal. The window is tiny, and the
2260                  * signal is private anyway.
2261                  */
2262                 if (!error && sig && lock_task_sighand(p, &flags)) {
2263                         error = specific_send_sig_info(sig, &info, p);
2264                         unlock_task_sighand(p, &flags);
2265                 }
2266         }
2267         rcu_read_unlock();
2268
2269         return error;
2270 }
2271
2272 /**
2273  *  sys_tgkill - send signal to one specific thread
2274  *  @tgid: the thread group ID of the thread
2275  *  @pid: the PID of the thread
2276  *  @sig: signal to be sent
2277  *
2278  *  This syscall also checks the @tgid and returns -ESRCH even if the PID
2279  *  exists but it's not belonging to the target process anymore. This
2280  *  method solves the problem of threads exiting and PIDs getting reused.
2281  */
2282 SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig)
2283 {
2284         /* This is only valid for single tasks */
2285         if (pid <= 0 || tgid <= 0)
2286                 return -EINVAL;
2287
2288         return do_tkill(tgid, pid, sig);
2289 }
2290
2291 /*
2292  *  Send a signal to only one task, even if it's a CLONE_THREAD task.
2293  */
2294 SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig)
2295 {
2296         /* This is only valid for single tasks */
2297         if (pid <= 0)
2298                 return -EINVAL;
2299
2300         return do_tkill(0, pid, sig);
2301 }
2302
2303 SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig,
2304                 siginfo_t __user *, uinfo)
2305 {
2306         siginfo_t info;
2307
2308         if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2309                 return -EFAULT;
2310
2311         /* Not even root can pretend to send signals from the kernel.
2312            Nor can they impersonate a kill(), which adds source info.  */
2313         if (info.si_code >= 0)
2314                 return -EPERM;
2315         info.si_signo = sig;
2316
2317         /* POSIX.1b doesn't mention process groups.  */
2318         return kill_proc_info(sig, &info, pid);
2319 }
2320
2321 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2322 {
2323         struct task_struct *t = current;
2324         struct k_sigaction *k;
2325         sigset_t mask;
2326
2327         if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2328                 return -EINVAL;
2329
2330         k = &t->sighand->action[sig-1];
2331
2332         spin_lock_irq(&current->sighand->siglock);
2333         if (oact)
2334                 *oact = *k;
2335
2336         if (act) {
2337                 sigdelsetmask(&act->sa.sa_mask,
2338                               sigmask(SIGKILL) | sigmask(SIGSTOP));
2339                 *k = *act;
2340                 /*
2341                  * POSIX 3.3.1.3:
2342                  *  "Setting a signal action to SIG_IGN for a signal that is
2343                  *   pending shall cause the pending signal to be discarded,
2344                  *   whether or not it is blocked."
2345                  *
2346                  *  "Setting a signal action to SIG_DFL for a signal that is
2347                  *   pending and whose default action is to ignore the signal
2348                  *   (for example, SIGCHLD), shall cause the pending signal to
2349                  *   be discarded, whether or not it is blocked"
2350                  */
2351                 if (sig_handler_ignored(sig_handler(t, sig), sig)) {
2352                         sigemptyset(&mask);
2353                         sigaddset(&mask, sig);
2354                         rm_from_queue_full(&mask, &t->signal->shared_pending);
2355                         do {
2356                                 rm_from_queue_full(&mask, &t->pending);
2357                                 t = next_thread(t);
2358                         } while (t != current);
2359                 }
2360         }
2361
2362         spin_unlock_irq(&current->sighand->siglock);
2363         return 0;
2364 }
2365
2366 int 
2367 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2368 {
2369         stack_t oss;
2370         int error;
2371
2372         if (uoss) {
2373                 oss.ss_sp = (void __user *) current->sas_ss_sp;
2374                 oss.ss_size = current->sas_ss_size;
2375                 oss.ss_flags = sas_ss_flags(sp);
2376         }
2377
2378         if (uss) {
2379                 void __user *ss_sp;
2380                 size_t ss_size;
2381                 int ss_flags;
2382
2383                 error = -EFAULT;
2384                 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2385                     || __get_user(ss_sp, &uss->ss_sp)
2386                     || __get_user(ss_flags, &uss->ss_flags)
2387                     || __get_user(ss_size, &uss->ss_size))
2388                         goto out;
2389
2390                 error = -EPERM;
2391                 if (on_sig_stack(sp))
2392                         goto out;
2393
2394                 error = -EINVAL;
2395                 /*
2396                  *
2397                  * Note - this code used to test ss_flags incorrectly
2398                  *        old code may have been written using ss_flags==0
2399                  *        to mean ss_flags==SS_ONSTACK (as this was the only
2400                  *        way that worked) - this fix preserves that older
2401                  *        mechanism
2402                  */
2403                 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2404                         goto out;
2405
2406                 if (ss_flags == SS_DISABLE) {
2407                         ss_size = 0;
2408                         ss_sp = NULL;
2409                 } else {
2410                         error = -ENOMEM;
2411                         if (ss_size < MINSIGSTKSZ)
2412                                 goto out;
2413                 }
2414
2415                 current->sas_ss_sp = (unsigned long) ss_sp;
2416                 current->sas_ss_size = ss_size;
2417         }
2418
2419         if (uoss) {
2420                 error = -EFAULT;
2421                 if (copy_to_user(uoss, &oss, sizeof(oss)))
2422                         goto out;
2423         }
2424
2425         error = 0;
2426 out:
2427         return error;
2428 }
2429
2430 #ifdef __ARCH_WANT_SYS_SIGPENDING
2431
2432 SYSCALL_DEFINE1(sigpending, old_sigset_t __user *, set)
2433 {
2434         return do_sigpending(set, sizeof(*set));
2435 }
2436
2437 #endif
2438
2439 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2440 /* Some platforms have their own version with special arguments others
2441    support only sys_rt_sigprocmask.  */
2442
2443 SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user *, set,
2444                 old_sigset_t __user *, oset)
2445 {
2446         int error;
2447         old_sigset_t old_set, new_set;
2448
2449         if (set) {
2450                 error = -EFAULT;
2451                 if (copy_from_user(&new_set, set, sizeof(*set)))
2452                         goto out;
2453                 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2454
2455                 spin_lock_irq(&current->sighand->siglock);
2456                 old_set = current->blocked.sig[0];
2457
2458                 error = 0;
2459                 switch (how) {
2460                 default:
2461                         error = -EINVAL;
2462                         break;
2463                 case SIG_BLOCK:
2464                         sigaddsetmask(&current->blocked, new_set);
2465                         break;
2466                 case SIG_UNBLOCK:
2467                         sigdelsetmask(&current->blocked, new_set);
2468                         break;
2469                 case SIG_SETMASK:
2470                         current->blocked.sig[0] = new_set;
2471                         break;
2472                 }
2473
2474                 recalc_sigpending();
2475                 spin_unlock_irq(&current->sighand->siglock);
2476                 if (error)
2477                         goto out;
2478                 if (oset)
2479                         goto set_old;
2480         } else if (oset) {
2481                 old_set = current->blocked.sig[0];
2482         set_old:
2483                 error = -EFAULT;
2484                 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2485                         goto out;
2486         }
2487         error = 0;
2488 out:
2489         return error;
2490 }
2491 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2492
2493 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2494 SYSCALL_DEFINE4(rt_sigaction, int, sig,
2495                 const struct sigaction __user *, act,
2496                 struct sigaction __user *, oact,
2497                 size_t, sigsetsize)
2498 {
2499         struct k_sigaction new_sa, old_sa;
2500         int ret = -EINVAL;
2501
2502         /* XXX: Don't preclude handling different sized sigset_t's.  */
2503         if (sigsetsize != sizeof(sigset_t))
2504                 goto out;
2505
2506         if (act) {
2507                 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2508                         return -EFAULT;
2509         }
2510
2511         ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2512
2513         if (!ret && oact) {
2514                 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2515                         return -EFAULT;
2516         }
2517 out:
2518         return ret;
2519 }
2520 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2521
2522 #ifdef __ARCH_WANT_SYS_SGETMASK
2523
2524 /*
2525  * For backwards compatibility.  Functionality superseded by sigprocmask.
2526  */
2527 SYSCALL_DEFINE0(sgetmask)
2528 {
2529         /* SMP safe */
2530         return current->blocked.sig[0];
2531 }
2532
2533 SYSCALL_DEFINE1(ssetmask, int, newmask)
2534 {
2535         int old;
2536
2537         spin_lock_irq(&current->sighand->siglock);
2538         old = current->blocked.sig[0];
2539
2540         siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2541                                                   sigmask(SIGSTOP)));
2542         recalc_sigpending();
2543         spin_unlock_irq(&current->sighand->siglock);
2544
2545         return old;
2546 }
2547 #endif /* __ARCH_WANT_SGETMASK */
2548
2549 #ifdef __ARCH_WANT_SYS_SIGNAL
2550 /*
2551  * For backwards compatibility.  Functionality superseded by sigaction.
2552  */
2553 SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler)
2554 {
2555         struct k_sigaction new_sa, old_sa;
2556         int ret;
2557
2558         new_sa.sa.sa_handler = handler;
2559         new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2560         sigemptyset(&new_sa.sa.sa_mask);
2561
2562         ret = do_sigaction(sig, &new_sa, &old_sa);
2563
2564         return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2565 }
2566 #endif /* __ARCH_WANT_SYS_SIGNAL */
2567
2568 #ifdef __ARCH_WANT_SYS_PAUSE
2569
2570 SYSCALL_DEFINE0(pause)
2571 {
2572         current->state = TASK_INTERRUPTIBLE;
2573         schedule();
2574         return -ERESTARTNOHAND;
2575 }
2576
2577 #endif
2578
2579 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2580 SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user *, unewset, size_t, sigsetsize)
2581 {
2582         sigset_t newset;
2583
2584         /* XXX: Don't preclude handling different sized sigset_t's.  */
2585         if (sigsetsize != sizeof(sigset_t))
2586                 return -EINVAL;
2587
2588         if (copy_from_user(&newset, unewset, sizeof(newset)))
2589                 return -EFAULT;
2590         sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2591
2592         spin_lock_irq(&current->sighand->siglock);
2593         current->saved_sigmask = current->blocked;
2594         current->blocked = newset;
2595         recalc_sigpending();
2596         spin_unlock_irq(&current->sighand->siglock);
2597
2598         current->state = TASK_INTERRUPTIBLE;
2599         schedule();
2600         set_restore_sigmask();
2601         return -ERESTARTNOHAND;
2602 }
2603 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2604
2605 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2606 {
2607         return NULL;
2608 }
2609
2610 void __init signals_init(void)
2611 {
2612         sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);
2613 }