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