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