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