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