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