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