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