signals: consolidate checking for ignored/legacy signals
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / kernel / signal.c
blobfb8ffd46885429ab9e0b4b860d3254e2b6909bc4
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/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>
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() */
37 * SLAB caches for signal bits.
40 static struct kmem_cache *sigqueue_cachep;
43 static int sig_ignored(struct task_struct *t, int sig)
45 void __user * handler;
48 * Tracers always want to know about signals..
50 if (t->ptrace & PT_PTRACED)
51 return 0;
54 * Blocked signals are never ignored, since the
55 * signal handler may change by the time it is
56 * unblocked.
58 if (sigismember(&t->blocked, sig) || sigismember(&t->real_blocked, sig))
59 return 0;
61 /* Is it explicitly or implicitly ignored? */
62 handler = t->sighand->action[sig-1].sa.sa_handler;
63 return handler == SIG_IGN ||
64 (handler == SIG_DFL && sig_kernel_ignore(sig));
68 * Re-calculate pending state from the set of locally pending
69 * signals, globally pending signals, and blocked signals.
71 static inline int has_pending_signals(sigset_t *signal, sigset_t *blocked)
73 unsigned long ready;
74 long i;
76 switch (_NSIG_WORDS) {
77 default:
78 for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;)
79 ready |= signal->sig[i] &~ blocked->sig[i];
80 break;
82 case 4: ready = signal->sig[3] &~ blocked->sig[3];
83 ready |= signal->sig[2] &~ blocked->sig[2];
84 ready |= signal->sig[1] &~ blocked->sig[1];
85 ready |= signal->sig[0] &~ blocked->sig[0];
86 break;
88 case 2: ready = signal->sig[1] &~ blocked->sig[1];
89 ready |= signal->sig[0] &~ blocked->sig[0];
90 break;
92 case 1: ready = signal->sig[0] &~ blocked->sig[0];
94 return ready != 0;
97 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
99 static int recalc_sigpending_tsk(struct task_struct *t)
101 if (t->signal->group_stop_count > 0 ||
102 PENDING(&t->pending, &t->blocked) ||
103 PENDING(&t->signal->shared_pending, &t->blocked)) {
104 set_tsk_thread_flag(t, TIF_SIGPENDING);
105 return 1;
108 * We must never clear the flag in another thread, or in current
109 * when it's possible the current syscall is returning -ERESTART*.
110 * So we don't clear it here, and only callers who know they should do.
112 return 0;
116 * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up.
117 * This is superfluous when called on current, the wakeup is a harmless no-op.
119 void recalc_sigpending_and_wake(struct task_struct *t)
121 if (recalc_sigpending_tsk(t))
122 signal_wake_up(t, 0);
125 void recalc_sigpending(void)
127 if (!recalc_sigpending_tsk(current) && !freezing(current))
128 clear_thread_flag(TIF_SIGPENDING);
132 /* Given the mask, find the first available signal that should be serviced. */
134 int next_signal(struct sigpending *pending, sigset_t *mask)
136 unsigned long i, *s, *m, x;
137 int sig = 0;
139 s = pending->signal.sig;
140 m = mask->sig;
141 switch (_NSIG_WORDS) {
142 default:
143 for (i = 0; i < _NSIG_WORDS; ++i, ++s, ++m)
144 if ((x = *s &~ *m) != 0) {
145 sig = ffz(~x) + i*_NSIG_BPW + 1;
146 break;
148 break;
150 case 2: if ((x = s[0] &~ m[0]) != 0)
151 sig = 1;
152 else if ((x = s[1] &~ m[1]) != 0)
153 sig = _NSIG_BPW + 1;
154 else
155 break;
156 sig += ffz(~x);
157 break;
159 case 1: if ((x = *s &~ *m) != 0)
160 sig = ffz(~x) + 1;
161 break;
164 return sig;
167 static struct sigqueue *__sigqueue_alloc(struct task_struct *t, gfp_t flags,
168 int override_rlimit)
170 struct sigqueue *q = NULL;
171 struct user_struct *user;
174 * In order to avoid problems with "switch_user()", we want to make
175 * sure that the compiler doesn't re-load "t->user"
177 user = t->user;
178 barrier();
179 atomic_inc(&user->sigpending);
180 if (override_rlimit ||
181 atomic_read(&user->sigpending) <=
182 t->signal->rlim[RLIMIT_SIGPENDING].rlim_cur)
183 q = kmem_cache_alloc(sigqueue_cachep, flags);
184 if (unlikely(q == NULL)) {
185 atomic_dec(&user->sigpending);
186 } else {
187 INIT_LIST_HEAD(&q->list);
188 q->flags = 0;
189 q->user = get_uid(user);
191 return(q);
194 static void __sigqueue_free(struct sigqueue *q)
196 if (q->flags & SIGQUEUE_PREALLOC)
197 return;
198 atomic_dec(&q->user->sigpending);
199 free_uid(q->user);
200 kmem_cache_free(sigqueue_cachep, q);
203 void flush_sigqueue(struct sigpending *queue)
205 struct sigqueue *q;
207 sigemptyset(&queue->signal);
208 while (!list_empty(&queue->list)) {
209 q = list_entry(queue->list.next, struct sigqueue , list);
210 list_del_init(&q->list);
211 __sigqueue_free(q);
216 * Flush all pending signals for a task.
218 void flush_signals(struct task_struct *t)
220 unsigned long flags;
222 spin_lock_irqsave(&t->sighand->siglock, flags);
223 clear_tsk_thread_flag(t, TIF_SIGPENDING);
224 flush_sigqueue(&t->pending);
225 flush_sigqueue(&t->signal->shared_pending);
226 spin_unlock_irqrestore(&t->sighand->siglock, flags);
229 void ignore_signals(struct task_struct *t)
231 int i;
233 for (i = 0; i < _NSIG; ++i)
234 t->sighand->action[i].sa.sa_handler = SIG_IGN;
236 flush_signals(t);
240 * Flush all handlers for a task.
243 void
244 flush_signal_handlers(struct task_struct *t, int force_default)
246 int i;
247 struct k_sigaction *ka = &t->sighand->action[0];
248 for (i = _NSIG ; i != 0 ; i--) {
249 if (force_default || ka->sa.sa_handler != SIG_IGN)
250 ka->sa.sa_handler = SIG_DFL;
251 ka->sa.sa_flags = 0;
252 sigemptyset(&ka->sa.sa_mask);
253 ka++;
257 int unhandled_signal(struct task_struct *tsk, int sig)
259 if (is_global_init(tsk))
260 return 1;
261 if (tsk->ptrace & PT_PTRACED)
262 return 0;
263 return (tsk->sighand->action[sig-1].sa.sa_handler == SIG_IGN) ||
264 (tsk->sighand->action[sig-1].sa.sa_handler == SIG_DFL);
268 /* Notify the system that a driver wants to block all signals for this
269 * process, and wants to be notified if any signals at all were to be
270 * sent/acted upon. If the notifier routine returns non-zero, then the
271 * signal will be acted upon after all. If the notifier routine returns 0,
272 * then then signal will be blocked. Only one block per process is
273 * allowed. priv is a pointer to private data that the notifier routine
274 * can use to determine if the signal should be blocked or not. */
276 void
277 block_all_signals(int (*notifier)(void *priv), void *priv, sigset_t *mask)
279 unsigned long flags;
281 spin_lock_irqsave(&current->sighand->siglock, flags);
282 current->notifier_mask = mask;
283 current->notifier_data = priv;
284 current->notifier = notifier;
285 spin_unlock_irqrestore(&current->sighand->siglock, flags);
288 /* Notify the system that blocking has ended. */
290 void
291 unblock_all_signals(void)
293 unsigned long flags;
295 spin_lock_irqsave(&current->sighand->siglock, flags);
296 current->notifier = NULL;
297 current->notifier_data = NULL;
298 recalc_sigpending();
299 spin_unlock_irqrestore(&current->sighand->siglock, flags);
302 static int collect_signal(int sig, struct sigpending *list, siginfo_t *info)
304 struct sigqueue *q, *first = NULL;
305 int still_pending = 0;
307 if (unlikely(!sigismember(&list->signal, sig)))
308 return 0;
311 * Collect the siginfo appropriate to this signal. Check if
312 * there is another siginfo for the same signal.
314 list_for_each_entry(q, &list->list, list) {
315 if (q->info.si_signo == sig) {
316 if (first) {
317 still_pending = 1;
318 break;
320 first = q;
323 if (first) {
324 list_del_init(&first->list);
325 copy_siginfo(info, &first->info);
326 __sigqueue_free(first);
327 if (!still_pending)
328 sigdelset(&list->signal, sig);
329 } else {
331 /* Ok, it wasn't in the queue. This must be
332 a fast-pathed signal or we must have been
333 out of queue space. So zero out the info.
335 sigdelset(&list->signal, sig);
336 info->si_signo = sig;
337 info->si_errno = 0;
338 info->si_code = 0;
339 info->si_pid = 0;
340 info->si_uid = 0;
342 return 1;
345 static int __dequeue_signal(struct sigpending *pending, sigset_t *mask,
346 siginfo_t *info)
348 int sig = next_signal(pending, mask);
350 if (sig) {
351 if (current->notifier) {
352 if (sigismember(current->notifier_mask, sig)) {
353 if (!(current->notifier)(current->notifier_data)) {
354 clear_thread_flag(TIF_SIGPENDING);
355 return 0;
360 if (!collect_signal(sig, pending, info))
361 sig = 0;
364 return sig;
368 * Dequeue a signal and return the element to the caller, which is
369 * expected to free it.
371 * All callers have to hold the siglock.
373 int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
375 int signr = 0;
377 /* We only dequeue private signals from ourselves, we don't let
378 * signalfd steal them
380 signr = __dequeue_signal(&tsk->pending, mask, info);
381 if (!signr) {
382 signr = __dequeue_signal(&tsk->signal->shared_pending,
383 mask, info);
385 * itimer signal ?
387 * itimers are process shared and we restart periodic
388 * itimers in the signal delivery path to prevent DoS
389 * attacks in the high resolution timer case. This is
390 * compliant with the old way of self restarting
391 * itimers, as the SIGALRM is a legacy signal and only
392 * queued once. Changing the restart behaviour to
393 * restart the timer in the signal dequeue path is
394 * reducing the timer noise on heavy loaded !highres
395 * systems too.
397 if (unlikely(signr == SIGALRM)) {
398 struct hrtimer *tmr = &tsk->signal->real_timer;
400 if (!hrtimer_is_queued(tmr) &&
401 tsk->signal->it_real_incr.tv64 != 0) {
402 hrtimer_forward(tmr, tmr->base->get_time(),
403 tsk->signal->it_real_incr);
404 hrtimer_restart(tmr);
408 recalc_sigpending();
409 if (signr && unlikely(sig_kernel_stop(signr))) {
411 * Set a marker that we have dequeued a stop signal. Our
412 * caller might release the siglock and then the pending
413 * stop signal it is about to process is no longer in the
414 * pending bitmasks, but must still be cleared by a SIGCONT
415 * (and overruled by a SIGKILL). So those cases clear this
416 * shared flag after we've set it. Note that this flag may
417 * remain set after the signal we return is ignored or
418 * handled. That doesn't matter because its only purpose
419 * is to alert stop-signal processing code when another
420 * processor has come along and cleared the flag.
422 if (!(tsk->signal->flags & SIGNAL_GROUP_EXIT))
423 tsk->signal->flags |= SIGNAL_STOP_DEQUEUED;
425 if (signr &&
426 ((info->si_code & __SI_MASK) == __SI_TIMER) &&
427 info->si_sys_private) {
429 * Release the siglock to ensure proper locking order
430 * of timer locks outside of siglocks. Note, we leave
431 * irqs disabled here, since the posix-timers code is
432 * about to disable them again anyway.
434 spin_unlock(&tsk->sighand->siglock);
435 do_schedule_next_timer(info);
436 spin_lock(&tsk->sighand->siglock);
438 return signr;
442 * Tell a process that it has a new active signal..
444 * NOTE! we rely on the previous spin_lock to
445 * lock interrupts for us! We can only be called with
446 * "siglock" held, and the local interrupt must
447 * have been disabled when that got acquired!
449 * No need to set need_resched since signal event passing
450 * goes through ->blocked
452 void signal_wake_up(struct task_struct *t, int resume)
454 unsigned int mask;
456 set_tsk_thread_flag(t, TIF_SIGPENDING);
459 * For SIGKILL, we want to wake it up in the stopped/traced/killable
460 * case. We don't check t->state here because there is a race with it
461 * executing another processor and just now entering stopped state.
462 * By using wake_up_state, we ensure the process will wake up and
463 * handle its death signal.
465 mask = TASK_INTERRUPTIBLE;
466 if (resume)
467 mask |= TASK_WAKEKILL;
468 if (!wake_up_state(t, mask))
469 kick_process(t);
473 * Remove signals in mask from the pending set and queue.
474 * Returns 1 if any signals were found.
476 * All callers must be holding the siglock.
478 * This version takes a sigset mask and looks at all signals,
479 * not just those in the first mask word.
481 static int rm_from_queue_full(sigset_t *mask, struct sigpending *s)
483 struct sigqueue *q, *n;
484 sigset_t m;
486 sigandsets(&m, mask, &s->signal);
487 if (sigisemptyset(&m))
488 return 0;
490 signandsets(&s->signal, &s->signal, mask);
491 list_for_each_entry_safe(q, n, &s->list, list) {
492 if (sigismember(mask, q->info.si_signo)) {
493 list_del_init(&q->list);
494 __sigqueue_free(q);
497 return 1;
500 * Remove signals in mask from the pending set and queue.
501 * Returns 1 if any signals were found.
503 * All callers must be holding the siglock.
505 static int rm_from_queue(unsigned long mask, struct sigpending *s)
507 struct sigqueue *q, *n;
509 if (!sigtestsetmask(&s->signal, mask))
510 return 0;
512 sigdelsetmask(&s->signal, mask);
513 list_for_each_entry_safe(q, n, &s->list, list) {
514 if (q->info.si_signo < SIGRTMIN &&
515 (mask & sigmask(q->info.si_signo))) {
516 list_del_init(&q->list);
517 __sigqueue_free(q);
520 return 1;
524 * Bad permissions for sending the signal
526 static int check_kill_permission(int sig, struct siginfo *info,
527 struct task_struct *t)
529 int error = -EINVAL;
530 if (!valid_signal(sig))
531 return error;
533 if (info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info))) {
534 error = audit_signal_info(sig, t); /* Let audit system see the signal */
535 if (error)
536 return error;
537 error = -EPERM;
538 if (((sig != SIGCONT) ||
539 (task_session_nr(current) != task_session_nr(t)))
540 && (current->euid ^ t->suid) && (current->euid ^ t->uid)
541 && (current->uid ^ t->suid) && (current->uid ^ t->uid)
542 && !capable(CAP_KILL))
543 return error;
546 return security_task_kill(t, info, sig, 0);
549 /* forward decl */
550 static void do_notify_parent_cldstop(struct task_struct *tsk, int why);
553 * Handle magic process-wide effects of stop/continue signals.
554 * Unlike the signal actions, these happen immediately at signal-generation
555 * time regardless of blocking, ignoring, or handling. This does the
556 * actual continuing for SIGCONT, but not the actual stopping for stop
557 * signals. The process stop is done as a signal action for SIG_DFL.
559 static void handle_stop_signal(int sig, struct task_struct *p)
561 struct task_struct *t;
563 if (p->signal->flags & SIGNAL_GROUP_EXIT)
565 * The process is in the middle of dying already.
567 return;
569 if (sig_kernel_stop(sig)) {
571 * This is a stop signal. Remove SIGCONT from all queues.
573 rm_from_queue(sigmask(SIGCONT), &p->signal->shared_pending);
574 t = p;
575 do {
576 rm_from_queue(sigmask(SIGCONT), &t->pending);
577 t = next_thread(t);
578 } while (t != p);
579 } else if (sig == SIGCONT) {
581 * Remove all stop signals from all queues,
582 * and wake all threads.
584 if (unlikely(p->signal->group_stop_count > 0)) {
586 * There was a group stop in progress. We'll
587 * pretend it finished before we got here. We are
588 * obliged to report it to the parent: if the
589 * SIGSTOP happened "after" this SIGCONT, then it
590 * would have cleared this pending SIGCONT. If it
591 * happened "before" this SIGCONT, then the parent
592 * got the SIGCHLD about the stop finishing before
593 * the continue happened. We do the notification
594 * now, and it's as if the stop had finished and
595 * the SIGCHLD was pending on entry to this kill.
597 p->signal->group_stop_count = 0;
598 p->signal->flags = SIGNAL_STOP_CONTINUED;
599 spin_unlock(&p->sighand->siglock);
600 do_notify_parent_cldstop(p, CLD_STOPPED);
601 spin_lock(&p->sighand->siglock);
603 rm_from_queue(SIG_KERNEL_STOP_MASK, &p->signal->shared_pending);
604 t = p;
605 do {
606 unsigned int state;
607 rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending);
610 * If there is a handler for SIGCONT, we must make
611 * sure that no thread returns to user mode before
612 * we post the signal, in case it was the only
613 * thread eligible to run the signal handler--then
614 * it must not do anything between resuming and
615 * running the handler. With the TIF_SIGPENDING
616 * flag set, the thread will pause and acquire the
617 * siglock that we hold now and until we've queued
618 * the pending signal.
620 * Wake up the stopped thread _after_ setting
621 * TIF_SIGPENDING
623 state = __TASK_STOPPED;
624 if (sig_user_defined(t, SIGCONT) && !sigismember(&t->blocked, SIGCONT)) {
625 set_tsk_thread_flag(t, TIF_SIGPENDING);
626 state |= TASK_INTERRUPTIBLE;
628 wake_up_state(t, state);
630 t = next_thread(t);
631 } while (t != p);
633 if (p->signal->flags & SIGNAL_STOP_STOPPED) {
635 * We were in fact stopped, and are now continued.
636 * Notify the parent with CLD_CONTINUED.
638 p->signal->flags = SIGNAL_STOP_CONTINUED;
639 p->signal->group_exit_code = 0;
640 spin_unlock(&p->sighand->siglock);
641 do_notify_parent_cldstop(p, CLD_CONTINUED);
642 spin_lock(&p->sighand->siglock);
643 } else {
645 * We are not stopped, but there could be a stop
646 * signal in the middle of being processed after
647 * being removed from the queue. Clear that too.
649 p->signal->flags = 0;
651 } else if (sig == SIGKILL) {
653 * Make sure that any pending stop signal already dequeued
654 * is undone by the wakeup for SIGKILL.
656 p->signal->flags = 0;
660 static inline int legacy_queue(struct sigpending *signals, int sig)
662 return (sig < SIGRTMIN) && sigismember(&signals->signal, sig);
665 static int send_signal(int sig, struct siginfo *info, struct task_struct *t,
666 struct sigpending *signals)
668 struct sigqueue * q = NULL;
671 * Short-circuit ignored signals and support queuing
672 * exactly one non-rt signal, so that we can get more
673 * detailed information about the cause of the signal.
675 if (sig_ignored(t, sig) || legacy_queue(signals, sig))
676 return 0;
679 * Deliver the signal to listening signalfds. This must be called
680 * with the sighand lock held.
682 signalfd_notify(t, sig);
685 * fast-pathed signals for kernel-internal things like SIGSTOP
686 * or SIGKILL.
688 if (info == SEND_SIG_FORCED)
689 goto out_set;
691 /* Real-time signals must be queued if sent by sigqueue, or
692 some other real-time mechanism. It is implementation
693 defined whether kill() does so. We attempt to do so, on
694 the principle of least surprise, but since kill is not
695 allowed to fail with EAGAIN when low on memory we just
696 make sure at least one signal gets delivered and don't
697 pass on the info struct. */
699 q = __sigqueue_alloc(t, GFP_ATOMIC, (sig < SIGRTMIN &&
700 (is_si_special(info) ||
701 info->si_code >= 0)));
702 if (q) {
703 list_add_tail(&q->list, &signals->list);
704 switch ((unsigned long) info) {
705 case (unsigned long) SEND_SIG_NOINFO:
706 q->info.si_signo = sig;
707 q->info.si_errno = 0;
708 q->info.si_code = SI_USER;
709 q->info.si_pid = task_pid_vnr(current);
710 q->info.si_uid = current->uid;
711 break;
712 case (unsigned long) SEND_SIG_PRIV:
713 q->info.si_signo = sig;
714 q->info.si_errno = 0;
715 q->info.si_code = SI_KERNEL;
716 q->info.si_pid = 0;
717 q->info.si_uid = 0;
718 break;
719 default:
720 copy_siginfo(&q->info, info);
721 break;
723 } else if (!is_si_special(info)) {
724 if (sig >= SIGRTMIN && info->si_code != SI_USER)
726 * Queue overflow, abort. We may abort if the signal was rt
727 * and sent by user using something other than kill().
729 return -EAGAIN;
732 out_set:
733 sigaddset(&signals->signal, sig);
734 return 1;
737 int print_fatal_signals;
739 static void print_fatal_signal(struct pt_regs *regs, int signr)
741 printk("%s/%d: potentially unexpected fatal signal %d.\n",
742 current->comm, task_pid_nr(current), signr);
744 #if defined(__i386__) && !defined(__arch_um__)
745 printk("code at %08lx: ", regs->ip);
747 int i;
748 for (i = 0; i < 16; i++) {
749 unsigned char insn;
751 __get_user(insn, (unsigned char *)(regs->ip + i));
752 printk("%02x ", insn);
755 #endif
756 printk("\n");
757 show_regs(regs);
760 static int __init setup_print_fatal_signals(char *str)
762 get_option (&str, &print_fatal_signals);
764 return 1;
767 __setup("print-fatal-signals=", setup_print_fatal_signals);
769 static int
770 specific_send_sig_info(int sig, struct siginfo *info, struct task_struct *t)
772 int ret;
774 BUG_ON(!irqs_disabled());
775 assert_spin_locked(&t->sighand->siglock);
777 ret = send_signal(sig, info, t, &t->pending);
778 if (ret <= 0)
779 return ret;
781 if (!sigismember(&t->blocked, sig))
782 signal_wake_up(t, sig == SIGKILL);
783 return 0;
787 * Force a signal that the process can't ignore: if necessary
788 * we unblock the signal and change any SIG_IGN to SIG_DFL.
790 * Note: If we unblock the signal, we always reset it to SIG_DFL,
791 * since we do not want to have a signal handler that was blocked
792 * be invoked when user space had explicitly blocked it.
794 * We don't want to have recursive SIGSEGV's etc, for example.
797 force_sig_info(int sig, struct siginfo *info, struct task_struct *t)
799 unsigned long int flags;
800 int ret, blocked, ignored;
801 struct k_sigaction *action;
803 spin_lock_irqsave(&t->sighand->siglock, flags);
804 action = &t->sighand->action[sig-1];
805 ignored = action->sa.sa_handler == SIG_IGN;
806 blocked = sigismember(&t->blocked, sig);
807 if (blocked || ignored) {
808 action->sa.sa_handler = SIG_DFL;
809 if (blocked) {
810 sigdelset(&t->blocked, sig);
811 recalc_sigpending_and_wake(t);
814 ret = specific_send_sig_info(sig, info, t);
815 spin_unlock_irqrestore(&t->sighand->siglock, flags);
817 return ret;
820 void
821 force_sig_specific(int sig, struct task_struct *t)
823 force_sig_info(sig, SEND_SIG_FORCED, t);
827 * Test if P wants to take SIG. After we've checked all threads with this,
828 * it's equivalent to finding no threads not blocking SIG. Any threads not
829 * blocking SIG were ruled out because they are not running and already
830 * have pending signals. Such threads will dequeue from the shared queue
831 * as soon as they're available, so putting the signal on the shared queue
832 * will be equivalent to sending it to one such thread.
834 static inline int wants_signal(int sig, struct task_struct *p)
836 if (sigismember(&p->blocked, sig))
837 return 0;
838 if (p->flags & PF_EXITING)
839 return 0;
840 if (sig == SIGKILL)
841 return 1;
842 if (task_is_stopped_or_traced(p))
843 return 0;
844 return task_curr(p) || !signal_pending(p);
847 static void
848 __group_complete_signal(int sig, struct task_struct *p)
850 struct task_struct *t;
853 * Now find a thread we can wake up to take the signal off the queue.
855 * If the main thread wants the signal, it gets first crack.
856 * Probably the least surprising to the average bear.
858 if (wants_signal(sig, p))
859 t = p;
860 else if (thread_group_empty(p))
862 * There is just one thread and it does not need to be woken.
863 * It will dequeue unblocked signals before it runs again.
865 return;
866 else {
868 * Otherwise try to find a suitable thread.
870 t = p->signal->curr_target;
871 if (t == NULL)
872 /* restart balancing at this thread */
873 t = p->signal->curr_target = p;
875 while (!wants_signal(sig, t)) {
876 t = next_thread(t);
877 if (t == p->signal->curr_target)
879 * No thread needs to be woken.
880 * Any eligible threads will see
881 * the signal in the queue soon.
883 return;
885 p->signal->curr_target = t;
889 * Found a killable thread. If the signal will be fatal,
890 * then start taking the whole group down immediately.
892 if (sig_fatal(p, sig) && !(p->signal->flags & SIGNAL_GROUP_EXIT) &&
893 !sigismember(&t->real_blocked, sig) &&
894 (sig == SIGKILL || !(t->ptrace & PT_PTRACED))) {
896 * This signal will be fatal to the whole group.
898 if (!sig_kernel_coredump(sig)) {
900 * Start a group exit and wake everybody up.
901 * This way we don't have other threads
902 * running and doing things after a slower
903 * thread has the fatal signal pending.
905 p->signal->flags = SIGNAL_GROUP_EXIT;
906 p->signal->group_exit_code = sig;
907 p->signal->group_stop_count = 0;
908 t = p;
909 do {
910 sigaddset(&t->pending.signal, SIGKILL);
911 signal_wake_up(t, 1);
912 } while_each_thread(p, t);
913 return;
918 * The signal is already in the shared-pending queue.
919 * Tell the chosen thread to wake up and dequeue it.
921 signal_wake_up(t, sig == SIGKILL);
922 return;
926 __group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
928 int ret;
930 assert_spin_locked(&p->sighand->siglock);
931 handle_stop_signal(sig, p);
934 * Put this signal on the shared-pending queue, or fail with EAGAIN.
935 * We always use the shared queue for process-wide signals,
936 * to avoid several races.
938 ret = send_signal(sig, info, p, &p->signal->shared_pending);
939 if (ret <= 0)
940 return ret;
942 __group_complete_signal(sig, p);
943 return 0;
947 * Nuke all other threads in the group.
949 void zap_other_threads(struct task_struct *p)
951 struct task_struct *t;
953 p->signal->group_stop_count = 0;
955 for (t = next_thread(p); t != p; t = next_thread(t)) {
957 * Don't bother with already dead threads
959 if (t->exit_state)
960 continue;
962 /* SIGKILL will be handled before any pending SIGSTOP */
963 sigaddset(&t->pending.signal, SIGKILL);
964 signal_wake_up(t, 1);
968 int __fatal_signal_pending(struct task_struct *tsk)
970 return sigismember(&tsk->pending.signal, SIGKILL);
972 EXPORT_SYMBOL(__fatal_signal_pending);
975 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
977 struct sighand_struct *lock_task_sighand(struct task_struct *tsk, unsigned long *flags)
979 struct sighand_struct *sighand;
981 for (;;) {
982 sighand = rcu_dereference(tsk->sighand);
983 if (unlikely(sighand == NULL))
984 break;
986 spin_lock_irqsave(&sighand->siglock, *flags);
987 if (likely(sighand == tsk->sighand))
988 break;
989 spin_unlock_irqrestore(&sighand->siglock, *flags);
992 return sighand;
995 int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
997 unsigned long flags;
998 int ret;
1000 ret = check_kill_permission(sig, info, p);
1002 if (!ret && sig) {
1003 ret = -ESRCH;
1004 if (lock_task_sighand(p, &flags)) {
1005 ret = __group_send_sig_info(sig, info, p);
1006 unlock_task_sighand(p, &flags);
1010 return ret;
1014 * __kill_pgrp_info() sends a signal to a process group: this is what the tty
1015 * control characters do (^C, ^Z etc)
1018 int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
1020 struct task_struct *p = NULL;
1021 int retval, success;
1023 success = 0;
1024 retval = -ESRCH;
1025 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
1026 int err = group_send_sig_info(sig, info, p);
1027 success |= !err;
1028 retval = err;
1029 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
1030 return success ? 0 : retval;
1033 int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
1035 int error = -ESRCH;
1036 struct task_struct *p;
1038 rcu_read_lock();
1039 if (unlikely(sig_needs_tasklist(sig)))
1040 read_lock(&tasklist_lock);
1042 retry:
1043 p = pid_task(pid, PIDTYPE_PID);
1044 if (p) {
1045 error = group_send_sig_info(sig, info, p);
1046 if (unlikely(error == -ESRCH))
1048 * The task was unhashed in between, try again.
1049 * If it is dead, pid_task() will return NULL,
1050 * if we race with de_thread() it will find the
1051 * new leader.
1053 goto retry;
1056 if (unlikely(sig_needs_tasklist(sig)))
1057 read_unlock(&tasklist_lock);
1058 rcu_read_unlock();
1059 return error;
1063 kill_proc_info(int sig, struct siginfo *info, pid_t pid)
1065 int error;
1066 rcu_read_lock();
1067 error = kill_pid_info(sig, info, find_vpid(pid));
1068 rcu_read_unlock();
1069 return error;
1072 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1073 int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
1074 uid_t uid, uid_t euid, u32 secid)
1076 int ret = -EINVAL;
1077 struct task_struct *p;
1079 if (!valid_signal(sig))
1080 return ret;
1082 read_lock(&tasklist_lock);
1083 p = pid_task(pid, PIDTYPE_PID);
1084 if (!p) {
1085 ret = -ESRCH;
1086 goto out_unlock;
1088 if ((info == SEND_SIG_NOINFO || (!is_si_special(info) && SI_FROMUSER(info)))
1089 && (euid != p->suid) && (euid != p->uid)
1090 && (uid != p->suid) && (uid != p->uid)) {
1091 ret = -EPERM;
1092 goto out_unlock;
1094 ret = security_task_kill(p, info, sig, secid);
1095 if (ret)
1096 goto out_unlock;
1097 if (sig && p->sighand) {
1098 unsigned long flags;
1099 spin_lock_irqsave(&p->sighand->siglock, flags);
1100 ret = __group_send_sig_info(sig, info, p);
1101 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1103 out_unlock:
1104 read_unlock(&tasklist_lock);
1105 return ret;
1107 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid);
1110 * kill_something_info() interprets pid in interesting ways just like kill(2).
1112 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1113 * is probably wrong. Should make it like BSD or SYSV.
1116 static int kill_something_info(int sig, struct siginfo *info, int pid)
1118 int ret;
1120 if (pid > 0) {
1121 rcu_read_lock();
1122 ret = kill_pid_info(sig, info, find_vpid(pid));
1123 rcu_read_unlock();
1124 return ret;
1127 read_lock(&tasklist_lock);
1128 if (pid != -1) {
1129 ret = __kill_pgrp_info(sig, info,
1130 pid ? find_vpid(-pid) : task_pgrp(current));
1131 } else {
1132 int retval = 0, count = 0;
1133 struct task_struct * p;
1135 for_each_process(p) {
1136 if (p->pid > 1 && !same_thread_group(p, current)) {
1137 int err = group_send_sig_info(sig, info, p);
1138 ++count;
1139 if (err != -EPERM)
1140 retval = err;
1143 ret = count ? retval : -ESRCH;
1145 read_unlock(&tasklist_lock);
1147 return ret;
1151 * These are for backward compatibility with the rest of the kernel source.
1155 * These two are the most common entry points. They send a signal
1156 * just to the specific thread.
1159 send_sig_info(int sig, struct siginfo *info, struct task_struct *p)
1161 int ret;
1162 unsigned long flags;
1165 * Make sure legacy kernel users don't send in bad values
1166 * (normal paths check this in check_kill_permission).
1168 if (!valid_signal(sig))
1169 return -EINVAL;
1172 * We need the tasklist lock even for the specific
1173 * thread case (when we don't need to follow the group
1174 * lists) in order to avoid races with "p->sighand"
1175 * going away or changing from under us.
1177 read_lock(&tasklist_lock);
1178 spin_lock_irqsave(&p->sighand->siglock, flags);
1179 ret = specific_send_sig_info(sig, info, p);
1180 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1181 read_unlock(&tasklist_lock);
1182 return ret;
1185 #define __si_special(priv) \
1186 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1189 send_sig(int sig, struct task_struct *p, int priv)
1191 return send_sig_info(sig, __si_special(priv), p);
1194 void
1195 force_sig(int sig, struct task_struct *p)
1197 force_sig_info(sig, SEND_SIG_PRIV, p);
1201 * When things go south during signal handling, we
1202 * will force a SIGSEGV. And if the signal that caused
1203 * the problem was already a SIGSEGV, we'll want to
1204 * make sure we don't even try to deliver the signal..
1207 force_sigsegv(int sig, struct task_struct *p)
1209 if (sig == SIGSEGV) {
1210 unsigned long flags;
1211 spin_lock_irqsave(&p->sighand->siglock, flags);
1212 p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL;
1213 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1215 force_sig(SIGSEGV, p);
1216 return 0;
1219 int kill_pgrp(struct pid *pid, int sig, int priv)
1221 int ret;
1223 read_lock(&tasklist_lock);
1224 ret = __kill_pgrp_info(sig, __si_special(priv), pid);
1225 read_unlock(&tasklist_lock);
1227 return ret;
1229 EXPORT_SYMBOL(kill_pgrp);
1231 int kill_pid(struct pid *pid, int sig, int priv)
1233 return kill_pid_info(sig, __si_special(priv), pid);
1235 EXPORT_SYMBOL(kill_pid);
1238 kill_proc(pid_t pid, int sig, int priv)
1240 int ret;
1242 rcu_read_lock();
1243 ret = kill_pid_info(sig, __si_special(priv), find_pid(pid));
1244 rcu_read_unlock();
1245 return ret;
1249 * These functions support sending signals using preallocated sigqueue
1250 * structures. This is needed "because realtime applications cannot
1251 * afford to lose notifications of asynchronous events, like timer
1252 * expirations or I/O completions". In the case of Posix Timers
1253 * we allocate the sigqueue structure from the timer_create. If this
1254 * allocation fails we are able to report the failure to the application
1255 * with an EAGAIN error.
1258 struct sigqueue *sigqueue_alloc(void)
1260 struct sigqueue *q;
1262 if ((q = __sigqueue_alloc(current, GFP_KERNEL, 0)))
1263 q->flags |= SIGQUEUE_PREALLOC;
1264 return(q);
1267 void sigqueue_free(struct sigqueue *q)
1269 unsigned long flags;
1270 spinlock_t *lock = &current->sighand->siglock;
1272 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1274 * If the signal is still pending remove it from the
1275 * pending queue. We must hold ->siglock while testing
1276 * q->list to serialize with collect_signal().
1278 spin_lock_irqsave(lock, flags);
1279 if (!list_empty(&q->list))
1280 list_del_init(&q->list);
1281 spin_unlock_irqrestore(lock, flags);
1283 q->flags &= ~SIGQUEUE_PREALLOC;
1284 __sigqueue_free(q);
1287 int send_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1289 unsigned long flags;
1290 int ret = 0;
1292 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1295 * The rcu based delayed sighand destroy makes it possible to
1296 * run this without tasklist lock held. The task struct itself
1297 * cannot go away as create_timer did get_task_struct().
1299 * We return -1, when the task is marked exiting, so
1300 * posix_timer_event can redirect it to the group leader
1302 rcu_read_lock();
1304 if (!likely(lock_task_sighand(p, &flags))) {
1305 ret = -1;
1306 goto out_err;
1309 if (unlikely(!list_empty(&q->list))) {
1311 * If an SI_TIMER entry is already queue just increment
1312 * the overrun count.
1314 BUG_ON(q->info.si_code != SI_TIMER);
1315 q->info.si_overrun++;
1316 goto out;
1318 /* Short-circuit ignored signals. */
1319 if (sig_ignored(p, sig)) {
1320 ret = 1;
1321 goto out;
1324 * Deliver the signal to listening signalfds. This must be called
1325 * with the sighand lock held.
1327 signalfd_notify(p, sig);
1329 list_add_tail(&q->list, &p->pending.list);
1330 sigaddset(&p->pending.signal, sig);
1331 if (!sigismember(&p->blocked, sig))
1332 signal_wake_up(p, sig == SIGKILL);
1334 out:
1335 unlock_task_sighand(p, &flags);
1336 out_err:
1337 rcu_read_unlock();
1339 return ret;
1343 send_group_sigqueue(int sig, struct sigqueue *q, struct task_struct *p)
1345 unsigned long flags;
1346 int ret = 0;
1348 BUG_ON(!(q->flags & SIGQUEUE_PREALLOC));
1350 read_lock(&tasklist_lock);
1351 /* Since it_lock is held, p->sighand cannot be NULL. */
1352 spin_lock_irqsave(&p->sighand->siglock, flags);
1353 handle_stop_signal(sig, p);
1355 /* Short-circuit ignored signals. */
1356 if (sig_ignored(p, sig)) {
1357 ret = 1;
1358 goto out;
1361 if (unlikely(!list_empty(&q->list))) {
1363 * If an SI_TIMER entry is already queue just increment
1364 * the overrun count. Other uses should not try to
1365 * send the signal multiple times.
1367 BUG_ON(q->info.si_code != SI_TIMER);
1368 q->info.si_overrun++;
1369 goto out;
1372 * Deliver the signal to listening signalfds. This must be called
1373 * with the sighand lock held.
1375 signalfd_notify(p, sig);
1378 * Put this signal on the shared-pending queue.
1379 * We always use the shared queue for process-wide signals,
1380 * to avoid several races.
1382 list_add_tail(&q->list, &p->signal->shared_pending.list);
1383 sigaddset(&p->signal->shared_pending.signal, sig);
1385 __group_complete_signal(sig, p);
1386 out:
1387 spin_unlock_irqrestore(&p->sighand->siglock, flags);
1388 read_unlock(&tasklist_lock);
1389 return ret;
1393 * Wake up any threads in the parent blocked in wait* syscalls.
1395 static inline void __wake_up_parent(struct task_struct *p,
1396 struct task_struct *parent)
1398 wake_up_interruptible_sync(&parent->signal->wait_chldexit);
1402 * Let a parent know about the death of a child.
1403 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1406 void do_notify_parent(struct task_struct *tsk, int sig)
1408 struct siginfo info;
1409 unsigned long flags;
1410 struct sighand_struct *psig;
1412 BUG_ON(sig == -1);
1414 /* do_notify_parent_cldstop should have been called instead. */
1415 BUG_ON(task_is_stopped_or_traced(tsk));
1417 BUG_ON(!tsk->ptrace &&
1418 (tsk->group_leader != tsk || !thread_group_empty(tsk)));
1420 info.si_signo = sig;
1421 info.si_errno = 0;
1423 * we are under tasklist_lock here so our parent is tied to
1424 * us and cannot exit and release its namespace.
1426 * the only it can is to switch its nsproxy with sys_unshare,
1427 * bu uncharing pid namespaces is not allowed, so we'll always
1428 * see relevant namespace
1430 * write_lock() currently calls preempt_disable() which is the
1431 * same as rcu_read_lock(), but according to Oleg, this is not
1432 * correct to rely on this
1434 rcu_read_lock();
1435 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1436 rcu_read_unlock();
1438 info.si_uid = tsk->uid;
1440 /* FIXME: find out whether or not this is supposed to be c*time. */
1441 info.si_utime = cputime_to_jiffies(cputime_add(tsk->utime,
1442 tsk->signal->utime));
1443 info.si_stime = cputime_to_jiffies(cputime_add(tsk->stime,
1444 tsk->signal->stime));
1446 info.si_status = tsk->exit_code & 0x7f;
1447 if (tsk->exit_code & 0x80)
1448 info.si_code = CLD_DUMPED;
1449 else if (tsk->exit_code & 0x7f)
1450 info.si_code = CLD_KILLED;
1451 else {
1452 info.si_code = CLD_EXITED;
1453 info.si_status = tsk->exit_code >> 8;
1456 psig = tsk->parent->sighand;
1457 spin_lock_irqsave(&psig->siglock, flags);
1458 if (!tsk->ptrace && sig == SIGCHLD &&
1459 (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN ||
1460 (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) {
1462 * We are exiting and our parent doesn't care. POSIX.1
1463 * defines special semantics for setting SIGCHLD to SIG_IGN
1464 * or setting the SA_NOCLDWAIT flag: we should be reaped
1465 * automatically and not left for our parent's wait4 call.
1466 * Rather than having the parent do it as a magic kind of
1467 * signal handler, we just set this to tell do_exit that we
1468 * can be cleaned up without becoming a zombie. Note that
1469 * we still call __wake_up_parent in this case, because a
1470 * blocked sys_wait4 might now return -ECHILD.
1472 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1473 * is implementation-defined: we do (if you don't want
1474 * it, just use SIG_IGN instead).
1476 tsk->exit_signal = -1;
1477 if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN)
1478 sig = 0;
1480 if (valid_signal(sig) && sig > 0)
1481 __group_send_sig_info(sig, &info, tsk->parent);
1482 __wake_up_parent(tsk, tsk->parent);
1483 spin_unlock_irqrestore(&psig->siglock, flags);
1486 static void do_notify_parent_cldstop(struct task_struct *tsk, int why)
1488 struct siginfo info;
1489 unsigned long flags;
1490 struct task_struct *parent;
1491 struct sighand_struct *sighand;
1493 if (tsk->ptrace & PT_PTRACED)
1494 parent = tsk->parent;
1495 else {
1496 tsk = tsk->group_leader;
1497 parent = tsk->real_parent;
1500 info.si_signo = SIGCHLD;
1501 info.si_errno = 0;
1503 * see comment in do_notify_parent() abot the following 3 lines
1505 rcu_read_lock();
1506 info.si_pid = task_pid_nr_ns(tsk, tsk->parent->nsproxy->pid_ns);
1507 rcu_read_unlock();
1509 info.si_uid = tsk->uid;
1511 /* FIXME: find out whether or not this is supposed to be c*time. */
1512 info.si_utime = cputime_to_jiffies(tsk->utime);
1513 info.si_stime = cputime_to_jiffies(tsk->stime);
1515 info.si_code = why;
1516 switch (why) {
1517 case CLD_CONTINUED:
1518 info.si_status = SIGCONT;
1519 break;
1520 case CLD_STOPPED:
1521 info.si_status = tsk->signal->group_exit_code & 0x7f;
1522 break;
1523 case CLD_TRAPPED:
1524 info.si_status = tsk->exit_code & 0x7f;
1525 break;
1526 default:
1527 BUG();
1530 sighand = parent->sighand;
1531 spin_lock_irqsave(&sighand->siglock, flags);
1532 if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN &&
1533 !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP))
1534 __group_send_sig_info(SIGCHLD, &info, parent);
1536 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1538 __wake_up_parent(tsk, parent);
1539 spin_unlock_irqrestore(&sighand->siglock, flags);
1542 static inline int may_ptrace_stop(void)
1544 if (!likely(current->ptrace & PT_PTRACED))
1545 return 0;
1547 * Are we in the middle of do_coredump?
1548 * If so and our tracer is also part of the coredump stopping
1549 * is a deadlock situation, and pointless because our tracer
1550 * is dead so don't allow us to stop.
1551 * If SIGKILL was already sent before the caller unlocked
1552 * ->siglock we must see ->core_waiters != 0. Otherwise it
1553 * is safe to enter schedule().
1555 if (unlikely(current->mm->core_waiters) &&
1556 unlikely(current->mm == current->parent->mm))
1557 return 0;
1559 return 1;
1563 * Return nonzero if there is a SIGKILL that should be waking us up.
1564 * Called with the siglock held.
1566 static int sigkill_pending(struct task_struct *tsk)
1568 return ((sigismember(&tsk->pending.signal, SIGKILL) ||
1569 sigismember(&tsk->signal->shared_pending.signal, SIGKILL)) &&
1570 !unlikely(sigismember(&tsk->blocked, SIGKILL)));
1574 * This must be called with current->sighand->siglock held.
1576 * This should be the path for all ptrace stops.
1577 * We always set current->last_siginfo while stopped here.
1578 * That makes it a way to test a stopped process for
1579 * being ptrace-stopped vs being job-control-stopped.
1581 * If we actually decide not to stop at all because the tracer
1582 * is gone, we keep current->exit_code unless clear_code.
1584 static void ptrace_stop(int exit_code, int clear_code, siginfo_t *info)
1586 int killed = 0;
1588 if (arch_ptrace_stop_needed(exit_code, info)) {
1590 * The arch code has something special to do before a
1591 * ptrace stop. This is allowed to block, e.g. for faults
1592 * on user stack pages. We can't keep the siglock while
1593 * calling arch_ptrace_stop, so we must release it now.
1594 * To preserve proper semantics, we must do this before
1595 * any signal bookkeeping like checking group_stop_count.
1596 * Meanwhile, a SIGKILL could come in before we retake the
1597 * siglock. That must prevent us from sleeping in TASK_TRACED.
1598 * So after regaining the lock, we must check for SIGKILL.
1600 spin_unlock_irq(&current->sighand->siglock);
1601 arch_ptrace_stop(exit_code, info);
1602 spin_lock_irq(&current->sighand->siglock);
1603 killed = sigkill_pending(current);
1607 * If there is a group stop in progress,
1608 * we must participate in the bookkeeping.
1610 if (current->signal->group_stop_count > 0)
1611 --current->signal->group_stop_count;
1613 current->last_siginfo = info;
1614 current->exit_code = exit_code;
1616 /* Let the debugger run. */
1617 __set_current_state(TASK_TRACED);
1618 spin_unlock_irq(&current->sighand->siglock);
1619 read_lock(&tasklist_lock);
1620 if (!unlikely(killed) && may_ptrace_stop()) {
1621 do_notify_parent_cldstop(current, CLD_TRAPPED);
1622 read_unlock(&tasklist_lock);
1623 schedule();
1624 } else {
1626 * By the time we got the lock, our tracer went away.
1627 * Don't drop the lock yet, another tracer may come.
1629 __set_current_state(TASK_RUNNING);
1630 if (clear_code)
1631 current->exit_code = 0;
1632 read_unlock(&tasklist_lock);
1636 * While in TASK_TRACED, we were considered "frozen enough".
1637 * Now that we woke up, it's crucial if we're supposed to be
1638 * frozen that we freeze now before running anything substantial.
1640 try_to_freeze();
1643 * We are back. Now reacquire the siglock before touching
1644 * last_siginfo, so that we are sure to have synchronized with
1645 * any signal-sending on another CPU that wants to examine it.
1647 spin_lock_irq(&current->sighand->siglock);
1648 current->last_siginfo = NULL;
1651 * Queued signals ignored us while we were stopped for tracing.
1652 * So check for any that we should take before resuming user mode.
1653 * This sets TIF_SIGPENDING, but never clears it.
1655 recalc_sigpending_tsk(current);
1658 void ptrace_notify(int exit_code)
1660 siginfo_t info;
1662 BUG_ON((exit_code & (0x7f | ~0xffff)) != SIGTRAP);
1664 memset(&info, 0, sizeof info);
1665 info.si_signo = SIGTRAP;
1666 info.si_code = exit_code;
1667 info.si_pid = task_pid_vnr(current);
1668 info.si_uid = current->uid;
1670 /* Let the debugger run. */
1671 spin_lock_irq(&current->sighand->siglock);
1672 ptrace_stop(exit_code, 1, &info);
1673 spin_unlock_irq(&current->sighand->siglock);
1676 static void
1677 finish_stop(int stop_count)
1680 * If there are no other threads in the group, or if there is
1681 * a group stop in progress and we are the last to stop,
1682 * report to the parent. When ptraced, every thread reports itself.
1684 if (stop_count == 0 || (current->ptrace & PT_PTRACED)) {
1685 read_lock(&tasklist_lock);
1686 do_notify_parent_cldstop(current, CLD_STOPPED);
1687 read_unlock(&tasklist_lock);
1690 do {
1691 schedule();
1692 } while (try_to_freeze());
1694 * Now we don't run again until continued.
1696 current->exit_code = 0;
1700 * This performs the stopping for SIGSTOP and other stop signals.
1701 * We have to stop all threads in the thread group.
1702 * Returns nonzero if we've actually stopped and released the siglock.
1703 * Returns zero if we didn't stop and still hold the siglock.
1705 static int do_signal_stop(int signr)
1707 struct signal_struct *sig = current->signal;
1708 int stop_count;
1710 if (sig->group_stop_count > 0) {
1712 * There is a group stop in progress. We don't need to
1713 * start another one.
1715 stop_count = --sig->group_stop_count;
1716 } else {
1717 struct task_struct *t;
1719 if (!likely(sig->flags & SIGNAL_STOP_DEQUEUED) ||
1720 unlikely(sig->group_exit_task))
1721 return 0;
1723 * There is no group stop already in progress.
1724 * We must initiate one now.
1726 sig->group_exit_code = signr;
1728 stop_count = 0;
1729 for (t = next_thread(current); t != current; t = next_thread(t))
1731 * Setting state to TASK_STOPPED for a group
1732 * stop is always done with the siglock held,
1733 * so this check has no races.
1735 if (!(t->flags & PF_EXITING) &&
1736 !task_is_stopped_or_traced(t)) {
1737 stop_count++;
1738 signal_wake_up(t, 0);
1740 sig->group_stop_count = stop_count;
1743 if (stop_count == 0)
1744 sig->flags = SIGNAL_STOP_STOPPED;
1745 current->exit_code = sig->group_exit_code;
1746 __set_current_state(TASK_STOPPED);
1748 spin_unlock_irq(&current->sighand->siglock);
1749 finish_stop(stop_count);
1750 return 1;
1753 static int ptrace_signal(int signr, siginfo_t *info,
1754 struct pt_regs *regs, void *cookie)
1756 if (!(current->ptrace & PT_PTRACED))
1757 return signr;
1759 ptrace_signal_deliver(regs, cookie);
1761 /* Let the debugger run. */
1762 ptrace_stop(signr, 0, info);
1764 /* We're back. Did the debugger cancel the sig? */
1765 signr = current->exit_code;
1766 if (signr == 0)
1767 return signr;
1769 current->exit_code = 0;
1771 /* Update the siginfo structure if the signal has
1772 changed. If the debugger wanted something
1773 specific in the siginfo structure then it should
1774 have updated *info via PTRACE_SETSIGINFO. */
1775 if (signr != info->si_signo) {
1776 info->si_signo = signr;
1777 info->si_errno = 0;
1778 info->si_code = SI_USER;
1779 info->si_pid = task_pid_vnr(current->parent);
1780 info->si_uid = current->parent->uid;
1783 /* If the (new) signal is now blocked, requeue it. */
1784 if (sigismember(&current->blocked, signr)) {
1785 specific_send_sig_info(signr, info, current);
1786 signr = 0;
1789 return signr;
1792 int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka,
1793 struct pt_regs *regs, void *cookie)
1795 sigset_t *mask = &current->blocked;
1796 int signr = 0;
1798 relock:
1800 * We'll jump back here after any time we were stopped in TASK_STOPPED.
1801 * While in TASK_STOPPED, we were considered "frozen enough".
1802 * Now that we woke up, it's crucial if we're supposed to be
1803 * frozen that we freeze now before running anything substantial.
1805 try_to_freeze();
1807 spin_lock_irq(&current->sighand->siglock);
1808 for (;;) {
1809 struct k_sigaction *ka;
1811 if (unlikely(current->signal->group_stop_count > 0) &&
1812 do_signal_stop(0))
1813 goto relock;
1815 signr = dequeue_signal(current, mask, info);
1817 if (!signr)
1818 break; /* will return 0 */
1820 if (signr != SIGKILL) {
1821 signr = ptrace_signal(signr, info, regs, cookie);
1822 if (!signr)
1823 continue;
1826 ka = &current->sighand->action[signr-1];
1827 if (ka->sa.sa_handler == SIG_IGN) /* Do nothing. */
1828 continue;
1829 if (ka->sa.sa_handler != SIG_DFL) {
1830 /* Run the handler. */
1831 *return_ka = *ka;
1833 if (ka->sa.sa_flags & SA_ONESHOT)
1834 ka->sa.sa_handler = SIG_DFL;
1836 break; /* will return non-zero "signr" value */
1840 * Now we are doing the default action for this signal.
1842 if (sig_kernel_ignore(signr)) /* Default is nothing. */
1843 continue;
1846 * Global init gets no signals it doesn't want.
1848 if (is_global_init(current))
1849 continue;
1851 if (sig_kernel_stop(signr)) {
1853 * The default action is to stop all threads in
1854 * the thread group. The job control signals
1855 * do nothing in an orphaned pgrp, but SIGSTOP
1856 * always works. Note that siglock needs to be
1857 * dropped during the call to is_orphaned_pgrp()
1858 * because of lock ordering with tasklist_lock.
1859 * This allows an intervening SIGCONT to be posted.
1860 * We need to check for that and bail out if necessary.
1862 if (signr != SIGSTOP) {
1863 spin_unlock_irq(&current->sighand->siglock);
1865 /* signals can be posted during this window */
1867 if (is_current_pgrp_orphaned())
1868 goto relock;
1870 spin_lock_irq(&current->sighand->siglock);
1873 if (likely(do_signal_stop(signr))) {
1874 /* It released the siglock. */
1875 goto relock;
1879 * We didn't actually stop, due to a race
1880 * with SIGCONT or something like that.
1882 continue;
1885 spin_unlock_irq(&current->sighand->siglock);
1888 * Anything else is fatal, maybe with a core dump.
1890 current->flags |= PF_SIGNALED;
1891 if ((signr != SIGKILL) && print_fatal_signals)
1892 print_fatal_signal(regs, signr);
1893 if (sig_kernel_coredump(signr)) {
1895 * If it was able to dump core, this kills all
1896 * other threads in the group and synchronizes with
1897 * their demise. If we lost the race with another
1898 * thread getting here, it set group_exit_code
1899 * first and our do_group_exit call below will use
1900 * that value and ignore the one we pass it.
1902 do_coredump((long)signr, signr, regs);
1906 * Death signals, no core dump.
1908 do_group_exit(signr);
1909 /* NOTREACHED */
1911 spin_unlock_irq(&current->sighand->siglock);
1912 return signr;
1915 void exit_signals(struct task_struct *tsk)
1917 int group_stop = 0;
1918 struct task_struct *t;
1920 if (thread_group_empty(tsk) || signal_group_exit(tsk->signal)) {
1921 tsk->flags |= PF_EXITING;
1922 return;
1925 spin_lock_irq(&tsk->sighand->siglock);
1927 * From now this task is not visible for group-wide signals,
1928 * see wants_signal(), do_signal_stop().
1930 tsk->flags |= PF_EXITING;
1931 if (!signal_pending(tsk))
1932 goto out;
1934 /* It could be that __group_complete_signal() choose us to
1935 * notify about group-wide signal. Another thread should be
1936 * woken now to take the signal since we will not.
1938 for (t = tsk; (t = next_thread(t)) != tsk; )
1939 if (!signal_pending(t) && !(t->flags & PF_EXITING))
1940 recalc_sigpending_and_wake(t);
1942 if (unlikely(tsk->signal->group_stop_count) &&
1943 !--tsk->signal->group_stop_count) {
1944 tsk->signal->flags = SIGNAL_STOP_STOPPED;
1945 group_stop = 1;
1947 out:
1948 spin_unlock_irq(&tsk->sighand->siglock);
1950 if (unlikely(group_stop)) {
1951 read_lock(&tasklist_lock);
1952 do_notify_parent_cldstop(tsk, CLD_STOPPED);
1953 read_unlock(&tasklist_lock);
1957 EXPORT_SYMBOL(recalc_sigpending);
1958 EXPORT_SYMBOL_GPL(dequeue_signal);
1959 EXPORT_SYMBOL(flush_signals);
1960 EXPORT_SYMBOL(force_sig);
1961 EXPORT_SYMBOL(kill_proc);
1962 EXPORT_SYMBOL(ptrace_notify);
1963 EXPORT_SYMBOL(send_sig);
1964 EXPORT_SYMBOL(send_sig_info);
1965 EXPORT_SYMBOL(sigprocmask);
1966 EXPORT_SYMBOL(block_all_signals);
1967 EXPORT_SYMBOL(unblock_all_signals);
1971 * System call entry points.
1974 asmlinkage long sys_restart_syscall(void)
1976 struct restart_block *restart = &current_thread_info()->restart_block;
1977 return restart->fn(restart);
1980 long do_no_restart_syscall(struct restart_block *param)
1982 return -EINTR;
1986 * We don't need to get the kernel lock - this is all local to this
1987 * particular thread.. (and that's good, because this is _heavily_
1988 * used by various programs)
1992 * This is also useful for kernel threads that want to temporarily
1993 * (or permanently) block certain signals.
1995 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1996 * interface happily blocks "unblockable" signals like SIGKILL
1997 * and friends.
1999 int sigprocmask(int how, sigset_t *set, sigset_t *oldset)
2001 int error;
2003 spin_lock_irq(&current->sighand->siglock);
2004 if (oldset)
2005 *oldset = current->blocked;
2007 error = 0;
2008 switch (how) {
2009 case SIG_BLOCK:
2010 sigorsets(&current->blocked, &current->blocked, set);
2011 break;
2012 case SIG_UNBLOCK:
2013 signandsets(&current->blocked, &current->blocked, set);
2014 break;
2015 case SIG_SETMASK:
2016 current->blocked = *set;
2017 break;
2018 default:
2019 error = -EINVAL;
2021 recalc_sigpending();
2022 spin_unlock_irq(&current->sighand->siglock);
2024 return error;
2027 asmlinkage long
2028 sys_rt_sigprocmask(int how, sigset_t __user *set, sigset_t __user *oset, size_t sigsetsize)
2030 int error = -EINVAL;
2031 sigset_t old_set, new_set;
2033 /* XXX: Don't preclude handling different sized sigset_t's. */
2034 if (sigsetsize != sizeof(sigset_t))
2035 goto out;
2037 if (set) {
2038 error = -EFAULT;
2039 if (copy_from_user(&new_set, set, sizeof(*set)))
2040 goto out;
2041 sigdelsetmask(&new_set, sigmask(SIGKILL)|sigmask(SIGSTOP));
2043 error = sigprocmask(how, &new_set, &old_set);
2044 if (error)
2045 goto out;
2046 if (oset)
2047 goto set_old;
2048 } else if (oset) {
2049 spin_lock_irq(&current->sighand->siglock);
2050 old_set = current->blocked;
2051 spin_unlock_irq(&current->sighand->siglock);
2053 set_old:
2054 error = -EFAULT;
2055 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2056 goto out;
2058 error = 0;
2059 out:
2060 return error;
2063 long do_sigpending(void __user *set, unsigned long sigsetsize)
2065 long error = -EINVAL;
2066 sigset_t pending;
2068 if (sigsetsize > sizeof(sigset_t))
2069 goto out;
2071 spin_lock_irq(&current->sighand->siglock);
2072 sigorsets(&pending, &current->pending.signal,
2073 &current->signal->shared_pending.signal);
2074 spin_unlock_irq(&current->sighand->siglock);
2076 /* Outside the lock because only this thread touches it. */
2077 sigandsets(&pending, &current->blocked, &pending);
2079 error = -EFAULT;
2080 if (!copy_to_user(set, &pending, sigsetsize))
2081 error = 0;
2083 out:
2084 return error;
2087 asmlinkage long
2088 sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize)
2090 return do_sigpending(set, sigsetsize);
2093 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2095 int copy_siginfo_to_user(siginfo_t __user *to, siginfo_t *from)
2097 int err;
2099 if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t)))
2100 return -EFAULT;
2101 if (from->si_code < 0)
2102 return __copy_to_user(to, from, sizeof(siginfo_t))
2103 ? -EFAULT : 0;
2105 * If you change siginfo_t structure, please be sure
2106 * this code is fixed accordingly.
2107 * Please remember to update the signalfd_copyinfo() function
2108 * inside fs/signalfd.c too, in case siginfo_t changes.
2109 * It should never copy any pad contained in the structure
2110 * to avoid security leaks, but must copy the generic
2111 * 3 ints plus the relevant union member.
2113 err = __put_user(from->si_signo, &to->si_signo);
2114 err |= __put_user(from->si_errno, &to->si_errno);
2115 err |= __put_user((short)from->si_code, &to->si_code);
2116 switch (from->si_code & __SI_MASK) {
2117 case __SI_KILL:
2118 err |= __put_user(from->si_pid, &to->si_pid);
2119 err |= __put_user(from->si_uid, &to->si_uid);
2120 break;
2121 case __SI_TIMER:
2122 err |= __put_user(from->si_tid, &to->si_tid);
2123 err |= __put_user(from->si_overrun, &to->si_overrun);
2124 err |= __put_user(from->si_ptr, &to->si_ptr);
2125 break;
2126 case __SI_POLL:
2127 err |= __put_user(from->si_band, &to->si_band);
2128 err |= __put_user(from->si_fd, &to->si_fd);
2129 break;
2130 case __SI_FAULT:
2131 err |= __put_user(from->si_addr, &to->si_addr);
2132 #ifdef __ARCH_SI_TRAPNO
2133 err |= __put_user(from->si_trapno, &to->si_trapno);
2134 #endif
2135 break;
2136 case __SI_CHLD:
2137 err |= __put_user(from->si_pid, &to->si_pid);
2138 err |= __put_user(from->si_uid, &to->si_uid);
2139 err |= __put_user(from->si_status, &to->si_status);
2140 err |= __put_user(from->si_utime, &to->si_utime);
2141 err |= __put_user(from->si_stime, &to->si_stime);
2142 break;
2143 case __SI_RT: /* This is not generated by the kernel as of now. */
2144 case __SI_MESGQ: /* But this is */
2145 err |= __put_user(from->si_pid, &to->si_pid);
2146 err |= __put_user(from->si_uid, &to->si_uid);
2147 err |= __put_user(from->si_ptr, &to->si_ptr);
2148 break;
2149 default: /* this is just in case for now ... */
2150 err |= __put_user(from->si_pid, &to->si_pid);
2151 err |= __put_user(from->si_uid, &to->si_uid);
2152 break;
2154 return err;
2157 #endif
2159 asmlinkage long
2160 sys_rt_sigtimedwait(const sigset_t __user *uthese,
2161 siginfo_t __user *uinfo,
2162 const struct timespec __user *uts,
2163 size_t sigsetsize)
2165 int ret, sig;
2166 sigset_t these;
2167 struct timespec ts;
2168 siginfo_t info;
2169 long timeout = 0;
2171 /* XXX: Don't preclude handling different sized sigset_t's. */
2172 if (sigsetsize != sizeof(sigset_t))
2173 return -EINVAL;
2175 if (copy_from_user(&these, uthese, sizeof(these)))
2176 return -EFAULT;
2179 * Invert the set of allowed signals to get those we
2180 * want to block.
2182 sigdelsetmask(&these, sigmask(SIGKILL)|sigmask(SIGSTOP));
2183 signotset(&these);
2185 if (uts) {
2186 if (copy_from_user(&ts, uts, sizeof(ts)))
2187 return -EFAULT;
2188 if (ts.tv_nsec >= 1000000000L || ts.tv_nsec < 0
2189 || ts.tv_sec < 0)
2190 return -EINVAL;
2193 spin_lock_irq(&current->sighand->siglock);
2194 sig = dequeue_signal(current, &these, &info);
2195 if (!sig) {
2196 timeout = MAX_SCHEDULE_TIMEOUT;
2197 if (uts)
2198 timeout = (timespec_to_jiffies(&ts)
2199 + (ts.tv_sec || ts.tv_nsec));
2201 if (timeout) {
2202 /* None ready -- temporarily unblock those we're
2203 * interested while we are sleeping in so that we'll
2204 * be awakened when they arrive. */
2205 current->real_blocked = current->blocked;
2206 sigandsets(&current->blocked, &current->blocked, &these);
2207 recalc_sigpending();
2208 spin_unlock_irq(&current->sighand->siglock);
2210 timeout = schedule_timeout_interruptible(timeout);
2212 spin_lock_irq(&current->sighand->siglock);
2213 sig = dequeue_signal(current, &these, &info);
2214 current->blocked = current->real_blocked;
2215 siginitset(&current->real_blocked, 0);
2216 recalc_sigpending();
2219 spin_unlock_irq(&current->sighand->siglock);
2221 if (sig) {
2222 ret = sig;
2223 if (uinfo) {
2224 if (copy_siginfo_to_user(uinfo, &info))
2225 ret = -EFAULT;
2227 } else {
2228 ret = -EAGAIN;
2229 if (timeout)
2230 ret = -EINTR;
2233 return ret;
2236 asmlinkage long
2237 sys_kill(int pid, int sig)
2239 struct siginfo info;
2241 info.si_signo = sig;
2242 info.si_errno = 0;
2243 info.si_code = SI_USER;
2244 info.si_pid = task_tgid_vnr(current);
2245 info.si_uid = current->uid;
2247 return kill_something_info(sig, &info, pid);
2250 static int do_tkill(int tgid, int pid, int sig)
2252 int error;
2253 struct siginfo info;
2254 struct task_struct *p;
2256 error = -ESRCH;
2257 info.si_signo = sig;
2258 info.si_errno = 0;
2259 info.si_code = SI_TKILL;
2260 info.si_pid = task_tgid_vnr(current);
2261 info.si_uid = current->uid;
2263 read_lock(&tasklist_lock);
2264 p = find_task_by_vpid(pid);
2265 if (p && (tgid <= 0 || task_tgid_vnr(p) == tgid)) {
2266 error = check_kill_permission(sig, &info, p);
2268 * The null signal is a permissions and process existence
2269 * probe. No signal is actually delivered.
2271 if (!error && sig && p->sighand) {
2272 spin_lock_irq(&p->sighand->siglock);
2273 handle_stop_signal(sig, p);
2274 error = specific_send_sig_info(sig, &info, p);
2275 spin_unlock_irq(&p->sighand->siglock);
2278 read_unlock(&tasklist_lock);
2280 return error;
2284 * sys_tgkill - send signal to one specific thread
2285 * @tgid: the thread group ID of the thread
2286 * @pid: the PID of the thread
2287 * @sig: signal to be sent
2289 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2290 * exists but it's not belonging to the target process anymore. This
2291 * method solves the problem of threads exiting and PIDs getting reused.
2293 asmlinkage long sys_tgkill(int tgid, int pid, int sig)
2295 /* This is only valid for single tasks */
2296 if (pid <= 0 || tgid <= 0)
2297 return -EINVAL;
2299 return do_tkill(tgid, pid, sig);
2303 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2305 asmlinkage long
2306 sys_tkill(int pid, int sig)
2308 /* This is only valid for single tasks */
2309 if (pid <= 0)
2310 return -EINVAL;
2312 return do_tkill(0, pid, sig);
2315 asmlinkage long
2316 sys_rt_sigqueueinfo(int pid, int sig, siginfo_t __user *uinfo)
2318 siginfo_t info;
2320 if (copy_from_user(&info, uinfo, sizeof(siginfo_t)))
2321 return -EFAULT;
2323 /* Not even root can pretend to send signals from the kernel.
2324 Nor can they impersonate a kill(), which adds source info. */
2325 if (info.si_code >= 0)
2326 return -EPERM;
2327 info.si_signo = sig;
2329 /* POSIX.1b doesn't mention process groups. */
2330 return kill_proc_info(sig, &info, pid);
2333 int do_sigaction(int sig, struct k_sigaction *act, struct k_sigaction *oact)
2335 struct k_sigaction *k;
2336 sigset_t mask;
2338 if (!valid_signal(sig) || sig < 1 || (act && sig_kernel_only(sig)))
2339 return -EINVAL;
2341 k = &current->sighand->action[sig-1];
2343 spin_lock_irq(&current->sighand->siglock);
2344 if (oact)
2345 *oact = *k;
2347 if (act) {
2348 sigdelsetmask(&act->sa.sa_mask,
2349 sigmask(SIGKILL) | sigmask(SIGSTOP));
2350 *k = *act;
2352 * POSIX 3.3.1.3:
2353 * "Setting a signal action to SIG_IGN for a signal that is
2354 * pending shall cause the pending signal to be discarded,
2355 * whether or not it is blocked."
2357 * "Setting a signal action to SIG_DFL for a signal that is
2358 * pending and whose default action is to ignore the signal
2359 * (for example, SIGCHLD), shall cause the pending signal to
2360 * be discarded, whether or not it is blocked"
2362 if (act->sa.sa_handler == SIG_IGN ||
2363 (act->sa.sa_handler == SIG_DFL && sig_kernel_ignore(sig))) {
2364 struct task_struct *t = current;
2365 sigemptyset(&mask);
2366 sigaddset(&mask, sig);
2367 rm_from_queue_full(&mask, &t->signal->shared_pending);
2368 do {
2369 rm_from_queue_full(&mask, &t->pending);
2370 t = next_thread(t);
2371 } while (t != current);
2375 spin_unlock_irq(&current->sighand->siglock);
2376 return 0;
2379 int
2380 do_sigaltstack (const stack_t __user *uss, stack_t __user *uoss, unsigned long sp)
2382 stack_t oss;
2383 int error;
2385 if (uoss) {
2386 oss.ss_sp = (void __user *) current->sas_ss_sp;
2387 oss.ss_size = current->sas_ss_size;
2388 oss.ss_flags = sas_ss_flags(sp);
2391 if (uss) {
2392 void __user *ss_sp;
2393 size_t ss_size;
2394 int ss_flags;
2396 error = -EFAULT;
2397 if (!access_ok(VERIFY_READ, uss, sizeof(*uss))
2398 || __get_user(ss_sp, &uss->ss_sp)
2399 || __get_user(ss_flags, &uss->ss_flags)
2400 || __get_user(ss_size, &uss->ss_size))
2401 goto out;
2403 error = -EPERM;
2404 if (on_sig_stack(sp))
2405 goto out;
2407 error = -EINVAL;
2410 * Note - this code used to test ss_flags incorrectly
2411 * old code may have been written using ss_flags==0
2412 * to mean ss_flags==SS_ONSTACK (as this was the only
2413 * way that worked) - this fix preserves that older
2414 * mechanism
2416 if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0)
2417 goto out;
2419 if (ss_flags == SS_DISABLE) {
2420 ss_size = 0;
2421 ss_sp = NULL;
2422 } else {
2423 error = -ENOMEM;
2424 if (ss_size < MINSIGSTKSZ)
2425 goto out;
2428 current->sas_ss_sp = (unsigned long) ss_sp;
2429 current->sas_ss_size = ss_size;
2432 if (uoss) {
2433 error = -EFAULT;
2434 if (copy_to_user(uoss, &oss, sizeof(oss)))
2435 goto out;
2438 error = 0;
2439 out:
2440 return error;
2443 #ifdef __ARCH_WANT_SYS_SIGPENDING
2445 asmlinkage long
2446 sys_sigpending(old_sigset_t __user *set)
2448 return do_sigpending(set, sizeof(*set));
2451 #endif
2453 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2454 /* Some platforms have their own version with special arguments others
2455 support only sys_rt_sigprocmask. */
2457 asmlinkage long
2458 sys_sigprocmask(int how, old_sigset_t __user *set, old_sigset_t __user *oset)
2460 int error;
2461 old_sigset_t old_set, new_set;
2463 if (set) {
2464 error = -EFAULT;
2465 if (copy_from_user(&new_set, set, sizeof(*set)))
2466 goto out;
2467 new_set &= ~(sigmask(SIGKILL) | sigmask(SIGSTOP));
2469 spin_lock_irq(&current->sighand->siglock);
2470 old_set = current->blocked.sig[0];
2472 error = 0;
2473 switch (how) {
2474 default:
2475 error = -EINVAL;
2476 break;
2477 case SIG_BLOCK:
2478 sigaddsetmask(&current->blocked, new_set);
2479 break;
2480 case SIG_UNBLOCK:
2481 sigdelsetmask(&current->blocked, new_set);
2482 break;
2483 case SIG_SETMASK:
2484 current->blocked.sig[0] = new_set;
2485 break;
2488 recalc_sigpending();
2489 spin_unlock_irq(&current->sighand->siglock);
2490 if (error)
2491 goto out;
2492 if (oset)
2493 goto set_old;
2494 } else if (oset) {
2495 old_set = current->blocked.sig[0];
2496 set_old:
2497 error = -EFAULT;
2498 if (copy_to_user(oset, &old_set, sizeof(*oset)))
2499 goto out;
2501 error = 0;
2502 out:
2503 return error;
2505 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2507 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2508 asmlinkage long
2509 sys_rt_sigaction(int sig,
2510 const struct sigaction __user *act,
2511 struct sigaction __user *oact,
2512 size_t sigsetsize)
2514 struct k_sigaction new_sa, old_sa;
2515 int ret = -EINVAL;
2517 /* XXX: Don't preclude handling different sized sigset_t's. */
2518 if (sigsetsize != sizeof(sigset_t))
2519 goto out;
2521 if (act) {
2522 if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa)))
2523 return -EFAULT;
2526 ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL);
2528 if (!ret && oact) {
2529 if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa)))
2530 return -EFAULT;
2532 out:
2533 return ret;
2535 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2537 #ifdef __ARCH_WANT_SYS_SGETMASK
2540 * For backwards compatibility. Functionality superseded by sigprocmask.
2542 asmlinkage long
2543 sys_sgetmask(void)
2545 /* SMP safe */
2546 return current->blocked.sig[0];
2549 asmlinkage long
2550 sys_ssetmask(int newmask)
2552 int old;
2554 spin_lock_irq(&current->sighand->siglock);
2555 old = current->blocked.sig[0];
2557 siginitset(&current->blocked, newmask & ~(sigmask(SIGKILL)|
2558 sigmask(SIGSTOP)));
2559 recalc_sigpending();
2560 spin_unlock_irq(&current->sighand->siglock);
2562 return old;
2564 #endif /* __ARCH_WANT_SGETMASK */
2566 #ifdef __ARCH_WANT_SYS_SIGNAL
2568 * For backwards compatibility. Functionality superseded by sigaction.
2570 asmlinkage unsigned long
2571 sys_signal(int sig, __sighandler_t handler)
2573 struct k_sigaction new_sa, old_sa;
2574 int ret;
2576 new_sa.sa.sa_handler = handler;
2577 new_sa.sa.sa_flags = SA_ONESHOT | SA_NOMASK;
2578 sigemptyset(&new_sa.sa.sa_mask);
2580 ret = do_sigaction(sig, &new_sa, &old_sa);
2582 return ret ? ret : (unsigned long)old_sa.sa.sa_handler;
2584 #endif /* __ARCH_WANT_SYS_SIGNAL */
2586 #ifdef __ARCH_WANT_SYS_PAUSE
2588 asmlinkage long
2589 sys_pause(void)
2591 current->state = TASK_INTERRUPTIBLE;
2592 schedule();
2593 return -ERESTARTNOHAND;
2596 #endif
2598 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2599 asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize)
2601 sigset_t newset;
2603 /* XXX: Don't preclude handling different sized sigset_t's. */
2604 if (sigsetsize != sizeof(sigset_t))
2605 return -EINVAL;
2607 if (copy_from_user(&newset, unewset, sizeof(newset)))
2608 return -EFAULT;
2609 sigdelsetmask(&newset, sigmask(SIGKILL)|sigmask(SIGSTOP));
2611 spin_lock_irq(&current->sighand->siglock);
2612 current->saved_sigmask = current->blocked;
2613 current->blocked = newset;
2614 recalc_sigpending();
2615 spin_unlock_irq(&current->sighand->siglock);
2617 current->state = TASK_INTERRUPTIBLE;
2618 schedule();
2619 set_thread_flag(TIF_RESTORE_SIGMASK);
2620 return -ERESTARTNOHAND;
2622 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2624 __attribute__((weak)) const char *arch_vma_name(struct vm_area_struct *vma)
2626 return NULL;
2629 void __init signals_init(void)
2631 sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC);