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