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