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