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