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