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