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