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