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