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