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