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