[PATCH] x86-64: Use ACPI PXM to parse PCI<->node assignments
[linux-2.6/kvm.git] / kernel / signal.c
blobb92c3c9f8b9a24529e18eb2a1a1bf75f87840f10
1 /*
2 * linux/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
13 #include <linux/config.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/smp_lock.h>
17 #include <linux/init.h>
18 #include <linux/sched.h>
19 #include <linux/fs.h>
20 #include <linux/tty.h>
21 #include <linux/binfmts.h>
22 #include <linux/security.h>
23 #include <linux/syscalls.h>
24 #include <linux/ptrace.h>
25 #include <linux/posix-timers.h>
26 #include <linux/signal.h>
27 #include <linux/audit.h>
28 #include <asm/param.h>
29 #include <asm/uaccess.h>
30 #include <asm/unistd.h>
31 #include <asm/siginfo.h>
34 * SLAB caches for signal bits.
37 static kmem_cache_t *sigqueue_cachep;
40 * In POSIX a signal is sent either to a specific thread (Linux task)
41 * or to the process as a whole (Linux thread group). How the signal
42 * is sent determines whether it's to one thread or the whole group,
43 * which determines which signal mask(s) are involved in blocking it
44 * from being delivered until later. When the signal is delivered,
45 * either it's caught or ignored by a user handler or it has a default
46 * effect that applies to the whole thread group (POSIX process).
48 * The possible effects an unblocked signal set to SIG_DFL can have are:
49 * ignore - Nothing Happens
50 * terminate - kill the process, i.e. all threads in the group,
51 * similar to exit_group. The group leader (only) reports
52 * WIFSIGNALED status to its parent.
53 * coredump - write a core dump file describing all threads using
54 * the same mm and then kill all those threads
55 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
57 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
58 * Other signals when not blocked and set to SIG_DFL behaves as follows.
59 * The job control signals also have other special effects.
61 * +--------------------+------------------+
62 * | POSIX signal | default action |
63 * +--------------------+------------------+
64 * | SIGHUP | terminate |
65 * | SIGINT | terminate |
66 * | SIGQUIT | coredump |
67 * | SIGILL | coredump |
68 * | SIGTRAP | coredump |
69 * | SIGABRT/SIGIOT | coredump |
70 * | SIGBUS | coredump |
71 * | SIGFPE | coredump |
72 * | SIGKILL | terminate(+) |
73 * | SIGUSR1 | terminate |
74 * | SIGSEGV | coredump |
75 * | SIGUSR2 | terminate |
76 * | SIGPIPE | terminate |
77 * | SIGALRM | terminate |
78 * | SIGTERM | terminate |
79 * | SIGCHLD | ignore |
80 * | SIGCONT | ignore(*) |
81 * | SIGSTOP | stop(*)(+) |
82 * | SIGTSTP | stop(*) |
83 * | SIGTTIN | stop(*) |
84 * | SIGTTOU | stop(*) |
85 * | SIGURG | ignore |
86 * | SIGXCPU | coredump |
87 * | SIGXFSZ | coredump |
88 * | SIGVTALRM | terminate |
89 * | SIGPROF | terminate |
90 * | SIGPOLL/SIGIO | terminate |
91 * | SIGSYS/SIGUNUSED | coredump |
92 * | SIGSTKFLT | terminate |
93 * | SIGWINCH | ignore |
94 * | SIGPWR | terminate |
95 * | SIGRTMIN-SIGRTMAX | terminate |
96 * +--------------------+------------------+
97 * | non-POSIX signal | default action |
98 * +--------------------+------------------+
99 * | SIGEMT | coredump |
100 * +--------------------+------------------+
102 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
103 * (*) Special job control effects:
104 * When SIGCONT is sent, it resumes the process (all threads in the group)
105 * from TASK_STOPPED state and also clears any pending/queued stop signals
106 * (any of those marked with "stop(*)"). This happens regardless of blocking,
107 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
108 * any pending/queued SIGCONT signals; this happens regardless of blocking,
109 * catching, or ignored the stop signal, though (except for SIGSTOP) the
110 * default action of stopping the process may happen later or never.
113 #ifdef SIGEMT
114 #define M_SIGEMT M(SIGEMT)
115 #else
116 #define M_SIGEMT 0
117 #endif
119 #if SIGRTMIN > BITS_PER_LONG
120 #define M(sig) (1ULL << ((sig)-1))
121 #else
122 #define M(sig) (1UL << ((sig)-1))
123 #endif
124 #define T(sig, mask) (M(sig) & (mask))
126 #define SIG_KERNEL_ONLY_MASK (\
127 M(SIGKILL) | M(SIGSTOP) )
129 #define SIG_KERNEL_STOP_MASK (\
130 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
132 #define SIG_KERNEL_COREDUMP_MASK (\
133 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
134 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
135 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
137 #define SIG_KERNEL_IGNORE_MASK (\
138 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
140 #define sig_kernel_only(sig) \
141 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
142 #define sig_kernel_coredump(sig) \
143 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
144 #define sig_kernel_ignore(sig) \
145 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
146 #define sig_kernel_stop(sig) \
147 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
149 #define sig_user_defined(t, signr) \
150 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
151 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
153 #define sig_fatal(t, signr) \
154 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
155 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
157 static int sig_ignored(struct task_struct *t, int sig)
159 void __user * handler;
162 * Tracers always want to know about signals..
164 if (t->ptrace & PT_PTRACED)
165 return 0;
168 * Blocked signals are never ignored, since the
169 * signal handler may change by the time it is
170 * unblocked.
172 if (sigismember(&t->blocked, sig))
173 return 0;
175 /* Is it explicitly or implicitly ignored? */
176 handler = t->sighand->action[sig-1].sa.sa_handler;
177 return handler == SIG_IGN ||
178 (handler == SIG_DFL && sig_kernel_ignore(sig));
182 * Re-calculate pending state from the set of locally pending
183 * signals, globally pending signals, and blocked signals.
185 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
187 unsigned long ready;
188 long i;
190 switch (_NSIG_WORDS) {
191 default:
192 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
193 ready |= signal->sig[i] &~ blocked->sig[i];
194 break;
196 case 4: ready = signal->sig[3] &~ blocked->sig[3];
197 ready |= signal->sig[2] &~ blocked->sig[2];
198 ready |= signal->sig[1] &~ blocked->sig[1];
199 ready |= signal->sig[0] &~ blocked->sig[0];
200 break;
202 case 2: ready = signal->sig[1] &~ blocked->sig[1];
203 ready |= signal->sig[0] &~ blocked->sig[0];
204 break;
206 case 1: ready = signal->sig[0] &~ blocked->sig[0];
208 return ready != 0;
211 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
213 fastcall void recalc_sigpending_tsk(struct task_struct *t)
215 if (t->signal->group_stop_count > 0 ||
216 (freezing(t)) ||
217 PENDING(&t->pending, &t->blocked) ||
218 PENDING(&t->signal->shared_pending, &t->blocked))
219 set_tsk_thread_flag(t, TIF_SIGPENDING);
220 else
221 clear_tsk_thread_flag(t, TIF_SIGPENDING);
224 void recalc_sigpending(void)
226 recalc_sigpending_tsk(current);
229 /* Given the mask, find the first available signal that should be serviced. */
231 static int
232 next_signal(struct sigpending *pending, sigset_t *mask)
234 unsigned long i, *s, *m, x;
235 int sig = 0;
237 s = pending->signal.sig;
238 m = mask->sig;
239 switch (_NSIG_WORDS) {
240 default:
241 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
242 if ((x = *s &~ *m) != 0) {
243 sig = ffz(~x) + i*_NSIG_BPW + 1;
244 break;
246 break;
248 case 2: if ((x = s[0] &~ m[0]) != 0)
249 sig = 1;
250 else if ((x = s[1] &~ m[1]) != 0)
251 sig = _NSIG_BPW + 1;
252 else
253 break;
254 sig += ffz(~x);
255 break;
257 case 1: if ((x = *s &~ *m) != 0)
258 sig = ffz(~x) + 1;
259 break;
262 return sig;
265 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, unsigned int __nocast flags,
266 int override_rlimit)
268 struct sigqueue *q = NULL;
270 atomic_inc(&t->user->sigpending);
271 if (override_rlimit ||
272 atomic_read(&t->user->sigpending) <=
273 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
274 q = kmem_cache_alloc(sigqueue_cachep, flags);
275 if (unlikely(q == NULL)) {
276 atomic_dec(&t->user->sigpending);
277 } else {
278 INIT_LIST_HEAD(&q->list);
279 q->flags = 0;
280 q->lock = NULL;
281 q->user = get_uid(t->user);
283 return(q);
286 static inline void __sigqueue_free(struct sigqueue *q)
288 if (q->flags & SIGQUEUE_PREALLOC)
289 return;
290 atomic_dec(&q->user->sigpending);
291 free_uid(q->user);
292 kmem_cache_free(sigqueue_cachep, q);
295 static void flush_sigqueue(struct sigpending *queue)
297 struct sigqueue *q;
299 sigemptyset(&queue->signal);
300 while (!list_empty(&queue->list)) {
301 q = list_entry(queue->list.next, struct sigqueue , list);
302 list_del_init(&q->list);
303 __sigqueue_free(q);
308 * Flush all pending signals for a task.
311 void
312 flush_signals(struct task_struct *t)
314 unsigned long flags;
316 spin_lock_irqsave(&t->sighand->siglock, flags);
317 clear_tsk_thread_flag(t,TIF_SIGPENDING);
318 flush_sigqueue(&t->pending);
319 flush_sigqueue(&t->signal->shared_pending);
320 spin_unlock_irqrestore(&t->sighand->siglock, flags);
324 * This function expects the tasklist_lock write-locked.
326 void __exit_sighand(struct task_struct *tsk)
328 struct sighand_struct * sighand = tsk->sighand;
330 /* Ok, we're done with the signal handlers */
331 tsk->sighand = NULL;
332 if (atomic_dec_and_test(&sighand->count))
333 kmem_cache_free(sighand_cachep, sighand);
336 void exit_sighand(struct task_struct *tsk)
338 write_lock_irq(&tasklist_lock);
339 __exit_sighand(tsk);
340 write_unlock_irq(&tasklist_lock);
344 * This function expects the tasklist_lock write-locked.
346 void __exit_signal(struct task_struct *tsk)
348 struct signal_struct * sig = tsk->signal;
349 struct sighand_struct * sighand = tsk->sighand;
351 if (!sig)
352 BUG();
353 if (!atomic_read(&sig->count))
354 BUG();
355 spin_lock(&sighand->siglock);
356 posix_cpu_timers_exit(tsk);
357 if (atomic_dec_and_test(&sig->count)) {
358 posix_cpu_timers_exit_group(tsk);
359 if (tsk == sig->curr_target)
360 sig->curr_target = next_thread(tsk);
361 tsk->signal = NULL;
362 spin_unlock(&sighand->siglock);
363 flush_sigqueue(&sig->shared_pending);
364 } else {
366 * If there is any task waiting for the group exit
367 * then notify it:
369 if (sig->group_exit_task && atomic_read(&sig->count) == sig->notify_count) {
370 wake_up_process(sig->group_exit_task);
371 sig->group_exit_task = NULL;
373 if (tsk == sig->curr_target)
374 sig->curr_target = next_thread(tsk);
375 tsk->signal = NULL;
377 * Accumulate here the counters for all threads but the
378 * group leader as they die, so they can be added into
379 * the process-wide totals when those are taken.
380 * The group leader stays around as a zombie as long
381 * as there are other threads. When it gets reaped,
382 * the exit.c code will add its counts into these totals.
383 * We won't ever get here for the group leader, since it
384 * will have been the last reference on the signal_struct.
386 sig->utime = cputime_add(sig->utime, tsk->utime);
387 sig->stime = cputime_add(sig->stime, tsk->stime);
388 sig->min_flt += tsk->min_flt;
389 sig->maj_flt += tsk->maj_flt;
390 sig->nvcsw += tsk->nvcsw;
391 sig->nivcsw += tsk->nivcsw;
392 sig->sched_time += tsk->sched_time;
393 spin_unlock(&sighand->siglock);
394 sig = NULL; /* Marker for below. */
396 clear_tsk_thread_flag(tsk,TIF_SIGPENDING);
397 flush_sigqueue(&tsk->pending);
398 if (sig) {
400 * We are cleaning up the signal_struct here. We delayed
401 * calling exit_itimers until after flush_sigqueue, just in
402 * case our thread-local pending queue contained a queued
403 * timer signal that would have been cleared in
404 * exit_itimers. When that called sigqueue_free, it would
405 * attempt to re-take the tasklist_lock and deadlock. This
406 * can never happen if we ensure that all queues the
407 * timer's signal might be queued on have been flushed
408 * first. The shared_pending queue, and our own pending
409 * queue are the only queues the timer could be on, since
410 * there are no other threads left in the group and timer
411 * signals are constrained to threads inside the group.
413 exit_itimers(sig);
414 exit_thread_group_keys(sig);
415 kmem_cache_free(signal_cachep, sig);
419 void exit_signal(struct task_struct *tsk)
421 write_lock_irq(&tasklist_lock);
422 __exit_signal(tsk);
423 write_unlock_irq(&tasklist_lock);
427 * Flush all handlers for a task.
430 void
431 flush_signal_handlers(struct task_struct *t, int force_default)
433 int i;
434 struct k_sigaction *ka = &t->sighand->action[0];
435 for (i = _NSIG ; i != 0 ; i--) {
436 if (force_default || ka->sa.sa_handler != SIG_IGN)
437 ka->sa.sa_handler = SIG_DFL;
438 ka->sa.sa_flags = 0;
439 sigemptyset(&ka->sa.sa_mask);
440 ka++;
445 /* Notify the system that a driver wants to block all signals for this
446 * process, and wants to be notified if any signals at all were to be
447 * sent/acted upon. If the notifier routine returns non-zero, then the
448 * signal will be acted upon after all. If the notifier routine returns 0,
449 * then then signal will be blocked. Only one block per process is
450 * allowed. priv is a pointer to private data that the notifier routine
451 * can use to determine if the signal should be blocked or not. */
453 void
454 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
456 unsigned long flags;
458 spin_lock_irqsave(&current->sighand->siglock, flags);
459 current->notifier_mask = mask;
460 current->notifier_data = priv;
461 current->notifier = notifier;
462 spin_unlock_irqrestore(&current->sighand->siglock, flags);
465 /* Notify the system that blocking has ended. */
467 void
468 unblock_all_signals(void)
470 unsigned long flags;
472 spin_lock_irqsave(&current->sighand->siglock, flags);
473 current->notifier = NULL;
474 current->notifier_data = NULL;
475 recalc_sigpending();
476 spin_unlock_irqrestore(&current->sighand->siglock, flags);
479 static inline int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
481 struct sigqueue *q, *first = NULL;
482 int still_pending = 0;
484 if (unlikely(!sigismember(&list->signal, sig)))
485 return 0;
488 * Collect the siginfo appropriate to this signal. Check if
489 * there is another siginfo for the same signal.
491 list_for_each_entry(q, &list->list, list) {
492 if (q->info.si_signo == sig) {
493 if (first) {
494 still_pending = 1;
495 break;
497 first = q;
500 if (first) {
501 list_del_init(&first->list);
502 copy_siginfo(info, &first->info);
503 __sigqueue_free(first);
504 if (!still_pending)
505 sigdelset(&list->signal, sig);
506 } else {
508 /* Ok, it wasn't in the queue. This must be
509 a fast-pathed signal or we must have been
510 out of queue space. So zero out the info.
512 sigdelset(&list->signal, sig);
513 info->si_signo = sig;
514 info->si_errno = 0;
515 info->si_code = 0;
516 info->si_pid = 0;
517 info->si_uid = 0;
519 return 1;
522 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
523 siginfo_t *info)
525 int sig = 0;
527 /* SIGKILL must have priority, otherwise it is quite easy
528 * to create an unkillable process, sending sig < SIGKILL
529 * to self */
530 if (unlikely(sigismember(&pending->signal, SIGKILL))) {
531 if (!sigismember(mask, SIGKILL))
532 sig = SIGKILL;
535 if (likely(!sig))
536 sig = next_signal(pending, mask);
537 if (sig) {
538 if (current->notifier) {
539 if (sigismember(current->notifier_mask, sig)) {
540 if (!(current->notifier)(current->notifier_data)) {
541 clear_thread_flag(TIF_SIGPENDING);
542 return 0;
547 if (!collect_signal(sig, pending, info))
548 sig = 0;
551 recalc_sigpending();
553 return sig;
557 * Dequeue a signal and return the element to the caller, which is
558 * expected to free it.
560 * All callers have to hold the siglock.
562 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
564 int signr = __dequeue_signal(&tsk->pending, mask, info);
565 if (!signr)
566 signr = __dequeue_signal(&tsk->signal->shared_pending,
567 mask, info);
568 if (signr && unlikely(sig_kernel_stop(signr))) {
570 * Set a marker that we have dequeued a stop signal. Our
571 * caller might release the siglock and then the pending
572 * stop signal it is about to process is no longer in the
573 * pending bitmasks, but must still be cleared by a SIGCONT
574 * (and overruled by a SIGKILL). So those cases clear this
575 * shared flag after we've set it. Note that this flag may
576 * remain set after the signal we return is ignored or
577 * handled. That doesn't matter because its only purpose
578 * is to alert stop-signal processing code when another
579 * processor has come along and cleared the flag.
581 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
583 if ( signr &&
584 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
585 info->si_sys_private){
587 * Release the siglock to ensure proper locking order
588 * of timer locks outside of siglocks. Note, we leave
589 * irqs disabled here, since the posix-timers code is
590 * about to disable them again anyway.
592 spin_unlock(&tsk->sighand->siglock);
593 do_schedule_next_timer(info);
594 spin_lock(&tsk->sighand->siglock);
596 return signr;
600 * Tell a process that it has a new active signal..
602 * NOTE! we rely on the previous spin_lock to
603 * lock interrupts for us! We can only be called with
604 * "siglock" held, and the local interrupt must
605 * have been disabled when that got acquired!
607 * No need to set need_resched since signal event passing
608 * goes through ->blocked
610 void signal_wake_up(struct task_struct *t, int resume)
612 unsigned int mask;
614 set_tsk_thread_flag(t, TIF_SIGPENDING);
617 * For SIGKILL, we want to wake it up in the stopped/traced case.
618 * We don't check t->state here because there is a race with it
619 * executing another processor and just now entering stopped state.
620 * By using wake_up_state, we ensure the process will wake up and
621 * handle its death signal.
623 mask = TASK_INTERRUPTIBLE;
624 if (resume)
625 mask |= TASK_STOPPED | TASK_TRACED;
626 if (!wake_up_state(t, mask))
627 kick_process(t);
631 * Remove signals in mask from the pending set and queue.
632 * Returns 1 if any signals were found.
634 * All callers must be holding the siglock.
636 static int rm_from_queue(unsigned long mask, struct sigpending *s)
638 struct sigqueue *q, *n;
640 if (!sigtestsetmask(&s->signal, mask))
641 return 0;
643 sigdelsetmask(&s->signal, mask);
644 list_for_each_entry_safe(q, n, &s->list, list) {
645 if (q->info.si_signo < SIGRTMIN &&
646 (mask & sigmask(q->info.si_signo))) {
647 list_del_init(&q->list);
648 __sigqueue_free(q);
651 return 1;
655 * Bad permissions for sending the signal
657 static int check_kill_permission(int sig, struct siginfo *info,
658 struct task_struct *t)
660 int error = -EINVAL;
661 if (!valid_signal(sig))
662 return error;
663 error = -EPERM;
664 if ((!info || ((unsigned long)info != 1 &&
665 (unsigned long)info != 2 && SI_FROMUSER(info)))
666 && ((sig != SIGCONT) ||
667 (current->signal->session != t->signal->session))
668 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
669 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
670 && !capable(CAP_KILL))
671 return error;
673 error = security_task_kill(t, info, sig);
674 if (!error)
675 audit_signal_info(sig, t); /* Let audit system see the signal */
676 return error;
679 /* forward decl */
680 static void do_notify_parent_cldstop(struct task_struct *tsk,
681 int to_self,
682 int why);
685 * Handle magic process-wide effects of stop/continue signals.
686 * Unlike the signal actions, these happen immediately at signal-generation
687 * time regardless of blocking, ignoring, or handling. This does the
688 * actual continuing for SIGCONT, but not the actual stopping for stop
689 * signals. The process stop is done as a signal action for SIG_DFL.
691 static void handle_stop_signal(int sig, struct task_struct *p)
693 struct task_struct *t;
695 if (p->signal->flags & SIGNAL_GROUP_EXIT)
697 * The process is in the middle of dying already.
699 return;
701 if (sig_kernel_stop(sig)) {
703 * This is a stop signal. Remove SIGCONT from all queues.
705 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
706 t = p;
707 do {
708 rm_from_queue(sigmask(SIGCONT), &t->pending);
709 t = next_thread(t);
710 } while (t != p);
711 } else if (sig == SIGCONT) {
713 * Remove all stop signals from all queues,
714 * and wake all threads.
716 if (unlikely(p->signal->group_stop_count > 0)) {
718 * There was a group stop in progress. We'll
719 * pretend it finished before we got here. We are
720 * obliged to report it to the parent: if the
721 * SIGSTOP happened "after" this SIGCONT, then it
722 * would have cleared this pending SIGCONT. If it
723 * happened "before" this SIGCONT, then the parent
724 * got the SIGCHLD about the stop finishing before
725 * the continue happened. We do the notification
726 * now, and it's as if the stop had finished and
727 * the SIGCHLD was pending on entry to this kill.
729 p->signal->group_stop_count = 0;
730 p->signal->flags = SIGNAL_STOP_CONTINUED;
731 spin_unlock(&p->sighand->siglock);
732 do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_STOPPED);
733 spin_lock(&p->sighand->siglock);
735 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
736 t = p;
737 do {
738 unsigned int state;
739 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
742 * If there is a handler for SIGCONT, we must make
743 * sure that no thread returns to user mode before
744 * we post the signal, in case it was the only
745 * thread eligible to run the signal handler--then
746 * it must not do anything between resuming and
747 * running the handler. With the TIF_SIGPENDING
748 * flag set, the thread will pause and acquire the
749 * siglock that we hold now and until we've queued
750 * the pending signal.
752 * Wake up the stopped thread _after_ setting
753 * TIF_SIGPENDING
755 state = TASK_STOPPED;
756 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
757 set_tsk_thread_flag(t, TIF_SIGPENDING);
758 state |= TASK_INTERRUPTIBLE;
760 wake_up_state(t, state);
762 t = next_thread(t);
763 } while (t != p);
765 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
767 * We were in fact stopped, and are now continued.
768 * Notify the parent with CLD_CONTINUED.
770 p->signal->flags = SIGNAL_STOP_CONTINUED;
771 p->signal->group_exit_code = 0;
772 spin_unlock(&p->sighand->siglock);
773 do_notify_parent_cldstop(p, (p->ptrace & PT_PTRACED), CLD_CONTINUED);
774 spin_lock(&p->sighand->siglock);
775 } else {
777 * We are not stopped, but there could be a stop
778 * signal in the middle of being processed after
779 * being removed from the queue. Clear that too.
781 p->signal->flags = 0;
783 } else if (sig == SIGKILL) {
785 * Make sure that any pending stop signal already dequeued
786 * is undone by the wakeup for SIGKILL.
788 p->signal->flags = 0;
792 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
793 struct sigpending *signals)
795 struct sigqueue * q = NULL;
796 int ret = 0;
799 * fast-pathed signals for kernel-internal things like SIGSTOP
800 * or SIGKILL.
802 if ((unsigned long)info == 2)
803 goto out_set;
805 /* Real-time signals must be queued if sent by sigqueue, or
806 some other real-time mechanism. It is implementation
807 defined whether kill() does so. We attempt to do so, on
808 the principle of least surprise, but since kill is not
809 allowed to fail with EAGAIN when low on memory we just
810 make sure at least one signal gets delivered and don't
811 pass on the info struct. */
813 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
814 ((unsigned long) info < 2 ||
815 info->si_code >= 0)));
816 if (q) {
817 list_add_tail(&q->list, &signals->list);
818 switch ((unsigned long) info) {
819 case 0:
820 q->info.si_signo = sig;
821 q->info.si_errno = 0;
822 q->info.si_code = SI_USER;
823 q->info.si_pid = current->pid;
824 q->info.si_uid = current->uid;
825 break;
826 case 1:
827 q->info.si_signo = sig;
828 q->info.si_errno = 0;
829 q->info.si_code = SI_KERNEL;
830 q->info.si_pid = 0;
831 q->info.si_uid = 0;
832 break;
833 default:
834 copy_siginfo(&q->info, info);
835 break;
837 } else {
838 if (sig >= SIGRTMIN && info && (unsigned long)info != 1
839 && info->si_code != SI_USER)
841 * Queue overflow, abort. We may abort if the signal was rt
842 * and sent by user using something other than kill().
844 return -EAGAIN;
845 if (((unsigned long)info > 1) && (info->si_code == SI_TIMER))
847 * Set up a return to indicate that we dropped
848 * the signal.
850 ret = info->si_sys_private;
853 out_set:
854 sigaddset(&signals->signal, sig);
855 return ret;
858 #define LEGACY_QUEUE(sigptr, sig) \
859 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
862 static int
863 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
865 int ret = 0;
867 if (!irqs_disabled())
868 BUG();
869 assert_spin_locked(&t->sighand->siglock);
871 if (((unsigned long)info > 2) && (info->si_code == SI_TIMER))
873 * Set up a return to indicate that we dropped the signal.
875 ret = info->si_sys_private;
877 /* Short-circuit ignored signals. */
878 if (sig_ignored(t, sig))
879 goto out;
881 /* Support queueing exactly one non-rt signal, so that we
882 can get more detailed information about the cause of
883 the signal. */
884 if (LEGACY_QUEUE(&t->pending, sig))
885 goto out;
887 ret = send_signal(sig, info, t, &t->pending);
888 if (!ret && !sigismember(&t->blocked, sig))
889 signal_wake_up(t, sig == SIGKILL);
890 out:
891 return ret;
895 * Force a signal that the process can't ignore: if necessary
896 * we unblock the signal and change any SIG_IGN to SIG_DFL.
900 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
902 unsigned long int flags;
903 int ret;
905 spin_lock_irqsave(&t->sighand->siglock, flags);
906 if (sigismember(&t->blocked, sig) || t->sighand->action[sig-1].sa.sa_handler == SIG_IGN) {
907 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
908 sigdelset(&t->blocked, sig);
909 recalc_sigpending_tsk(t);
911 ret = specific_send_sig_info(sig, info, t);
912 spin_unlock_irqrestore(&t->sighand->siglock, flags);
914 return ret;
917 void
918 force_sig_specific(int sig, struct task_struct *t)
920 unsigned long int flags;
922 spin_lock_irqsave(&t->sighand->siglock, flags);
923 if (t->sighand->action[sig-1].sa.sa_handler == SIG_IGN)
924 t->sighand->action[sig-1].sa.sa_handler = SIG_DFL;
925 sigdelset(&t->blocked, sig);
926 recalc_sigpending_tsk(t);
927 specific_send_sig_info(sig, (void *)2, t);
928 spin_unlock_irqrestore(&t->sighand->siglock, flags);
932 * Test if P wants to take SIG. After we've checked all threads with this,
933 * it's equivalent to finding no threads not blocking SIG. Any threads not
934 * blocking SIG were ruled out because they are not running and already
935 * have pending signals. Such threads will dequeue from the shared queue
936 * as soon as they're available, so putting the signal on the shared queue
937 * will be equivalent to sending it to one such thread.
939 #define wants_signal(sig, p, mask) \
940 (!sigismember(&(p)->blocked, sig) \
941 && !((p)->state & mask) \
942 && !((p)->flags & PF_EXITING) \
943 && (task_curr(p) || !signal_pending(p)))
946 static void
947 __group_complete_signal(int sig, struct task_struct *p)
949 unsigned int mask;
950 struct task_struct *t;
953 * Don't bother traced and stopped tasks (but
954 * SIGKILL will punch through that).
956 mask = TASK_STOPPED | TASK_TRACED;
957 if (sig == SIGKILL)
958 mask = 0;
961 * Now find a thread we can wake up to take the signal off the queue.
963 * If the main thread wants the signal, it gets first crack.
964 * Probably the least surprising to the average bear.
966 if (wants_signal(sig, p, mask))
967 t = p;
968 else if (thread_group_empty(p))
970 * There is just one thread and it does not need to be woken.
971 * It will dequeue unblocked signals before it runs again.
973 return;
974 else {
976 * Otherwise try to find a suitable thread.
978 t = p->signal->curr_target;
979 if (t == NULL)
980 /* restart balancing at this thread */
981 t = p->signal->curr_target = p;
982 BUG_ON(t->tgid != p->tgid);
984 while (!wants_signal(sig, t, mask)) {
985 t = next_thread(t);
986 if (t == p->signal->curr_target)
988 * No thread needs to be woken.
989 * Any eligible threads will see
990 * the signal in the queue soon.
992 return;
994 p->signal->curr_target = t;
998 * Found a killable thread. If the signal will be fatal,
999 * then start taking the whole group down immediately.
1001 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
1002 !sigismember(&t->real_blocked, sig) &&
1003 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
1005 * This signal will be fatal to the whole group.
1007 if (!sig_kernel_coredump(sig)) {
1009 * Start a group exit and wake everybody up.
1010 * This way we don't have other threads
1011 * running and doing things after a slower
1012 * thread has the fatal signal pending.
1014 p->signal->flags = SIGNAL_GROUP_EXIT;
1015 p->signal->group_exit_code = sig;
1016 p->signal->group_stop_count = 0;
1017 t = p;
1018 do {
1019 sigaddset(&t->pending.signal, SIGKILL);
1020 signal_wake_up(t, 1);
1021 t = next_thread(t);
1022 } while (t != p);
1023 return;
1027 * There will be a core dump. We make all threads other
1028 * than the chosen one go into a group stop so that nothing
1029 * happens until it gets scheduled, takes the signal off
1030 * the shared queue, and does the core dump. This is a
1031 * little more complicated than strictly necessary, but it
1032 * keeps the signal state that winds up in the core dump
1033 * unchanged from the death state, e.g. which thread had
1034 * the core-dump signal unblocked.
1036 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
1037 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
1038 p->signal->group_stop_count = 0;
1039 p->signal->group_exit_task = t;
1040 t = p;
1041 do {
1042 p->signal->group_stop_count++;
1043 signal_wake_up(t, 0);
1044 t = next_thread(t);
1045 } while (t != p);
1046 wake_up_process(p->signal->group_exit_task);
1047 return;
1051 * The signal is already in the shared-pending queue.
1052 * Tell the chosen thread to wake up and dequeue it.
1054 signal_wake_up(t, sig == SIGKILL);
1055 return;
1059 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1061 int ret = 0;
1063 assert_spin_locked(&p->sighand->siglock);
1064 handle_stop_signal(sig, p);
1066 if (((unsigned long)info > 2) && (info->si_code == SI_TIMER))
1068 * Set up a return to indicate that we dropped the signal.
1070 ret = info->si_sys_private;
1072 /* Short-circuit ignored signals. */
1073 if (sig_ignored(p, sig))
1074 return ret;
1076 if (LEGACY_QUEUE(&p->signal->shared_pending, sig))
1077 /* This is a non-RT signal and we already have one queued. */
1078 return ret;
1081 * Put this signal on the shared-pending queue, or fail with EAGAIN.
1082 * We always use the shared queue for process-wide signals,
1083 * to avoid several races.
1085 ret = send_signal(sig, info, p, &p->signal->shared_pending);
1086 if (unlikely(ret))
1087 return ret;
1089 __group_complete_signal(sig, p);
1090 return 0;
1094 * Nuke all other threads in the group.
1096 void zap_other_threads(struct task_struct *p)
1098 struct task_struct *t;
1100 p->signal->flags = SIGNAL_GROUP_EXIT;
1101 p->signal->group_stop_count = 0;
1103 if (thread_group_empty(p))
1104 return;
1106 for (t = next_thread(p); t != p; t = next_thread(t)) {
1108 * Don't bother with already dead threads
1110 if (t->exit_state)
1111 continue;
1114 * We don't want to notify the parent, since we are
1115 * killed as part of a thread group due to another
1116 * thread doing an execve() or similar. So set the
1117 * exit signal to -1 to allow immediate reaping of
1118 * the process. But don't detach the thread group
1119 * leader.
1121 if (t != p->group_leader)
1122 t->exit_signal = -1;
1124 sigaddset(&t->pending.signal, SIGKILL);
1125 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
1126 signal_wake_up(t, 1);
1131 * Must be called with the tasklist_lock held for reading!
1133 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1135 unsigned long flags;
1136 int ret;
1138 ret = check_kill_permission(sig, info, p);
1139 if (!ret && sig && p->sighand) {
1140 spin_lock_irqsave(&p->sighand->siglock, flags);
1141 ret = __group_send_sig_info(sig, info, p);
1142 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1145 return ret;
1149 * kill_pg_info() sends a signal to a process group: this is what the tty
1150 * control characters do (^C, ^Z etc)
1153 int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1155 struct task_struct *p = NULL;
1156 int retval, success;
1158 if (pgrp <= 0)
1159 return -EINVAL;
1161 success = 0;
1162 retval = -ESRCH;
1163 do_each_task_pid(pgrp, PIDTYPE_PGID, p) {
1164 int err = group_send_sig_info(sig, info, p);
1165 success |= !err;
1166 retval = err;
1167 } while_each_task_pid(pgrp, PIDTYPE_PGID, p);
1168 return success ? 0 : retval;
1172 kill_pg_info(int sig, struct siginfo *info, pid_t pgrp)
1174 int retval;
1176 read_lock(&tasklist_lock);
1177 retval = __kill_pg_info(sig, info, pgrp);
1178 read_unlock(&tasklist_lock);
1180 return retval;
1184 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1186 int error;
1187 struct task_struct *p;
1189 read_lock(&tasklist_lock);
1190 p = find_task_by_pid(pid);
1191 error = -ESRCH;
1192 if (p)
1193 error = group_send_sig_info(sig, info, p);
1194 read_unlock(&tasklist_lock);
1195 return error;
1200 * kill_something_info() interprets pid in interesting ways just like kill(2).
1202 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1203 * is probably wrong. Should make it like BSD or SYSV.
1206 static int kill_something_info(int sig, struct siginfo *info, int pid)
1208 if (!pid) {
1209 return kill_pg_info(sig, info, process_group(current));
1210 } else if (pid == -1) {
1211 int retval = 0, count = 0;
1212 struct task_struct * p;
1214 read_lock(&tasklist_lock);
1215 for_each_process(p) {
1216 if (p->pid > 1 && p->tgid != current->tgid) {
1217 int err = group_send_sig_info(sig, info, p);
1218 ++count;
1219 if (err != -EPERM)
1220 retval = err;
1223 read_unlock(&tasklist_lock);
1224 return count ? retval : -ESRCH;
1225 } else if (pid < 0) {
1226 return kill_pg_info(sig, info, -pid);
1227 } else {
1228 return kill_proc_info(sig, info, pid);
1233 * These are for backward compatibility with the rest of the kernel source.
1237 * These two are the most common entry points. They send a signal
1238 * just to the specific thread.
1241 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1243 int ret;
1244 unsigned long flags;
1247 * Make sure legacy kernel users don't send in bad values
1248 * (normal paths check this in check_kill_permission).
1250 if (!valid_signal(sig))
1251 return -EINVAL;
1254 * We need the tasklist lock even for the specific
1255 * thread case (when we don't need to follow the group
1256 * lists) in order to avoid races with "p->sighand"
1257 * going away or changing from under us.
1259 read_lock(&tasklist_lock);
1260 spin_lock_irqsave(&p->sighand->siglock, flags);
1261 ret = specific_send_sig_info(sig, info, p);
1262 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1263 read_unlock(&tasklist_lock);
1264 return ret;
1268 send_sig(int sig, struct task_struct *p, int priv)
1270 return send_sig_info(sig, (void*)(long)(priv != 0), p);
1274 * This is the entry point for "process-wide" signals.
1275 * They will go to an appropriate thread in the thread group.
1278 send_group_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1280 int ret;
1281 read_lock(&tasklist_lock);
1282 ret = group_send_sig_info(sig, info, p);
1283 read_unlock(&tasklist_lock);
1284 return ret;
1287 void
1288 force_sig(int sig, struct task_struct *p)
1290 force_sig_info(sig, (void*)1L, p);
1294 * When things go south during signal handling, we
1295 * will force a SIGSEGV. And if the signal that caused
1296 * the problem was already a SIGSEGV, we'll want to
1297 * make sure we don't even try to deliver the signal..
1300 force_sigsegv(int sig, struct task_struct *p)
1302 if (sig == SIGSEGV) {
1303 unsigned long flags;
1304 spin_lock_irqsave(&p->sighand->siglock, flags);
1305 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1306 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1308 force_sig(SIGSEGV, p);
1309 return 0;
1313 kill_pg(pid_t pgrp, int sig, int priv)
1315 return kill_pg_info(sig, (void *)(long)(priv != 0), pgrp);
1319 kill_proc(pid_t pid, int sig, int priv)
1321 return kill_proc_info(sig, (void *)(long)(priv != 0), pid);
1325 * These functions support sending signals using preallocated sigqueue
1326 * structures. This is needed "because realtime applications cannot
1327 * afford to lose notifications of asynchronous events, like timer
1328 * expirations or I/O completions". In the case of Posix Timers
1329 * we allocate the sigqueue structure from the timer_create. If this
1330 * allocation fails we are able to report the failure to the application
1331 * with an EAGAIN error.
1334 struct sigqueue *sigqueue_alloc(void)
1336 struct sigqueue *q;
1338 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1339 q->flags |= SIGQUEUE_PREALLOC;
1340 return(q);
1343 void sigqueue_free(struct sigqueue *q)
1345 unsigned long flags;
1346 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1348 * If the signal is still pending remove it from the
1349 * pending queue.
1351 if (unlikely(!list_empty(&q->list))) {
1352 read_lock(&tasklist_lock);
1353 spin_lock_irqsave(q->lock, flags);
1354 if (!list_empty(&q->list))
1355 list_del_init(&q->list);
1356 spin_unlock_irqrestore(q->lock, flags);
1357 read_unlock(&tasklist_lock);
1359 q->flags &= ~SIGQUEUE_PREALLOC;
1360 __sigqueue_free(q);
1364 send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1366 unsigned long flags;
1367 int ret = 0;
1369 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1370 read_lock(&tasklist_lock);
1372 if (unlikely(p->flags & PF_EXITING)) {
1373 ret = -1;
1374 goto out_err;
1377 spin_lock_irqsave(&p->sighand->siglock, flags);
1379 if (unlikely(!list_empty(&q->list))) {
1381 * If an SI_TIMER entry is already queue just increment
1382 * the overrun count.
1384 if (q->info.si_code != SI_TIMER)
1385 BUG();
1386 q->info.si_overrun++;
1387 goto out;
1389 /* Short-circuit ignored signals. */
1390 if (sig_ignored(p, sig)) {
1391 ret = 1;
1392 goto out;
1395 q->lock = &p->sighand->siglock;
1396 list_add_tail(&q->list, &p->pending.list);
1397 sigaddset(&p->pending.signal, sig);
1398 if (!sigismember(&p->blocked, sig))
1399 signal_wake_up(p, sig == SIGKILL);
1401 out:
1402 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1403 out_err:
1404 read_unlock(&tasklist_lock);
1406 return ret;
1410 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1412 unsigned long flags;
1413 int ret = 0;
1415 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1416 read_lock(&tasklist_lock);
1417 spin_lock_irqsave(&p->sighand->siglock, flags);
1418 handle_stop_signal(sig, p);
1420 /* Short-circuit ignored signals. */
1421 if (sig_ignored(p, sig)) {
1422 ret = 1;
1423 goto out;
1426 if (unlikely(!list_empty(&q->list))) {
1428 * If an SI_TIMER entry is already queue just increment
1429 * the overrun count. Other uses should not try to
1430 * send the signal multiple times.
1432 if (q->info.si_code != SI_TIMER)
1433 BUG();
1434 q->info.si_overrun++;
1435 goto out;
1439 * Put this signal on the shared-pending queue.
1440 * We always use the shared queue for process-wide signals,
1441 * to avoid several races.
1443 q->lock = &p->sighand->siglock;
1444 list_add_tail(&q->list, &p->signal->shared_pending.list);
1445 sigaddset(&p->signal->shared_pending.signal, sig);
1447 __group_complete_signal(sig, p);
1448 out:
1449 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1450 read_unlock(&tasklist_lock);
1451 return(ret);
1455 * Wake up any threads in the parent blocked in wait* syscalls.
1457 static inline void __wake_up_parent(struct task_struct *p,
1458 struct task_struct *parent)
1460 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1464 * Let a parent know about the death of a child.
1465 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1468 void do_notify_parent(struct task_struct *tsk, int sig)
1470 struct siginfo info;
1471 unsigned long flags;
1472 struct sighand_struct *psig;
1474 BUG_ON(sig == -1);
1476 /* do_notify_parent_cldstop should have been called instead. */
1477 BUG_ON(tsk->state & (TASK_STOPPED|TASK_TRACED));
1479 BUG_ON(!tsk->ptrace &&
1480 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1482 info.si_signo = sig;
1483 info.si_errno = 0;
1484 info.si_pid = tsk->pid;
1485 info.si_uid = tsk->uid;
1487 /* FIXME: find out whether or not this is supposed to be c*time. */
1488 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1489 tsk->signal->utime));
1490 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1491 tsk->signal->stime));
1493 info.si_status = tsk->exit_code & 0x7f;
1494 if (tsk->exit_code & 0x80)
1495 info.si_code = CLD_DUMPED;
1496 else if (tsk->exit_code & 0x7f)
1497 info.si_code = CLD_KILLED;
1498 else {
1499 info.si_code = CLD_EXITED;
1500 info.si_status = tsk->exit_code >> 8;
1503 psig = tsk->parent->sighand;
1504 spin_lock_irqsave(&psig->siglock, flags);
1505 if (sig == SIGCHLD &&
1506 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1507 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1509 * We are exiting and our parent doesn't care. POSIX.1
1510 * defines special semantics for setting SIGCHLD to SIG_IGN
1511 * or setting the SA_NOCLDWAIT flag: we should be reaped
1512 * automatically and not left for our parent's wait4 call.
1513 * Rather than having the parent do it as a magic kind of
1514 * signal handler, we just set this to tell do_exit that we
1515 * can be cleaned up without becoming a zombie. Note that
1516 * we still call __wake_up_parent in this case, because a
1517 * blocked sys_wait4 might now return -ECHILD.
1519 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1520 * is implementation-defined: we do (if you don't want
1521 * it, just use SIG_IGN instead).
1523 tsk->exit_signal = -1;
1524 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1525 sig = 0;
1527 if (valid_signal(sig) && sig > 0)
1528 __group_send_sig_info(sig, &info, tsk->parent);
1529 __wake_up_parent(tsk, tsk->parent);
1530 spin_unlock_irqrestore(&psig->siglock, flags);
1533 static void do_notify_parent_cldstop(struct task_struct *tsk, int to_self, int why)
1535 struct siginfo info;
1536 unsigned long flags;
1537 struct task_struct *parent;
1538 struct sighand_struct *sighand;
1540 if (to_self)
1541 parent = tsk->parent;
1542 else {
1543 tsk = tsk->group_leader;
1544 parent = tsk->real_parent;
1547 info.si_signo = SIGCHLD;
1548 info.si_errno = 0;
1549 info.si_pid = tsk->pid;
1550 info.si_uid = tsk->uid;
1552 /* FIXME: find out whether or not this is supposed to be c*time. */
1553 info.si_utime = cputime_to_jiffies(tsk->utime);
1554 info.si_stime = cputime_to_jiffies(tsk->stime);
1556 info.si_code = why;
1557 switch (why) {
1558 case CLD_CONTINUED:
1559 info.si_status = SIGCONT;
1560 break;
1561 case CLD_STOPPED:
1562 info.si_status = tsk->signal->group_exit_code & 0x7f;
1563 break;
1564 case CLD_TRAPPED:
1565 info.si_status = tsk->exit_code & 0x7f;
1566 break;
1567 default:
1568 BUG();
1571 sighand = parent->sighand;
1572 spin_lock_irqsave(&sighand->siglock, flags);
1573 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1574 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1575 __group_send_sig_info(SIGCHLD, &info, parent);
1577 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1579 __wake_up_parent(tsk, parent);
1580 spin_unlock_irqrestore(&sighand->siglock, flags);
1584 * This must be called with current->sighand->siglock held.
1586 * This should be the path for all ptrace stops.
1587 * We always set current->last_siginfo while stopped here.
1588 * That makes it a way to test a stopped process for
1589 * being ptrace-stopped vs being job-control-stopped.
1591 * If we actually decide not to stop at all because the tracer is gone,
1592 * we leave nostop_code in current->exit_code.
1594 static void ptrace_stop(int exit_code, int nostop_code, siginfo_t *info)
1597 * If there is a group stop in progress,
1598 * we must participate in the bookkeeping.
1600 if (current->signal->group_stop_count > 0)
1601 --current->signal->group_stop_count;
1603 current->last_siginfo = info;
1604 current->exit_code = exit_code;
1606 /* Let the debugger run. */
1607 set_current_state(TASK_TRACED);
1608 spin_unlock_irq(&current->sighand->siglock);
1609 read_lock(&tasklist_lock);
1610 if (likely(current->ptrace & PT_PTRACED) &&
1611 likely(current->parent != current->real_parent ||
1612 !(current->ptrace & PT_ATTACHED)) &&
1613 (likely(current->parent->signal != current->signal) ||
1614 !unlikely(current->signal->flags & SIGNAL_GROUP_EXIT))) {
1615 do_notify_parent_cldstop(current, 1, CLD_TRAPPED);
1616 read_unlock(&tasklist_lock);
1617 schedule();
1618 } else {
1620 * By the time we got the lock, our tracer went away.
1621 * Don't stop here.
1623 read_unlock(&tasklist_lock);
1624 set_current_state(TASK_RUNNING);
1625 current->exit_code = nostop_code;
1629 * We are back. Now reacquire the siglock before touching
1630 * last_siginfo, so that we are sure to have synchronized with
1631 * any signal-sending on another CPU that wants to examine it.
1633 spin_lock_irq(&current->sighand->siglock);
1634 current->last_siginfo = NULL;
1637 * Queued signals ignored us while we were stopped for tracing.
1638 * So check for any that we should take before resuming user mode.
1640 recalc_sigpending();
1643 void ptrace_notify(int exit_code)
1645 siginfo_t info;
1647 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1649 memset(&info, 0, sizeof info);
1650 info.si_signo = SIGTRAP;
1651 info.si_code = exit_code;
1652 info.si_pid = current->pid;
1653 info.si_uid = current->uid;
1655 /* Let the debugger run. */
1656 spin_lock_irq(&current->sighand->siglock);
1657 ptrace_stop(exit_code, 0, &info);
1658 spin_unlock_irq(&current->sighand->siglock);
1661 static void
1662 finish_stop(int stop_count)
1664 int to_self;
1667 * If there are no other threads in the group, or if there is
1668 * a group stop in progress and we are the last to stop,
1669 * report to the parent. When ptraced, every thread reports itself.
1671 if (stop_count < 0 || (current->ptrace & PT_PTRACED))
1672 to_self = 1;
1673 else if (stop_count == 0)
1674 to_self = 0;
1675 else
1676 goto out;
1678 read_lock(&tasklist_lock);
1679 do_notify_parent_cldstop(current, to_self, CLD_STOPPED);
1680 read_unlock(&tasklist_lock);
1682 out:
1683 schedule();
1685 * Now we don't run again until continued.
1687 current->exit_code = 0;
1691 * This performs the stopping for SIGSTOP and other stop signals.
1692 * We have to stop all threads in the thread group.
1693 * Returns nonzero if we've actually stopped and released the siglock.
1694 * Returns zero if we didn't stop and still hold the siglock.
1696 static int
1697 do_signal_stop(int signr)
1699 struct signal_struct *sig = current->signal;
1700 struct sighand_struct *sighand = current->sighand;
1701 int stop_count = -1;
1703 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED))
1704 return 0;
1706 if (sig->group_stop_count > 0) {
1708 * There is a group stop in progress. We don't need to
1709 * start another one.
1711 signr = sig->group_exit_code;
1712 stop_count = --sig->group_stop_count;
1713 current->exit_code = signr;
1714 set_current_state(TASK_STOPPED);
1715 if (stop_count == 0)
1716 sig->flags = SIGNAL_STOP_STOPPED;
1717 spin_unlock_irq(&sighand->siglock);
1719 else if (thread_group_empty(current)) {
1721 * Lock must be held through transition to stopped state.
1723 current->exit_code = current->signal->group_exit_code = signr;
1724 set_current_state(TASK_STOPPED);
1725 sig->flags = SIGNAL_STOP_STOPPED;
1726 spin_unlock_irq(&sighand->siglock);
1728 else {
1730 * There is no group stop already in progress.
1731 * We must initiate one now, but that requires
1732 * dropping siglock to get both the tasklist lock
1733 * and siglock again in the proper order. Note that
1734 * this allows an intervening SIGCONT to be posted.
1735 * We need to check for that and bail out if necessary.
1737 struct task_struct *t;
1739 spin_unlock_irq(&sighand->siglock);
1741 /* signals can be posted during this window */
1743 read_lock(&tasklist_lock);
1744 spin_lock_irq(&sighand->siglock);
1746 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED)) {
1748 * Another stop or continue happened while we
1749 * didn't have the lock. We can just swallow this
1750 * signal now. If we raced with a SIGCONT, that
1751 * should have just cleared it now. If we raced
1752 * with another processor delivering a stop signal,
1753 * then the SIGCONT that wakes us up should clear it.
1755 read_unlock(&tasklist_lock);
1756 return 0;
1759 if (sig->group_stop_count == 0) {
1760 sig->group_exit_code = signr;
1761 stop_count = 0;
1762 for (t = next_thread(current); t != current;
1763 t = next_thread(t))
1765 * Setting state to TASK_STOPPED for a group
1766 * stop is always done with the siglock held,
1767 * so this check has no races.
1769 if (t->state < TASK_STOPPED) {
1770 stop_count++;
1771 signal_wake_up(t, 0);
1773 sig->group_stop_count = stop_count;
1775 else {
1776 /* A race with another thread while unlocked. */
1777 signr = sig->group_exit_code;
1778 stop_count = --sig->group_stop_count;
1781 current->exit_code = signr;
1782 set_current_state(TASK_STOPPED);
1783 if (stop_count == 0)
1784 sig->flags = SIGNAL_STOP_STOPPED;
1786 spin_unlock_irq(&sighand->siglock);
1787 read_unlock(&tasklist_lock);
1790 finish_stop(stop_count);
1791 return 1;
1795 * Do appropriate magic when group_stop_count > 0.
1796 * We return nonzero if we stopped, after releasing the siglock.
1797 * We return zero if we still hold the siglock and should look
1798 * for another signal without checking group_stop_count again.
1800 static inline int handle_group_stop(void)
1802 int stop_count;
1804 if (current->signal->group_exit_task == current) {
1806 * Group stop is so we can do a core dump,
1807 * We are the initiating thread, so get on with it.
1809 current->signal->group_exit_task = NULL;
1810 return 0;
1813 if (current->signal->flags & SIGNAL_GROUP_EXIT)
1815 * Group stop is so another thread can do a core dump,
1816 * or else we are racing against a death signal.
1817 * Just punt the stop so we can get the next signal.
1819 return 0;
1822 * There is a group stop in progress. We stop
1823 * without any associated signal being in our queue.
1825 stop_count = --current->signal->group_stop_count;
1826 if (stop_count == 0)
1827 current->signal->flags = SIGNAL_STOP_STOPPED;
1828 current->exit_code = current->signal->group_exit_code;
1829 set_current_state(TASK_STOPPED);
1830 spin_unlock_irq(&current->sighand->siglock);
1831 finish_stop(stop_count);
1832 return 1;
1835 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1836 struct pt_regs *regs, void *cookie)
1838 sigset_t *mask = &current->blocked;
1839 int signr = 0;
1841 relock:
1842 spin_lock_irq(&current->sighand->siglock);
1843 for (;;) {
1844 struct k_sigaction *ka;
1846 if (unlikely(current->signal->group_stop_count > 0) &&
1847 handle_group_stop())
1848 goto relock;
1850 signr = dequeue_signal(current, mask, info);
1852 if (!signr)
1853 break; /* will return 0 */
1855 if ((current->ptrace & PT_PTRACED) && signr != SIGKILL) {
1856 ptrace_signal_deliver(regs, cookie);
1858 /* Let the debugger run. */
1859 ptrace_stop(signr, signr, info);
1861 /* We're back. Did the debugger cancel the sig? */
1862 signr = current->exit_code;
1863 if (signr == 0)
1864 continue;
1866 current->exit_code = 0;
1868 /* Update the siginfo structure if the signal has
1869 changed. If the debugger wanted something
1870 specific in the siginfo structure then it should
1871 have updated *info via PTRACE_SETSIGINFO. */
1872 if (signr != info->si_signo) {
1873 info->si_signo = signr;
1874 info->si_errno = 0;
1875 info->si_code = SI_USER;
1876 info->si_pid = current->parent->pid;
1877 info->si_uid = current->parent->uid;
1880 /* If the (new) signal is now blocked, requeue it. */
1881 if (sigismember(&current->blocked, signr)) {
1882 specific_send_sig_info(signr, info, current);
1883 continue;
1887 ka = &current->sighand->action[signr-1];
1888 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1889 continue;
1890 if (ka->sa.sa_handler != SIG_DFL) {
1891 /* Run the handler. */
1892 *return_ka = *ka;
1894 if (ka->sa.sa_flags & SA_ONESHOT)
1895 ka->sa.sa_handler = SIG_DFL;
1897 break; /* will return non-zero "signr" value */
1901 * Now we are doing the default action for this signal.
1903 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1904 continue;
1906 /* Init gets no signals it doesn't want. */
1907 if (current->pid == 1)
1908 continue;
1910 if (sig_kernel_stop(signr)) {
1912 * The default action is to stop all threads in
1913 * the thread group. The job control signals
1914 * do nothing in an orphaned pgrp, but SIGSTOP
1915 * always works. Note that siglock needs to be
1916 * dropped during the call to is_orphaned_pgrp()
1917 * because of lock ordering with tasklist_lock.
1918 * This allows an intervening SIGCONT to be posted.
1919 * We need to check for that and bail out if necessary.
1921 if (signr != SIGSTOP) {
1922 spin_unlock_irq(&current->sighand->siglock);
1924 /* signals can be posted during this window */
1926 if (is_orphaned_pgrp(process_group(current)))
1927 goto relock;
1929 spin_lock_irq(&current->sighand->siglock);
1932 if (likely(do_signal_stop(signr))) {
1933 /* It released the siglock. */
1934 goto relock;
1938 * We didn't actually stop, due to a race
1939 * with SIGCONT or something like that.
1941 continue;
1944 spin_unlock_irq(&current->sighand->siglock);
1947 * Anything else is fatal, maybe with a core dump.
1949 current->flags |= PF_SIGNALED;
1950 if (sig_kernel_coredump(signr)) {
1952 * If it was able to dump core, this kills all
1953 * other threads in the group and synchronizes with
1954 * their demise. If we lost the race with another
1955 * thread getting here, it set group_exit_code
1956 * first and our do_group_exit call below will use
1957 * that value and ignore the one we pass it.
1959 do_coredump((long)signr, signr, regs);
1963 * Death signals, no core dump.
1965 do_group_exit(signr);
1966 /* NOTREACHED */
1968 spin_unlock_irq(&current->sighand->siglock);
1969 return signr;
1972 EXPORT_SYMBOL(recalc_sigpending);
1973 EXPORT_SYMBOL_GPL(dequeue_signal);
1974 EXPORT_SYMBOL(flush_signals);
1975 EXPORT_SYMBOL(force_sig);
1976 EXPORT_SYMBOL(kill_pg);
1977 EXPORT_SYMBOL(kill_proc);
1978 EXPORT_SYMBOL(ptrace_notify);
1979 EXPORT_SYMBOL(send_sig);
1980 EXPORT_SYMBOL(send_sig_info);
1981 EXPORT_SYMBOL(sigprocmask);
1982 EXPORT_SYMBOL(block_all_signals);
1983 EXPORT_SYMBOL(unblock_all_signals);
1987 * System call entry points.
1990 asmlinkage long sys_restart_syscall(void)
1992 struct restart_block *restart = &current_thread_info()->restart_block;
1993 return restart->fn(restart);
1996 long do_no_restart_syscall(struct restart_block *param)
1998 return -EINTR;
2002 * We don't need to get the kernel lock - this is all local to this
2003 * particular thread.. (and that's good, because this is _heavily_
2004 * used by various programs)
2008 * This is also useful for kernel threads that want to temporarily
2009 * (or permanently) block certain signals.
2011 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
2012 * interface happily blocks "unblockable" signals like SIGKILL
2013 * and friends.
2015 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2017 int error;
2018 sigset_t old_block;
2020 spin_lock_irq(&current->sighand->siglock);
2021 old_block = current->blocked;
2022 error = 0;
2023 switch (how) {
2024 case SIG_BLOCK:
2025 sigorsets(&current->blocked, &current->blocked, set);
2026 break;
2027 case SIG_UNBLOCK:
2028 signandsets(&current->blocked, &current->blocked, set);
2029 break;
2030 case SIG_SETMASK:
2031 current->blocked = *set;
2032 break;
2033 default:
2034 error = -EINVAL;
2036 recalc_sigpending();
2037 spin_unlock_irq(&current->sighand->siglock);
2038 if (oldset)
2039 *oldset = old_block;
2040 return error;
2043 asmlinkage long
2044 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2046 int error = -EINVAL;
2047 sigset_t old_set, new_set;
2049 /* XXX: Don't preclude handling different sized sigset_t's. */
2050 if (sigsetsize != sizeof(sigset_t))
2051 goto out;
2053 if (set) {
2054 error = -EFAULT;
2055 if (copy_from_user(&new_set, set, sizeof(*set)))
2056 goto out;
2057 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2059 error = sigprocmask(how, &new_set, &old_set);
2060 if (error)
2061 goto out;
2062 if (oset)
2063 goto set_old;
2064 } else if (oset) {
2065 spin_lock_irq(&current->sighand->siglock);
2066 old_set = current->blocked;
2067 spin_unlock_irq(&current->sighand->siglock);
2069 set_old:
2070 error = -EFAULT;
2071 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2072 goto out;
2074 error = 0;
2075 out:
2076 return error;
2079 long do_sigpending(void __user *set, unsigned long sigsetsize)
2081 long error = -EINVAL;
2082 sigset_t pending;
2084 if (sigsetsize > sizeof(sigset_t))
2085 goto out;
2087 spin_lock_irq(&current->sighand->siglock);
2088 sigorsets(&pending, &current->pending.signal,
2089 &current->signal->shared_pending.signal);
2090 spin_unlock_irq(&current->sighand->siglock);
2092 /* Outside the lock because only this thread touches it. */
2093 sigandsets(&pending, &current->blocked, &pending);
2095 error = -EFAULT;
2096 if (!copy_to_user(set, &pending, sigsetsize))
2097 error = 0;
2099 out:
2100 return error;
2103 asmlinkage long
2104 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2106 return do_sigpending(set, sigsetsize);
2109 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2111 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2113 int err;
2115 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2116 return -EFAULT;
2117 if (from->si_code < 0)
2118 return __copy_to_user(to, from, sizeof(siginfo_t))
2119 ? -EFAULT : 0;
2121 * If you change siginfo_t structure, please be sure
2122 * this code is fixed accordingly.
2123 * It should never copy any pad contained in the structure
2124 * to avoid security leaks, but must copy the generic
2125 * 3 ints plus the relevant union member.
2127 err = __put_user(from->si_signo, &to->si_signo);
2128 err |= __put_user(from->si_errno, &to->si_errno);
2129 err |= __put_user((short)from->si_code, &to->si_code);
2130 switch (from->si_code & __SI_MASK) {
2131 case __SI_KILL:
2132 err |= __put_user(from->si_pid, &to->si_pid);
2133 err |= __put_user(from->si_uid, &to->si_uid);
2134 break;
2135 case __SI_TIMER:
2136 err |= __put_user(from->si_tid, &to->si_tid);
2137 err |= __put_user(from->si_overrun, &to->si_overrun);
2138 err |= __put_user(from->si_ptr, &to->si_ptr);
2139 break;
2140 case __SI_POLL:
2141 err |= __put_user(from->si_band, &to->si_band);
2142 err |= __put_user(from->si_fd, &to->si_fd);
2143 break;
2144 case __SI_FAULT:
2145 err |= __put_user(from->si_addr, &to->si_addr);
2146 #ifdef __ARCH_SI_TRAPNO
2147 err |= __put_user(from->si_trapno, &to->si_trapno);
2148 #endif
2149 break;
2150 case __SI_CHLD:
2151 err |= __put_user(from->si_pid, &to->si_pid);
2152 err |= __put_user(from->si_uid, &to->si_uid);
2153 err |= __put_user(from->si_status, &to->si_status);
2154 err |= __put_user(from->si_utime, &to->si_utime);
2155 err |= __put_user(from->si_stime, &to->si_stime);
2156 break;
2157 case __SI_RT: /* This is not generated by the kernel as of now. */
2158 case __SI_MESGQ: /* But this is */
2159 err |= __put_user(from->si_pid, &to->si_pid);
2160 err |= __put_user(from->si_uid, &to->si_uid);
2161 err |= __put_user(from->si_ptr, &to->si_ptr);
2162 break;
2163 default: /* this is just in case for now ... */
2164 err |= __put_user(from->si_pid, &to->si_pid);
2165 err |= __put_user(from->si_uid, &to->si_uid);
2166 break;
2168 return err;
2171 #endif
2173 asmlinkage long
2174 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2175 siginfo_t __user *uinfo,
2176 const struct timespec __user *uts,
2177 size_t sigsetsize)
2179 int ret, sig;
2180 sigset_t these;
2181 struct timespec ts;
2182 siginfo_t info;
2183 long timeout = 0;
2185 /* XXX: Don't preclude handling different sized sigset_t's. */
2186 if (sigsetsize != sizeof(sigset_t))
2187 return -EINVAL;
2189 if (copy_from_user(&these, uthese, sizeof(these)))
2190 return -EFAULT;
2193 * Invert the set of allowed signals to get those we
2194 * want to block.
2196 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2197 signotset(&these);
2199 if (uts) {
2200 if (copy_from_user(&ts, uts, sizeof(ts)))
2201 return -EFAULT;
2202 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2203 || ts.tv_sec < 0)
2204 return -EINVAL;
2207 spin_lock_irq(&current->sighand->siglock);
2208 sig = dequeue_signal(current, &these, &info);
2209 if (!sig) {
2210 timeout = MAX_SCHEDULE_TIMEOUT;
2211 if (uts)
2212 timeout = (timespec_to_jiffies(&ts)
2213 + (ts.tv_sec || ts.tv_nsec));
2215 if (timeout) {
2216 /* None ready -- temporarily unblock those we're
2217 * interested while we are sleeping in so that we'll
2218 * be awakened when they arrive. */
2219 current->real_blocked = current->blocked;
2220 sigandsets(&current->blocked, &current->blocked, &these);
2221 recalc_sigpending();
2222 spin_unlock_irq(&current->sighand->siglock);
2224 timeout = schedule_timeout_interruptible(timeout);
2226 try_to_freeze();
2227 spin_lock_irq(&current->sighand->siglock);
2228 sig = dequeue_signal(current, &these, &info);
2229 current->blocked = current->real_blocked;
2230 siginitset(&current->real_blocked, 0);
2231 recalc_sigpending();
2234 spin_unlock_irq(&current->sighand->siglock);
2236 if (sig) {
2237 ret = sig;
2238 if (uinfo) {
2239 if (copy_siginfo_to_user(uinfo, &info))
2240 ret = -EFAULT;
2242 } else {
2243 ret = -EAGAIN;
2244 if (timeout)
2245 ret = -EINTR;
2248 return ret;
2251 asmlinkage long
2252 sys_kill(int pid, int sig)
2254 struct siginfo info;
2256 info.si_signo = sig;
2257 info.si_errno = 0;
2258 info.si_code = SI_USER;
2259 info.si_pid = current->tgid;
2260 info.si_uid = current->uid;
2262 return kill_something_info(sig, &info, pid);
2266 * sys_tgkill - send signal to one specific thread
2267 * @tgid: the thread group ID of the thread
2268 * @pid: the PID of the thread
2269 * @sig: signal to be sent
2271 * This syscall also checks the tgid and returns -ESRCH even if the PID
2272 * exists but it's not belonging to the target process anymore. This
2273 * method solves the problem of threads exiting and PIDs getting reused.
2275 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2277 struct siginfo info;
2278 int error;
2279 struct task_struct *p;
2281 /* This is only valid for single tasks */
2282 if (pid <= 0 || tgid <= 0)
2283 return -EINVAL;
2285 info.si_signo = sig;
2286 info.si_errno = 0;
2287 info.si_code = SI_TKILL;
2288 info.si_pid = current->tgid;
2289 info.si_uid = current->uid;
2291 read_lock(&tasklist_lock);
2292 p = find_task_by_pid(pid);
2293 error = -ESRCH;
2294 if (p && (p->tgid == tgid)) {
2295 error = check_kill_permission(sig, &info, p);
2297 * The null signal is a permissions and process existence
2298 * probe. No signal is actually delivered.
2300 if (!error && sig && p->sighand) {
2301 spin_lock_irq(&p->sighand->siglock);
2302 handle_stop_signal(sig, p);
2303 error = specific_send_sig_info(sig, &info, p);
2304 spin_unlock_irq(&p->sighand->siglock);
2307 read_unlock(&tasklist_lock);
2308 return error;
2312 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2314 asmlinkage long
2315 sys_tkill(int pid, int sig)
2317 struct siginfo info;
2318 int error;
2319 struct task_struct *p;
2321 /* This is only valid for single tasks */
2322 if (pid <= 0)
2323 return -EINVAL;
2325 info.si_signo = sig;
2326 info.si_errno = 0;
2327 info.si_code = SI_TKILL;
2328 info.si_pid = current->tgid;
2329 info.si_uid = current->uid;
2331 read_lock(&tasklist_lock);
2332 p = find_task_by_pid(pid);
2333 error = -ESRCH;
2334 if (p) {
2335 error = check_kill_permission(sig, &info, p);
2337 * The null signal is a permissions and process existence
2338 * probe. No signal is actually delivered.
2340 if (!error && sig && p->sighand) {
2341 spin_lock_irq(&p->sighand->siglock);
2342 handle_stop_signal(sig, p);
2343 error = specific_send_sig_info(sig, &info, p);
2344 spin_unlock_irq(&p->sighand->siglock);
2347 read_unlock(&tasklist_lock);
2348 return error;
2351 asmlinkage long
2352 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2354 siginfo_t info;
2356 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2357 return -EFAULT;
2359 /* Not even root can pretend to send signals from the kernel.
2360 Nor can they impersonate a kill(), which adds source info. */
2361 if (info.si_code >= 0)
2362 return -EPERM;
2363 info.si_signo = sig;
2365 /* POSIX.1b doesn't mention process groups. */
2366 return kill_proc_info(sig, &info, pid);
2370 do_sigaction(int sig, const struct k_sigaction *act, struct k_sigaction *oact)
2372 struct k_sigaction *k;
2374 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2375 return -EINVAL;
2377 k = &current->sighand->action[sig-1];
2379 spin_lock_irq(&current->sighand->siglock);
2380 if (signal_pending(current)) {
2382 * If there might be a fatal signal pending on multiple
2383 * threads, make sure we take it before changing the action.
2385 spin_unlock_irq(&current->sighand->siglock);
2386 return -ERESTARTNOINTR;
2389 if (oact)
2390 *oact = *k;
2392 if (act) {
2394 * POSIX 3.3.1.3:
2395 * "Setting a signal action to SIG_IGN for a signal that is
2396 * pending shall cause the pending signal to be discarded,
2397 * whether or not it is blocked."
2399 * "Setting a signal action to SIG_DFL for a signal that is
2400 * pending and whose default action is to ignore the signal
2401 * (for example, SIGCHLD), shall cause the pending signal to
2402 * be discarded, whether or not it is blocked"
2404 if (act->sa.sa_handler == SIG_IGN ||
2405 (act->sa.sa_handler == SIG_DFL &&
2406 sig_kernel_ignore(sig))) {
2408 * This is a fairly rare case, so we only take the
2409 * tasklist_lock once we're sure we'll need it.
2410 * Now we must do this little unlock and relock
2411 * dance to maintain the lock hierarchy.
2413 struct task_struct *t = current;
2414 spin_unlock_irq(&t->sighand->siglock);
2415 read_lock(&tasklist_lock);
2416 spin_lock_irq(&t->sighand->siglock);
2417 *k = *act;
2418 sigdelsetmask(&k->sa.sa_mask,
2419 sigmask(SIGKILL) | sigmask(SIGSTOP));
2420 rm_from_queue(sigmask(sig), &t->signal->shared_pending);
2421 do {
2422 rm_from_queue(sigmask(sig), &t->pending);
2423 recalc_sigpending_tsk(t);
2424 t = next_thread(t);
2425 } while (t != current);
2426 spin_unlock_irq(&current->sighand->siglock);
2427 read_unlock(&tasklist_lock);
2428 return 0;
2431 *k = *act;
2432 sigdelsetmask(&k->sa.sa_mask,
2433 sigmask(SIGKILL) | sigmask(SIGSTOP));
2436 spin_unlock_irq(&current->sighand->siglock);
2437 return 0;
2440 int
2441 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2443 stack_t oss;
2444 int error;
2446 if (uoss) {
2447 oss.ss_sp = (void __user *) current->sas_ss_sp;
2448 oss.ss_size = current->sas_ss_size;
2449 oss.ss_flags = sas_ss_flags(sp);
2452 if (uss) {
2453 void __user *ss_sp;
2454 size_t ss_size;
2455 int ss_flags;
2457 error = -EFAULT;
2458 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2459 || __get_user(ss_sp, &uss->ss_sp)
2460 || __get_user(ss_flags, &uss->ss_flags)
2461 || __get_user(ss_size, &uss->ss_size))
2462 goto out;
2464 error = -EPERM;
2465 if (on_sig_stack(sp))
2466 goto out;
2468 error = -EINVAL;
2471 * Note - this code used to test ss_flags incorrectly
2472 * old code may have been written using ss_flags==0
2473 * to mean ss_flags==SS_ONSTACK (as this was the only
2474 * way that worked) - this fix preserves that older
2475 * mechanism
2477 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2478 goto out;
2480 if (ss_flags == SS_DISABLE) {
2481 ss_size = 0;
2482 ss_sp = NULL;
2483 } else {
2484 error = -ENOMEM;
2485 if (ss_size < MINSIGSTKSZ)
2486 goto out;
2489 current->sas_ss_sp = (unsigned long) ss_sp;
2490 current->sas_ss_size = ss_size;
2493 if (uoss) {
2494 error = -EFAULT;
2495 if (copy_to_user(uoss, &oss, sizeof(oss)))
2496 goto out;
2499 error = 0;
2500 out:
2501 return error;
2504 #ifdef __ARCH_WANT_SYS_SIGPENDING
2506 asmlinkage long
2507 sys_sigpending(old_sigset_t __user *set)
2509 return do_sigpending(set, sizeof(*set));
2512 #endif
2514 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2515 /* Some platforms have their own version with special arguments others
2516 support only sys_rt_sigprocmask. */
2518 asmlinkage long
2519 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2521 int error;
2522 old_sigset_t old_set, new_set;
2524 if (set) {
2525 error = -EFAULT;
2526 if (copy_from_user(&new_set, set, sizeof(*set)))
2527 goto out;
2528 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2530 spin_lock_irq(&current->sighand->siglock);
2531 old_set = current->blocked.sig[0];
2533 error = 0;
2534 switch (how) {
2535 default:
2536 error = -EINVAL;
2537 break;
2538 case SIG_BLOCK:
2539 sigaddsetmask(&current->blocked, new_set);
2540 break;
2541 case SIG_UNBLOCK:
2542 sigdelsetmask(&current->blocked, new_set);
2543 break;
2544 case SIG_SETMASK:
2545 current->blocked.sig[0] = new_set;
2546 break;
2549 recalc_sigpending();
2550 spin_unlock_irq(&current->sighand->siglock);
2551 if (error)
2552 goto out;
2553 if (oset)
2554 goto set_old;
2555 } else if (oset) {
2556 old_set = current->blocked.sig[0];
2557 set_old:
2558 error = -EFAULT;
2559 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2560 goto out;
2562 error = 0;
2563 out:
2564 return error;
2566 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2568 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2569 asmlinkage long
2570 sys_rt_sigaction(int sig,
2571 const struct sigaction __user *act,
2572 struct sigaction __user *oact,
2573 size_t sigsetsize)
2575 struct k_sigaction new_sa, old_sa;
2576 int ret = -EINVAL;
2578 /* XXX: Don't preclude handling different sized sigset_t's. */
2579 if (sigsetsize != sizeof(sigset_t))
2580 goto out;
2582 if (act) {
2583 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2584 return -EFAULT;
2587 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2589 if (!ret && oact) {
2590 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2591 return -EFAULT;
2593 out:
2594 return ret;
2596 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2598 #ifdef __ARCH_WANT_SYS_SGETMASK
2601 * For backwards compatibility. Functionality superseded by sigprocmask.
2603 asmlinkage long
2604 sys_sgetmask(void)
2606 /* SMP safe */
2607 return current->blocked.sig[0];
2610 asmlinkage long
2611 sys_ssetmask(int newmask)
2613 int old;
2615 spin_lock_irq(&current->sighand->siglock);
2616 old = current->blocked.sig[0];
2618 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2619 sigmask(SIGSTOP)));
2620 recalc_sigpending();
2621 spin_unlock_irq(&current->sighand->siglock);
2623 return old;
2625 #endif /* __ARCH_WANT_SGETMASK */
2627 #ifdef __ARCH_WANT_SYS_SIGNAL
2629 * For backwards compatibility. Functionality superseded by sigaction.
2631 asmlinkage unsigned long
2632 sys_signal(int sig, __sighandler_t handler)
2634 struct k_sigaction new_sa, old_sa;
2635 int ret;
2637 new_sa.sa.sa_handler = handler;
2638 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2640 ret = do_sigaction(sig, &new_sa, &old_sa);
2642 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2644 #endif /* __ARCH_WANT_SYS_SIGNAL */
2646 #ifdef __ARCH_WANT_SYS_PAUSE
2648 asmlinkage long
2649 sys_pause(void)
2651 current->state = TASK_INTERRUPTIBLE;
2652 schedule();
2653 return -ERESTARTNOHAND;
2656 #endif
2658 void __init signals_init(void)
2660 sigqueue_cachep =
2661 kmem_cache_create("sigqueue",
2662 sizeof(struct sigqueue),
2663 __alignof__(struct sigqueue),
2664 SLAB_PANIC, NULL, NULL);