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>
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
)
54 * Blocked signals are never ignored, since the
55 * signal handler may change by the time it is
58 if (sigismember(&t
->blocked
, sig
))
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
)
76 switch (_NSIG_WORDS
) {
78 for (i
= _NSIG_WORDS
, ready
= 0; --i
>= 0 ;)
79 ready
|= signal
->sig
[i
] &~ blocked
->sig
[i
];
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];
88 case 2: ready
= signal
->sig
[1] &~ blocked
->sig
[1];
89 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
92 case 1: ready
= signal
->sig
[0] &~ blocked
->sig
[0];
97 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
99 fastcall
void recalc_sigpending_tsk(struct task_struct
*t
)
101 if (t
->signal
->group_stop_count
> 0 ||
103 PENDING(&t
->pending
, &t
->blocked
) ||
104 PENDING(&t
->signal
->shared_pending
, &t
->blocked
))
105 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
107 clear_tsk_thread_flag(t
, TIF_SIGPENDING
);
110 void recalc_sigpending(void)
112 recalc_sigpending_tsk(current
);
115 /* Given the mask, find the first available signal that should be serviced. */
117 int next_signal(struct sigpending
*pending
, sigset_t
*mask
)
119 unsigned long i
, *s
, *m
, x
;
122 s
= pending
->signal
.sig
;
124 switch (_NSIG_WORDS
) {
126 for (i
= 0; i
< _NSIG_WORDS
; ++i
, ++s
, ++m
)
127 if ((x
= *s
&~ *m
) != 0) {
128 sig
= ffz(~x
) + i
*_NSIG_BPW
+ 1;
133 case 2: if ((x
= s
[0] &~ m
[0]) != 0)
135 else if ((x
= s
[1] &~ m
[1]) != 0)
142 case 1: if ((x
= *s
&~ *m
) != 0)
150 static struct sigqueue
*__sigqueue_alloc(struct task_struct
*t
, gfp_t flags
,
153 struct sigqueue
*q
= NULL
;
154 struct user_struct
*user
;
157 * In order to avoid problems with "switch_user()", we want to make
158 * sure that the compiler doesn't re-load "t->user"
162 atomic_inc(&user
->sigpending
);
163 if (override_rlimit
||
164 atomic_read(&user
->sigpending
) <=
165 t
->signal
->rlim
[RLIMIT_SIGPENDING
].rlim_cur
)
166 q
= kmem_cache_alloc(sigqueue_cachep
, flags
);
167 if (unlikely(q
== NULL
)) {
168 atomic_dec(&user
->sigpending
);
170 INIT_LIST_HEAD(&q
->list
);
172 q
->user
= get_uid(user
);
177 static void __sigqueue_free(struct sigqueue
*q
)
179 if (q
->flags
& SIGQUEUE_PREALLOC
)
181 atomic_dec(&q
->user
->sigpending
);
183 kmem_cache_free(sigqueue_cachep
, q
);
186 void flush_sigqueue(struct sigpending
*queue
)
190 sigemptyset(&queue
->signal
);
191 while (!list_empty(&queue
->list
)) {
192 q
= list_entry(queue
->list
.next
, struct sigqueue
, list
);
193 list_del_init(&q
->list
);
199 * Flush all pending signals for a task.
201 void flush_signals(struct task_struct
*t
)
205 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
206 clear_tsk_thread_flag(t
,TIF_SIGPENDING
);
207 flush_sigqueue(&t
->pending
);
208 flush_sigqueue(&t
->signal
->shared_pending
);
209 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
212 void ignore_signals(struct task_struct
*t
)
216 for (i
= 0; i
< _NSIG
; ++i
)
217 t
->sighand
->action
[i
].sa
.sa_handler
= SIG_IGN
;
223 * Flush all handlers for a task.
227 flush_signal_handlers(struct task_struct
*t
, int force_default
)
230 struct k_sigaction
*ka
= &t
->sighand
->action
[0];
231 for (i
= _NSIG
; i
!= 0 ; i
--) {
232 if (force_default
|| ka
->sa
.sa_handler
!= SIG_IGN
)
233 ka
->sa
.sa_handler
= SIG_DFL
;
235 sigemptyset(&ka
->sa
.sa_mask
);
241 /* Notify the system that a driver wants to block all signals for this
242 * process, and wants to be notified if any signals at all were to be
243 * sent/acted upon. If the notifier routine returns non-zero, then the
244 * signal will be acted upon after all. If the notifier routine returns 0,
245 * then then signal will be blocked. Only one block per process is
246 * allowed. priv is a pointer to private data that the notifier routine
247 * can use to determine if the signal should be blocked or not. */
250 block_all_signals(int (*notifier
)(void *priv
), void *priv
, sigset_t
*mask
)
254 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
255 current
->notifier_mask
= mask
;
256 current
->notifier_data
= priv
;
257 current
->notifier
= notifier
;
258 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
261 /* Notify the system that blocking has ended. */
264 unblock_all_signals(void)
268 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
269 current
->notifier
= NULL
;
270 current
->notifier_data
= NULL
;
272 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
275 static int collect_signal(int sig
, struct sigpending
*list
, siginfo_t
*info
)
277 struct sigqueue
*q
, *first
= NULL
;
278 int still_pending
= 0;
280 if (unlikely(!sigismember(&list
->signal
, sig
)))
284 * Collect the siginfo appropriate to this signal. Check if
285 * there is another siginfo for the same signal.
287 list_for_each_entry(q
, &list
->list
, list
) {
288 if (q
->info
.si_signo
== sig
) {
297 list_del_init(&first
->list
);
298 copy_siginfo(info
, &first
->info
);
299 __sigqueue_free(first
);
301 sigdelset(&list
->signal
, sig
);
304 /* Ok, it wasn't in the queue. This must be
305 a fast-pathed signal or we must have been
306 out of queue space. So zero out the info.
308 sigdelset(&list
->signal
, sig
);
309 info
->si_signo
= sig
;
318 static int __dequeue_signal(struct sigpending
*pending
, sigset_t
*mask
,
321 int sig
= next_signal(pending
, mask
);
324 if (current
->notifier
) {
325 if (sigismember(current
->notifier_mask
, sig
)) {
326 if (!(current
->notifier
)(current
->notifier_data
)) {
327 clear_thread_flag(TIF_SIGPENDING
);
333 if (!collect_signal(sig
, pending
, info
))
341 * Dequeue a signal and return the element to the caller, which is
342 * expected to free it.
344 * All callers have to hold the siglock.
346 int dequeue_signal(struct task_struct
*tsk
, sigset_t
*mask
, siginfo_t
*info
)
348 int signr
= __dequeue_signal(&tsk
->pending
, mask
, info
);
350 signr
= __dequeue_signal(&tsk
->signal
->shared_pending
,
355 * itimers are process shared and we restart periodic
356 * itimers in the signal delivery path to prevent DoS
357 * attacks in the high resolution timer case. This is
358 * compliant with the old way of self restarting
359 * itimers, as the SIGALRM is a legacy signal and only
360 * queued once. Changing the restart behaviour to
361 * restart the timer in the signal dequeue path is
362 * reducing the timer noise on heavy loaded !highres
365 if (unlikely(signr
== SIGALRM
)) {
366 struct hrtimer
*tmr
= &tsk
->signal
->real_timer
;
368 if (!hrtimer_is_queued(tmr
) &&
369 tsk
->signal
->it_real_incr
.tv64
!= 0) {
370 hrtimer_forward(tmr
, tmr
->base
->get_time(),
371 tsk
->signal
->it_real_incr
);
372 hrtimer_restart(tmr
);
376 recalc_sigpending_tsk(tsk
);
377 if (signr
&& unlikely(sig_kernel_stop(signr
))) {
379 * Set a marker that we have dequeued a stop signal. Our
380 * caller might release the siglock and then the pending
381 * stop signal it is about to process is no longer in the
382 * pending bitmasks, but must still be cleared by a SIGCONT
383 * (and overruled by a SIGKILL). So those cases clear this
384 * shared flag after we've set it. Note that this flag may
385 * remain set after the signal we return is ignored or
386 * handled. That doesn't matter because its only purpose
387 * is to alert stop-signal processing code when another
388 * processor has come along and cleared the flag.
390 if (!(tsk
->signal
->flags
& SIGNAL_GROUP_EXIT
))
391 tsk
->signal
->flags
|= SIGNAL_STOP_DEQUEUED
;
394 ((info
->si_code
& __SI_MASK
) == __SI_TIMER
) &&
395 info
->si_sys_private
){
397 * Release the siglock to ensure proper locking order
398 * of timer locks outside of siglocks. Note, we leave
399 * irqs disabled here, since the posix-timers code is
400 * about to disable them again anyway.
402 spin_unlock(&tsk
->sighand
->siglock
);
403 do_schedule_next_timer(info
);
404 spin_lock(&tsk
->sighand
->siglock
);
410 * Tell a process that it has a new active signal..
412 * NOTE! we rely on the previous spin_lock to
413 * lock interrupts for us! We can only be called with
414 * "siglock" held, and the local interrupt must
415 * have been disabled when that got acquired!
417 * No need to set need_resched since signal event passing
418 * goes through ->blocked
420 void signal_wake_up(struct task_struct
*t
, int resume
)
424 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
427 * For SIGKILL, we want to wake it up in the stopped/traced case.
428 * We don't check t->state here because there is a race with it
429 * executing another processor and just now entering stopped state.
430 * By using wake_up_state, we ensure the process will wake up and
431 * handle its death signal.
433 mask
= TASK_INTERRUPTIBLE
;
435 mask
|= TASK_STOPPED
| TASK_TRACED
;
436 if (!wake_up_state(t
, mask
))
441 * Remove signals in mask from the pending set and queue.
442 * Returns 1 if any signals were found.
444 * All callers must be holding the siglock.
446 * This version takes a sigset mask and looks at all signals,
447 * not just those in the first mask word.
449 static int rm_from_queue_full(sigset_t
*mask
, struct sigpending
*s
)
451 struct sigqueue
*q
, *n
;
454 sigandsets(&m
, mask
, &s
->signal
);
455 if (sigisemptyset(&m
))
458 signandsets(&s
->signal
, &s
->signal
, mask
);
459 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
460 if (sigismember(mask
, q
->info
.si_signo
)) {
461 list_del_init(&q
->list
);
468 * Remove signals in mask from the pending set and queue.
469 * Returns 1 if any signals were found.
471 * All callers must be holding the siglock.
473 static int rm_from_queue(unsigned long mask
, struct sigpending
*s
)
475 struct sigqueue
*q
, *n
;
477 if (!sigtestsetmask(&s
->signal
, mask
))
480 sigdelsetmask(&s
->signal
, mask
);
481 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
482 if (q
->info
.si_signo
< SIGRTMIN
&&
483 (mask
& sigmask(q
->info
.si_signo
))) {
484 list_del_init(&q
->list
);
492 * Bad permissions for sending the signal
494 static int check_kill_permission(int sig
, struct siginfo
*info
,
495 struct task_struct
*t
)
498 if (!valid_signal(sig
))
501 if ((info
== SEND_SIG_NOINFO
|| (!is_si_special(info
) && SI_FROMUSER(info
)))
502 && ((sig
!= SIGCONT
) ||
503 (process_session(current
) != process_session(t
)))
504 && (current
->euid
^ t
->suid
) && (current
->euid
^ t
->uid
)
505 && (current
->uid
^ t
->suid
) && (current
->uid
^ t
->uid
)
506 && !capable(CAP_KILL
))
509 error
= security_task_kill(t
, info
, sig
, 0);
511 audit_signal_info(sig
, t
); /* Let audit system see the signal */
516 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
);
519 * Handle magic process-wide effects of stop/continue signals.
520 * Unlike the signal actions, these happen immediately at signal-generation
521 * time regardless of blocking, ignoring, or handling. This does the
522 * actual continuing for SIGCONT, but not the actual stopping for stop
523 * signals. The process stop is done as a signal action for SIG_DFL.
525 static void handle_stop_signal(int sig
, struct task_struct
*p
)
527 struct task_struct
*t
;
529 if (p
->signal
->flags
& SIGNAL_GROUP_EXIT
)
531 * The process is in the middle of dying already.
535 if (sig_kernel_stop(sig
)) {
537 * This is a stop signal. Remove SIGCONT from all queues.
539 rm_from_queue(sigmask(SIGCONT
), &p
->signal
->shared_pending
);
542 rm_from_queue(sigmask(SIGCONT
), &t
->pending
);
545 } else if (sig
== SIGCONT
) {
547 * Remove all stop signals from all queues,
548 * and wake all threads.
550 if (unlikely(p
->signal
->group_stop_count
> 0)) {
552 * There was a group stop in progress. We'll
553 * pretend it finished before we got here. We are
554 * obliged to report it to the parent: if the
555 * SIGSTOP happened "after" this SIGCONT, then it
556 * would have cleared this pending SIGCONT. If it
557 * happened "before" this SIGCONT, then the parent
558 * got the SIGCHLD about the stop finishing before
559 * the continue happened. We do the notification
560 * now, and it's as if the stop had finished and
561 * the SIGCHLD was pending on entry to this kill.
563 p
->signal
->group_stop_count
= 0;
564 p
->signal
->flags
= SIGNAL_STOP_CONTINUED
;
565 spin_unlock(&p
->sighand
->siglock
);
566 do_notify_parent_cldstop(p
, CLD_STOPPED
);
567 spin_lock(&p
->sighand
->siglock
);
569 rm_from_queue(SIG_KERNEL_STOP_MASK
, &p
->signal
->shared_pending
);
573 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
576 * If there is a handler for SIGCONT, we must make
577 * sure that no thread returns to user mode before
578 * we post the signal, in case it was the only
579 * thread eligible to run the signal handler--then
580 * it must not do anything between resuming and
581 * running the handler. With the TIF_SIGPENDING
582 * flag set, the thread will pause and acquire the
583 * siglock that we hold now and until we've queued
584 * the pending signal.
586 * Wake up the stopped thread _after_ setting
589 state
= TASK_STOPPED
;
590 if (sig_user_defined(t
, SIGCONT
) && !sigismember(&t
->blocked
, SIGCONT
)) {
591 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
592 state
|= TASK_INTERRUPTIBLE
;
594 wake_up_state(t
, state
);
599 if (p
->signal
->flags
& SIGNAL_STOP_STOPPED
) {
601 * We were in fact stopped, and are now continued.
602 * Notify the parent with CLD_CONTINUED.
604 p
->signal
->flags
= SIGNAL_STOP_CONTINUED
;
605 p
->signal
->group_exit_code
= 0;
606 spin_unlock(&p
->sighand
->siglock
);
607 do_notify_parent_cldstop(p
, CLD_CONTINUED
);
608 spin_lock(&p
->sighand
->siglock
);
611 * We are not stopped, but there could be a stop
612 * signal in the middle of being processed after
613 * being removed from the queue. Clear that too.
615 p
->signal
->flags
= 0;
617 } else if (sig
== SIGKILL
) {
619 * Make sure that any pending stop signal already dequeued
620 * is undone by the wakeup for SIGKILL.
622 p
->signal
->flags
= 0;
626 static int send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
627 struct sigpending
*signals
)
629 struct sigqueue
* q
= NULL
;
633 * Deliver the signal to listening signalfds. This must be called
634 * with the sighand lock held.
636 signalfd_notify(t
, sig
);
639 * fast-pathed signals for kernel-internal things like SIGSTOP
642 if (info
== SEND_SIG_FORCED
)
645 /* Real-time signals must be queued if sent by sigqueue, or
646 some other real-time mechanism. It is implementation
647 defined whether kill() does so. We attempt to do so, on
648 the principle of least surprise, but since kill is not
649 allowed to fail with EAGAIN when low on memory we just
650 make sure at least one signal gets delivered and don't
651 pass on the info struct. */
653 q
= __sigqueue_alloc(t
, GFP_ATOMIC
, (sig
< SIGRTMIN
&&
654 (is_si_special(info
) ||
655 info
->si_code
>= 0)));
657 list_add_tail(&q
->list
, &signals
->list
);
658 switch ((unsigned long) info
) {
659 case (unsigned long) SEND_SIG_NOINFO
:
660 q
->info
.si_signo
= sig
;
661 q
->info
.si_errno
= 0;
662 q
->info
.si_code
= SI_USER
;
663 q
->info
.si_pid
= current
->pid
;
664 q
->info
.si_uid
= current
->uid
;
666 case (unsigned long) SEND_SIG_PRIV
:
667 q
->info
.si_signo
= sig
;
668 q
->info
.si_errno
= 0;
669 q
->info
.si_code
= SI_KERNEL
;
674 copy_siginfo(&q
->info
, info
);
677 } else if (!is_si_special(info
)) {
678 if (sig
>= SIGRTMIN
&& info
->si_code
!= SI_USER
)
680 * Queue overflow, abort. We may abort if the signal was rt
681 * and sent by user using something other than kill().
687 sigaddset(&signals
->signal
, sig
);
691 #define LEGACY_QUEUE(sigptr, sig) \
692 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
696 specific_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
700 BUG_ON(!irqs_disabled());
701 assert_spin_locked(&t
->sighand
->siglock
);
703 /* Short-circuit ignored signals. */
704 if (sig_ignored(t
, sig
))
707 /* Support queueing exactly one non-rt signal, so that we
708 can get more detailed information about the cause of
710 if (LEGACY_QUEUE(&t
->pending
, sig
))
713 ret
= send_signal(sig
, info
, t
, &t
->pending
);
714 if (!ret
&& !sigismember(&t
->blocked
, sig
))
715 signal_wake_up(t
, sig
== SIGKILL
);
721 * Force a signal that the process can't ignore: if necessary
722 * we unblock the signal and change any SIG_IGN to SIG_DFL.
724 * Note: If we unblock the signal, we always reset it to SIG_DFL,
725 * since we do not want to have a signal handler that was blocked
726 * be invoked when user space had explicitly blocked it.
728 * We don't want to have recursive SIGSEGV's etc, for example.
731 force_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
733 unsigned long int flags
;
734 int ret
, blocked
, ignored
;
735 struct k_sigaction
*action
;
737 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
738 action
= &t
->sighand
->action
[sig
-1];
739 ignored
= action
->sa
.sa_handler
== SIG_IGN
;
740 blocked
= sigismember(&t
->blocked
, sig
);
741 if (blocked
|| ignored
) {
742 action
->sa
.sa_handler
= SIG_DFL
;
744 sigdelset(&t
->blocked
, sig
);
745 recalc_sigpending_tsk(t
);
748 ret
= specific_send_sig_info(sig
, info
, t
);
749 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
755 force_sig_specific(int sig
, struct task_struct
*t
)
757 force_sig_info(sig
, SEND_SIG_FORCED
, t
);
761 * Test if P wants to take SIG. After we've checked all threads with this,
762 * it's equivalent to finding no threads not blocking SIG. Any threads not
763 * blocking SIG were ruled out because they are not running and already
764 * have pending signals. Such threads will dequeue from the shared queue
765 * as soon as they're available, so putting the signal on the shared queue
766 * will be equivalent to sending it to one such thread.
768 static inline int wants_signal(int sig
, struct task_struct
*p
)
770 if (sigismember(&p
->blocked
, sig
))
772 if (p
->flags
& PF_EXITING
)
776 if (p
->state
& (TASK_STOPPED
| TASK_TRACED
))
778 return task_curr(p
) || !signal_pending(p
);
782 __group_complete_signal(int sig
, struct task_struct
*p
)
784 struct task_struct
*t
;
787 * Now find a thread we can wake up to take the signal off the queue.
789 * If the main thread wants the signal, it gets first crack.
790 * Probably the least surprising to the average bear.
792 if (wants_signal(sig
, p
))
794 else if (thread_group_empty(p
))
796 * There is just one thread and it does not need to be woken.
797 * It will dequeue unblocked signals before it runs again.
802 * Otherwise try to find a suitable thread.
804 t
= p
->signal
->curr_target
;
806 /* restart balancing at this thread */
807 t
= p
->signal
->curr_target
= p
;
809 while (!wants_signal(sig
, t
)) {
811 if (t
== p
->signal
->curr_target
)
813 * No thread needs to be woken.
814 * Any eligible threads will see
815 * the signal in the queue soon.
819 p
->signal
->curr_target
= t
;
823 * Found a killable thread. If the signal will be fatal,
824 * then start taking the whole group down immediately.
826 if (sig_fatal(p
, sig
) && !(p
->signal
->flags
& SIGNAL_GROUP_EXIT
) &&
827 !sigismember(&t
->real_blocked
, sig
) &&
828 (sig
== SIGKILL
|| !(t
->ptrace
& PT_PTRACED
))) {
830 * This signal will be fatal to the whole group.
832 if (!sig_kernel_coredump(sig
)) {
834 * Start a group exit and wake everybody up.
835 * This way we don't have other threads
836 * running and doing things after a slower
837 * thread has the fatal signal pending.
839 p
->signal
->flags
= SIGNAL_GROUP_EXIT
;
840 p
->signal
->group_exit_code
= sig
;
841 p
->signal
->group_stop_count
= 0;
844 sigaddset(&t
->pending
.signal
, SIGKILL
);
845 signal_wake_up(t
, 1);
852 * There will be a core dump. We make all threads other
853 * than the chosen one go into a group stop so that nothing
854 * happens until it gets scheduled, takes the signal off
855 * the shared queue, and does the core dump. This is a
856 * little more complicated than strictly necessary, but it
857 * keeps the signal state that winds up in the core dump
858 * unchanged from the death state, e.g. which thread had
859 * the core-dump signal unblocked.
861 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
862 rm_from_queue(SIG_KERNEL_STOP_MASK
, &p
->signal
->shared_pending
);
863 p
->signal
->group_stop_count
= 0;
864 p
->signal
->group_exit_task
= t
;
867 p
->signal
->group_stop_count
++;
868 signal_wake_up(t
, 0);
871 wake_up_process(p
->signal
->group_exit_task
);
876 * The signal is already in the shared-pending queue.
877 * Tell the chosen thread to wake up and dequeue it.
879 signal_wake_up(t
, sig
== SIGKILL
);
884 __group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
888 assert_spin_locked(&p
->sighand
->siglock
);
889 handle_stop_signal(sig
, p
);
891 /* Short-circuit ignored signals. */
892 if (sig_ignored(p
, sig
))
895 if (LEGACY_QUEUE(&p
->signal
->shared_pending
, sig
))
896 /* This is a non-RT signal and we already have one queued. */
900 * Put this signal on the shared-pending queue, or fail with EAGAIN.
901 * We always use the shared queue for process-wide signals,
902 * to avoid several races.
904 ret
= send_signal(sig
, info
, p
, &p
->signal
->shared_pending
);
908 __group_complete_signal(sig
, p
);
913 * Nuke all other threads in the group.
915 void zap_other_threads(struct task_struct
*p
)
917 struct task_struct
*t
;
919 p
->signal
->flags
= SIGNAL_GROUP_EXIT
;
920 p
->signal
->group_stop_count
= 0;
922 if (thread_group_empty(p
))
925 for (t
= next_thread(p
); t
!= p
; t
= next_thread(t
)) {
927 * Don't bother with already dead threads
932 /* SIGKILL will be handled before any pending SIGSTOP */
933 sigaddset(&t
->pending
.signal
, SIGKILL
);
934 signal_wake_up(t
, 1);
939 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
941 struct sighand_struct
*lock_task_sighand(struct task_struct
*tsk
, unsigned long *flags
)
943 struct sighand_struct
*sighand
;
946 sighand
= rcu_dereference(tsk
->sighand
);
947 if (unlikely(sighand
== NULL
))
950 spin_lock_irqsave(&sighand
->siglock
, *flags
);
951 if (likely(sighand
== tsk
->sighand
))
953 spin_unlock_irqrestore(&sighand
->siglock
, *flags
);
959 int group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
964 ret
= check_kill_permission(sig
, info
, p
);
968 if (lock_task_sighand(p
, &flags
)) {
969 ret
= __group_send_sig_info(sig
, info
, p
);
970 unlock_task_sighand(p
, &flags
);
978 * kill_pgrp_info() sends a signal to a process group: this is what the tty
979 * control characters do (^C, ^Z etc)
982 int __kill_pgrp_info(int sig
, struct siginfo
*info
, struct pid
*pgrp
)
984 struct task_struct
*p
= NULL
;
989 do_each_pid_task(pgrp
, PIDTYPE_PGID
, p
) {
990 int err
= group_send_sig_info(sig
, info
, p
);
993 } while_each_pid_task(pgrp
, PIDTYPE_PGID
, p
);
994 return success
? 0 : retval
;
997 int kill_pgrp_info(int sig
, struct siginfo
*info
, struct pid
*pgrp
)
1001 read_lock(&tasklist_lock
);
1002 retval
= __kill_pgrp_info(sig
, info
, pgrp
);
1003 read_unlock(&tasklist_lock
);
1008 int kill_pid_info(int sig
, struct siginfo
*info
, struct pid
*pid
)
1011 struct task_struct
*p
;
1014 if (unlikely(sig_needs_tasklist(sig
)))
1015 read_lock(&tasklist_lock
);
1017 p
= pid_task(pid
, PIDTYPE_PID
);
1020 error
= group_send_sig_info(sig
, info
, p
);
1022 if (unlikely(sig_needs_tasklist(sig
)))
1023 read_unlock(&tasklist_lock
);
1029 kill_proc_info(int sig
, struct siginfo
*info
, pid_t pid
)
1033 error
= kill_pid_info(sig
, info
, find_pid(pid
));
1038 /* like kill_pid_info(), but doesn't use uid/euid of "current" */
1039 int kill_pid_info_as_uid(int sig
, struct siginfo
*info
, struct pid
*pid
,
1040 uid_t uid
, uid_t euid
, u32 secid
)
1043 struct task_struct
*p
;
1045 if (!valid_signal(sig
))
1048 read_lock(&tasklist_lock
);
1049 p
= pid_task(pid
, PIDTYPE_PID
);
1054 if ((info
== SEND_SIG_NOINFO
|| (!is_si_special(info
) && SI_FROMUSER(info
)))
1055 && (euid
!= p
->suid
) && (euid
!= p
->uid
)
1056 && (uid
!= p
->suid
) && (uid
!= p
->uid
)) {
1060 ret
= security_task_kill(p
, info
, sig
, secid
);
1063 if (sig
&& p
->sighand
) {
1064 unsigned long flags
;
1065 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1066 ret
= __group_send_sig_info(sig
, info
, p
);
1067 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1070 read_unlock(&tasklist_lock
);
1073 EXPORT_SYMBOL_GPL(kill_pid_info_as_uid
);
1076 * kill_something_info() interprets pid in interesting ways just like kill(2).
1078 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1079 * is probably wrong. Should make it like BSD or SYSV.
1082 static int kill_something_info(int sig
, struct siginfo
*info
, int pid
)
1087 ret
= kill_pgrp_info(sig
, info
, task_pgrp(current
));
1088 } else if (pid
== -1) {
1089 int retval
= 0, count
= 0;
1090 struct task_struct
* p
;
1092 read_lock(&tasklist_lock
);
1093 for_each_process(p
) {
1094 if (p
->pid
> 1 && p
->tgid
!= current
->tgid
) {
1095 int err
= group_send_sig_info(sig
, info
, p
);
1101 read_unlock(&tasklist_lock
);
1102 ret
= count
? retval
: -ESRCH
;
1103 } else if (pid
< 0) {
1104 ret
= kill_pgrp_info(sig
, info
, find_pid(-pid
));
1106 ret
= kill_pid_info(sig
, info
, find_pid(pid
));
1113 * These are for backward compatibility with the rest of the kernel source.
1117 * These two are the most common entry points. They send a signal
1118 * just to the specific thread.
1121 send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1124 unsigned long flags
;
1127 * Make sure legacy kernel users don't send in bad values
1128 * (normal paths check this in check_kill_permission).
1130 if (!valid_signal(sig
))
1134 * We need the tasklist lock even for the specific
1135 * thread case (when we don't need to follow the group
1136 * lists) in order to avoid races with "p->sighand"
1137 * going away or changing from under us.
1139 read_lock(&tasklist_lock
);
1140 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1141 ret
= specific_send_sig_info(sig
, info
, p
);
1142 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1143 read_unlock(&tasklist_lock
);
1147 #define __si_special(priv) \
1148 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1151 send_sig(int sig
, struct task_struct
*p
, int priv
)
1153 return send_sig_info(sig
, __si_special(priv
), p
);
1157 * This is the entry point for "process-wide" signals.
1158 * They will go to an appropriate thread in the thread group.
1161 send_group_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1164 read_lock(&tasklist_lock
);
1165 ret
= group_send_sig_info(sig
, info
, p
);
1166 read_unlock(&tasklist_lock
);
1171 force_sig(int sig
, struct task_struct
*p
)
1173 force_sig_info(sig
, SEND_SIG_PRIV
, p
);
1177 * When things go south during signal handling, we
1178 * will force a SIGSEGV. And if the signal that caused
1179 * the problem was already a SIGSEGV, we'll want to
1180 * make sure we don't even try to deliver the signal..
1183 force_sigsegv(int sig
, struct task_struct
*p
)
1185 if (sig
== SIGSEGV
) {
1186 unsigned long flags
;
1187 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1188 p
->sighand
->action
[sig
- 1].sa
.sa_handler
= SIG_DFL
;
1189 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1191 force_sig(SIGSEGV
, p
);
1195 int kill_pgrp(struct pid
*pid
, int sig
, int priv
)
1197 return kill_pgrp_info(sig
, __si_special(priv
), pid
);
1199 EXPORT_SYMBOL(kill_pgrp
);
1201 int kill_pid(struct pid
*pid
, int sig
, int priv
)
1203 return kill_pid_info(sig
, __si_special(priv
), pid
);
1205 EXPORT_SYMBOL(kill_pid
);
1208 kill_proc(pid_t pid
, int sig
, int priv
)
1210 return kill_proc_info(sig
, __si_special(priv
), pid
);
1214 * These functions support sending signals using preallocated sigqueue
1215 * structures. This is needed "because realtime applications cannot
1216 * afford to lose notifications of asynchronous events, like timer
1217 * expirations or I/O completions". In the case of Posix Timers
1218 * we allocate the sigqueue structure from the timer_create. If this
1219 * allocation fails we are able to report the failure to the application
1220 * with an EAGAIN error.
1223 struct sigqueue
*sigqueue_alloc(void)
1227 if ((q
= __sigqueue_alloc(current
, GFP_KERNEL
, 0)))
1228 q
->flags
|= SIGQUEUE_PREALLOC
;
1232 void sigqueue_free(struct sigqueue
*q
)
1234 unsigned long flags
;
1235 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1237 * If the signal is still pending remove it from the
1240 if (unlikely(!list_empty(&q
->list
))) {
1241 spinlock_t
*lock
= ¤t
->sighand
->siglock
;
1242 read_lock(&tasklist_lock
);
1243 spin_lock_irqsave(lock
, flags
);
1244 if (!list_empty(&q
->list
))
1245 list_del_init(&q
->list
);
1246 spin_unlock_irqrestore(lock
, flags
);
1247 read_unlock(&tasklist_lock
);
1249 q
->flags
&= ~SIGQUEUE_PREALLOC
;
1253 int send_sigqueue(int sig
, struct sigqueue
*q
, struct task_struct
*p
)
1255 unsigned long flags
;
1258 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1261 * The rcu based delayed sighand destroy makes it possible to
1262 * run this without tasklist lock held. The task struct itself
1263 * cannot go away as create_timer did get_task_struct().
1265 * We return -1, when the task is marked exiting, so
1266 * posix_timer_event can redirect it to the group leader
1270 if (!likely(lock_task_sighand(p
, &flags
))) {
1275 if (unlikely(!list_empty(&q
->list
))) {
1277 * If an SI_TIMER entry is already queue just increment
1278 * the overrun count.
1280 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1281 q
->info
.si_overrun
++;
1284 /* Short-circuit ignored signals. */
1285 if (sig_ignored(p
, sig
)) {
1290 * Deliver the signal to listening signalfds. This must be called
1291 * with the sighand lock held.
1293 signalfd_notify(p
, sig
);
1295 list_add_tail(&q
->list
, &p
->pending
.list
);
1296 sigaddset(&p
->pending
.signal
, sig
);
1297 if (!sigismember(&p
->blocked
, sig
))
1298 signal_wake_up(p
, sig
== SIGKILL
);
1301 unlock_task_sighand(p
, &flags
);
1309 send_group_sigqueue(int sig
, struct sigqueue
*q
, struct task_struct
*p
)
1311 unsigned long flags
;
1314 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1316 read_lock(&tasklist_lock
);
1317 /* Since it_lock is held, p->sighand cannot be NULL. */
1318 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1319 handle_stop_signal(sig
, p
);
1321 /* Short-circuit ignored signals. */
1322 if (sig_ignored(p
, sig
)) {
1327 if (unlikely(!list_empty(&q
->list
))) {
1329 * If an SI_TIMER entry is already queue just increment
1330 * the overrun count. Other uses should not try to
1331 * send the signal multiple times.
1333 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1334 q
->info
.si_overrun
++;
1338 * Deliver the signal to listening signalfds. This must be called
1339 * with the sighand lock held.
1341 signalfd_notify(p
, sig
);
1344 * Put this signal on the shared-pending queue.
1345 * We always use the shared queue for process-wide signals,
1346 * to avoid several races.
1348 list_add_tail(&q
->list
, &p
->signal
->shared_pending
.list
);
1349 sigaddset(&p
->signal
->shared_pending
.signal
, sig
);
1351 __group_complete_signal(sig
, p
);
1353 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1354 read_unlock(&tasklist_lock
);
1359 * Wake up any threads in the parent blocked in wait* syscalls.
1361 static inline void __wake_up_parent(struct task_struct
*p
,
1362 struct task_struct
*parent
)
1364 wake_up_interruptible_sync(&parent
->signal
->wait_chldexit
);
1368 * Let a parent know about the death of a child.
1369 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1372 void do_notify_parent(struct task_struct
*tsk
, int sig
)
1374 struct siginfo info
;
1375 unsigned long flags
;
1376 struct sighand_struct
*psig
;
1380 /* do_notify_parent_cldstop should have been called instead. */
1381 BUG_ON(tsk
->state
& (TASK_STOPPED
|TASK_TRACED
));
1383 BUG_ON(!tsk
->ptrace
&&
1384 (tsk
->group_leader
!= tsk
|| !thread_group_empty(tsk
)));
1386 info
.si_signo
= sig
;
1388 info
.si_pid
= tsk
->pid
;
1389 info
.si_uid
= tsk
->uid
;
1391 /* FIXME: find out whether or not this is supposed to be c*time. */
1392 info
.si_utime
= cputime_to_jiffies(cputime_add(tsk
->utime
,
1393 tsk
->signal
->utime
));
1394 info
.si_stime
= cputime_to_jiffies(cputime_add(tsk
->stime
,
1395 tsk
->signal
->stime
));
1397 info
.si_status
= tsk
->exit_code
& 0x7f;
1398 if (tsk
->exit_code
& 0x80)
1399 info
.si_code
= CLD_DUMPED
;
1400 else if (tsk
->exit_code
& 0x7f)
1401 info
.si_code
= CLD_KILLED
;
1403 info
.si_code
= CLD_EXITED
;
1404 info
.si_status
= tsk
->exit_code
>> 8;
1407 psig
= tsk
->parent
->sighand
;
1408 spin_lock_irqsave(&psig
->siglock
, flags
);
1409 if (!tsk
->ptrace
&& sig
== SIGCHLD
&&
1410 (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
||
1411 (psig
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDWAIT
))) {
1413 * We are exiting and our parent doesn't care. POSIX.1
1414 * defines special semantics for setting SIGCHLD to SIG_IGN
1415 * or setting the SA_NOCLDWAIT flag: we should be reaped
1416 * automatically and not left for our parent's wait4 call.
1417 * Rather than having the parent do it as a magic kind of
1418 * signal handler, we just set this to tell do_exit that we
1419 * can be cleaned up without becoming a zombie. Note that
1420 * we still call __wake_up_parent in this case, because a
1421 * blocked sys_wait4 might now return -ECHILD.
1423 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1424 * is implementation-defined: we do (if you don't want
1425 * it, just use SIG_IGN instead).
1427 tsk
->exit_signal
= -1;
1428 if (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
)
1431 if (valid_signal(sig
) && sig
> 0)
1432 __group_send_sig_info(sig
, &info
, tsk
->parent
);
1433 __wake_up_parent(tsk
, tsk
->parent
);
1434 spin_unlock_irqrestore(&psig
->siglock
, flags
);
1437 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
)
1439 struct siginfo info
;
1440 unsigned long flags
;
1441 struct task_struct
*parent
;
1442 struct sighand_struct
*sighand
;
1444 if (tsk
->ptrace
& PT_PTRACED
)
1445 parent
= tsk
->parent
;
1447 tsk
= tsk
->group_leader
;
1448 parent
= tsk
->real_parent
;
1451 info
.si_signo
= SIGCHLD
;
1453 info
.si_pid
= tsk
->pid
;
1454 info
.si_uid
= tsk
->uid
;
1456 /* FIXME: find out whether or not this is supposed to be c*time. */
1457 info
.si_utime
= cputime_to_jiffies(tsk
->utime
);
1458 info
.si_stime
= cputime_to_jiffies(tsk
->stime
);
1463 info
.si_status
= SIGCONT
;
1466 info
.si_status
= tsk
->signal
->group_exit_code
& 0x7f;
1469 info
.si_status
= tsk
->exit_code
& 0x7f;
1475 sighand
= parent
->sighand
;
1476 spin_lock_irqsave(&sighand
->siglock
, flags
);
1477 if (sighand
->action
[SIGCHLD
-1].sa
.sa_handler
!= SIG_IGN
&&
1478 !(sighand
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDSTOP
))
1479 __group_send_sig_info(SIGCHLD
, &info
, parent
);
1481 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1483 __wake_up_parent(tsk
, parent
);
1484 spin_unlock_irqrestore(&sighand
->siglock
, flags
);
1487 static inline int may_ptrace_stop(void)
1489 if (!likely(current
->ptrace
& PT_PTRACED
))
1492 if (unlikely(current
->parent
== current
->real_parent
&&
1493 (current
->ptrace
& PT_ATTACHED
)))
1496 if (unlikely(current
->signal
== current
->parent
->signal
) &&
1497 unlikely(current
->signal
->flags
& SIGNAL_GROUP_EXIT
))
1501 * Are we in the middle of do_coredump?
1502 * If so and our tracer is also part of the coredump stopping
1503 * is a deadlock situation, and pointless because our tracer
1504 * is dead so don't allow us to stop.
1505 * If SIGKILL was already sent before the caller unlocked
1506 * ->siglock we must see ->core_waiters != 0. Otherwise it
1507 * is safe to enter schedule().
1509 if (unlikely(current
->mm
->core_waiters
) &&
1510 unlikely(current
->mm
== current
->parent
->mm
))
1517 * This must be called with current->sighand->siglock held.
1519 * This should be the path for all ptrace stops.
1520 * We always set current->last_siginfo while stopped here.
1521 * That makes it a way to test a stopped process for
1522 * being ptrace-stopped vs being job-control-stopped.
1524 * If we actually decide not to stop at all because the tracer is gone,
1525 * we leave nostop_code in current->exit_code.
1527 static void ptrace_stop(int exit_code
, int nostop_code
, siginfo_t
*info
)
1530 * If there is a group stop in progress,
1531 * we must participate in the bookkeeping.
1533 if (current
->signal
->group_stop_count
> 0)
1534 --current
->signal
->group_stop_count
;
1536 current
->last_siginfo
= info
;
1537 current
->exit_code
= exit_code
;
1539 /* Let the debugger run. */
1540 set_current_state(TASK_TRACED
);
1541 spin_unlock_irq(¤t
->sighand
->siglock
);
1543 read_lock(&tasklist_lock
);
1544 if (may_ptrace_stop()) {
1545 do_notify_parent_cldstop(current
, CLD_TRAPPED
);
1546 read_unlock(&tasklist_lock
);
1550 * By the time we got the lock, our tracer went away.
1553 read_unlock(&tasklist_lock
);
1554 set_current_state(TASK_RUNNING
);
1555 current
->exit_code
= nostop_code
;
1559 * We are back. Now reacquire the siglock before touching
1560 * last_siginfo, so that we are sure to have synchronized with
1561 * any signal-sending on another CPU that wants to examine it.
1563 spin_lock_irq(¤t
->sighand
->siglock
);
1564 current
->last_siginfo
= NULL
;
1567 * Queued signals ignored us while we were stopped for tracing.
1568 * So check for any that we should take before resuming user mode.
1570 recalc_sigpending();
1573 void ptrace_notify(int exit_code
)
1577 BUG_ON((exit_code
& (0x7f | ~0xffff)) != SIGTRAP
);
1579 memset(&info
, 0, sizeof info
);
1580 info
.si_signo
= SIGTRAP
;
1581 info
.si_code
= exit_code
;
1582 info
.si_pid
= current
->pid
;
1583 info
.si_uid
= current
->uid
;
1585 /* Let the debugger run. */
1586 spin_lock_irq(¤t
->sighand
->siglock
);
1587 ptrace_stop(exit_code
, 0, &info
);
1588 spin_unlock_irq(¤t
->sighand
->siglock
);
1592 finish_stop(int stop_count
)
1595 * If there are no other threads in the group, or if there is
1596 * a group stop in progress and we are the last to stop,
1597 * report to the parent. When ptraced, every thread reports itself.
1599 if (stop_count
== 0 || (current
->ptrace
& PT_PTRACED
)) {
1600 read_lock(&tasklist_lock
);
1601 do_notify_parent_cldstop(current
, CLD_STOPPED
);
1602 read_unlock(&tasklist_lock
);
1607 } while (try_to_freeze());
1609 * Now we don't run again until continued.
1611 current
->exit_code
= 0;
1615 * This performs the stopping for SIGSTOP and other stop signals.
1616 * We have to stop all threads in the thread group.
1617 * Returns nonzero if we've actually stopped and released the siglock.
1618 * Returns zero if we didn't stop and still hold the siglock.
1620 static int do_signal_stop(int signr
)
1622 struct signal_struct
*sig
= current
->signal
;
1625 if (!likely(sig
->flags
& SIGNAL_STOP_DEQUEUED
))
1628 if (sig
->group_stop_count
> 0) {
1630 * There is a group stop in progress. We don't need to
1631 * start another one.
1633 stop_count
= --sig
->group_stop_count
;
1636 * There is no group stop already in progress.
1637 * We must initiate one now.
1639 struct task_struct
*t
;
1641 sig
->group_exit_code
= signr
;
1644 for (t
= next_thread(current
); t
!= current
; t
= next_thread(t
))
1646 * Setting state to TASK_STOPPED for a group
1647 * stop is always done with the siglock held,
1648 * so this check has no races.
1650 if (!t
->exit_state
&&
1651 !(t
->state
& (TASK_STOPPED
|TASK_TRACED
))) {
1653 signal_wake_up(t
, 0);
1655 sig
->group_stop_count
= stop_count
;
1658 if (stop_count
== 0)
1659 sig
->flags
= SIGNAL_STOP_STOPPED
;
1660 current
->exit_code
= sig
->group_exit_code
;
1661 __set_current_state(TASK_STOPPED
);
1663 spin_unlock_irq(¤t
->sighand
->siglock
);
1664 finish_stop(stop_count
);
1669 * Do appropriate magic when group_stop_count > 0.
1670 * We return nonzero if we stopped, after releasing the siglock.
1671 * We return zero if we still hold the siglock and should look
1672 * for another signal without checking group_stop_count again.
1674 static int handle_group_stop(void)
1678 if (current
->signal
->group_exit_task
== current
) {
1680 * Group stop is so we can do a core dump,
1681 * We are the initiating thread, so get on with it.
1683 current
->signal
->group_exit_task
= NULL
;
1687 if (current
->signal
->flags
& SIGNAL_GROUP_EXIT
)
1689 * Group stop is so another thread can do a core dump,
1690 * or else we are racing against a death signal.
1691 * Just punt the stop so we can get the next signal.
1696 * There is a group stop in progress. We stop
1697 * without any associated signal being in our queue.
1699 stop_count
= --current
->signal
->group_stop_count
;
1700 if (stop_count
== 0)
1701 current
->signal
->flags
= SIGNAL_STOP_STOPPED
;
1702 current
->exit_code
= current
->signal
->group_exit_code
;
1703 set_current_state(TASK_STOPPED
);
1704 spin_unlock_irq(¤t
->sighand
->siglock
);
1705 finish_stop(stop_count
);
1709 int get_signal_to_deliver(siginfo_t
*info
, struct k_sigaction
*return_ka
,
1710 struct pt_regs
*regs
, void *cookie
)
1712 sigset_t
*mask
= ¤t
->blocked
;
1718 spin_lock_irq(¤t
->sighand
->siglock
);
1720 struct k_sigaction
*ka
;
1722 if (unlikely(current
->signal
->group_stop_count
> 0) &&
1723 handle_group_stop())
1726 signr
= dequeue_signal(current
, mask
, info
);
1729 break; /* will return 0 */
1731 if ((current
->ptrace
& PT_PTRACED
) && signr
!= SIGKILL
) {
1732 ptrace_signal_deliver(regs
, cookie
);
1734 /* Let the debugger run. */
1735 ptrace_stop(signr
, signr
, info
);
1737 /* We're back. Did the debugger cancel the sig? */
1738 signr
= current
->exit_code
;
1742 current
->exit_code
= 0;
1744 /* Update the siginfo structure if the signal has
1745 changed. If the debugger wanted something
1746 specific in the siginfo structure then it should
1747 have updated *info via PTRACE_SETSIGINFO. */
1748 if (signr
!= info
->si_signo
) {
1749 info
->si_signo
= signr
;
1751 info
->si_code
= SI_USER
;
1752 info
->si_pid
= current
->parent
->pid
;
1753 info
->si_uid
= current
->parent
->uid
;
1756 /* If the (new) signal is now blocked, requeue it. */
1757 if (sigismember(¤t
->blocked
, signr
)) {
1758 specific_send_sig_info(signr
, info
, current
);
1763 ka
= ¤t
->sighand
->action
[signr
-1];
1764 if (ka
->sa
.sa_handler
== SIG_IGN
) /* Do nothing. */
1766 if (ka
->sa
.sa_handler
!= SIG_DFL
) {
1767 /* Run the handler. */
1770 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
1771 ka
->sa
.sa_handler
= SIG_DFL
;
1773 break; /* will return non-zero "signr" value */
1777 * Now we are doing the default action for this signal.
1779 if (sig_kernel_ignore(signr
)) /* Default is nothing. */
1783 * Init of a pid space gets no signals it doesn't want from
1784 * within that pid space. It can of course get signals from
1785 * its parent pid space.
1787 if (current
== child_reaper(current
))
1790 if (sig_kernel_stop(signr
)) {
1792 * The default action is to stop all threads in
1793 * the thread group. The job control signals
1794 * do nothing in an orphaned pgrp, but SIGSTOP
1795 * always works. Note that siglock needs to be
1796 * dropped during the call to is_orphaned_pgrp()
1797 * because of lock ordering with tasklist_lock.
1798 * This allows an intervening SIGCONT to be posted.
1799 * We need to check for that and bail out if necessary.
1801 if (signr
!= SIGSTOP
) {
1802 spin_unlock_irq(¤t
->sighand
->siglock
);
1804 /* signals can be posted during this window */
1806 if (is_current_pgrp_orphaned())
1809 spin_lock_irq(¤t
->sighand
->siglock
);
1812 if (likely(do_signal_stop(signr
))) {
1813 /* It released the siglock. */
1818 * We didn't actually stop, due to a race
1819 * with SIGCONT or something like that.
1824 spin_unlock_irq(¤t
->sighand
->siglock
);
1827 * Anything else is fatal, maybe with a core dump.
1829 current
->flags
|= PF_SIGNALED
;
1830 if (sig_kernel_coredump(signr
)) {
1832 * If it was able to dump core, this kills all
1833 * other threads in the group and synchronizes with
1834 * their demise. If we lost the race with another
1835 * thread getting here, it set group_exit_code
1836 * first and our do_group_exit call below will use
1837 * that value and ignore the one we pass it.
1839 do_coredump((long)signr
, signr
, regs
);
1843 * Death signals, no core dump.
1845 do_group_exit(signr
);
1848 spin_unlock_irq(¤t
->sighand
->siglock
);
1852 EXPORT_SYMBOL(recalc_sigpending
);
1853 EXPORT_SYMBOL_GPL(dequeue_signal
);
1854 EXPORT_SYMBOL(flush_signals
);
1855 EXPORT_SYMBOL(force_sig
);
1856 EXPORT_SYMBOL(kill_proc
);
1857 EXPORT_SYMBOL(ptrace_notify
);
1858 EXPORT_SYMBOL(send_sig
);
1859 EXPORT_SYMBOL(send_sig_info
);
1860 EXPORT_SYMBOL(sigprocmask
);
1861 EXPORT_SYMBOL(block_all_signals
);
1862 EXPORT_SYMBOL(unblock_all_signals
);
1866 * System call entry points.
1869 asmlinkage
long sys_restart_syscall(void)
1871 struct restart_block
*restart
= ¤t_thread_info()->restart_block
;
1872 return restart
->fn(restart
);
1875 long do_no_restart_syscall(struct restart_block
*param
)
1881 * We don't need to get the kernel lock - this is all local to this
1882 * particular thread.. (and that's good, because this is _heavily_
1883 * used by various programs)
1887 * This is also useful for kernel threads that want to temporarily
1888 * (or permanently) block certain signals.
1890 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1891 * interface happily blocks "unblockable" signals like SIGKILL
1894 int sigprocmask(int how
, sigset_t
*set
, sigset_t
*oldset
)
1898 spin_lock_irq(¤t
->sighand
->siglock
);
1900 *oldset
= current
->blocked
;
1905 sigorsets(¤t
->blocked
, ¤t
->blocked
, set
);
1908 signandsets(¤t
->blocked
, ¤t
->blocked
, set
);
1911 current
->blocked
= *set
;
1916 recalc_sigpending();
1917 spin_unlock_irq(¤t
->sighand
->siglock
);
1923 sys_rt_sigprocmask(int how
, sigset_t __user
*set
, sigset_t __user
*oset
, size_t sigsetsize
)
1925 int error
= -EINVAL
;
1926 sigset_t old_set
, new_set
;
1928 /* XXX: Don't preclude handling different sized sigset_t's. */
1929 if (sigsetsize
!= sizeof(sigset_t
))
1934 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
1936 sigdelsetmask(&new_set
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
1938 error
= sigprocmask(how
, &new_set
, &old_set
);
1944 spin_lock_irq(¤t
->sighand
->siglock
);
1945 old_set
= current
->blocked
;
1946 spin_unlock_irq(¤t
->sighand
->siglock
);
1950 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
1958 long do_sigpending(void __user
*set
, unsigned long sigsetsize
)
1960 long error
= -EINVAL
;
1963 if (sigsetsize
> sizeof(sigset_t
))
1966 spin_lock_irq(¤t
->sighand
->siglock
);
1967 sigorsets(&pending
, ¤t
->pending
.signal
,
1968 ¤t
->signal
->shared_pending
.signal
);
1969 spin_unlock_irq(¤t
->sighand
->siglock
);
1971 /* Outside the lock because only this thread touches it. */
1972 sigandsets(&pending
, ¤t
->blocked
, &pending
);
1975 if (!copy_to_user(set
, &pending
, sigsetsize
))
1983 sys_rt_sigpending(sigset_t __user
*set
, size_t sigsetsize
)
1985 return do_sigpending(set
, sigsetsize
);
1988 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
1990 int copy_siginfo_to_user(siginfo_t __user
*to
, siginfo_t
*from
)
1994 if (!access_ok (VERIFY_WRITE
, to
, sizeof(siginfo_t
)))
1996 if (from
->si_code
< 0)
1997 return __copy_to_user(to
, from
, sizeof(siginfo_t
))
2000 * If you change siginfo_t structure, please be sure
2001 * this code is fixed accordingly.
2002 * Please remember to update the signalfd_copyinfo() function
2003 * inside fs/signalfd.c too, in case siginfo_t changes.
2004 * It should never copy any pad contained in the structure
2005 * to avoid security leaks, but must copy the generic
2006 * 3 ints plus the relevant union member.
2008 err
= __put_user(from
->si_signo
, &to
->si_signo
);
2009 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
2010 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
2011 switch (from
->si_code
& __SI_MASK
) {
2013 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2014 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2017 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
2018 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
2019 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2022 err
|= __put_user(from
->si_band
, &to
->si_band
);
2023 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
2026 err
|= __put_user(from
->si_addr
, &to
->si_addr
);
2027 #ifdef __ARCH_SI_TRAPNO
2028 err
|= __put_user(from
->si_trapno
, &to
->si_trapno
);
2032 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2033 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2034 err
|= __put_user(from
->si_status
, &to
->si_status
);
2035 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
2036 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
2038 case __SI_RT
: /* This is not generated by the kernel as of now. */
2039 case __SI_MESGQ
: /* But this is */
2040 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2041 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2042 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2044 default: /* this is just in case for now ... */
2045 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2046 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2055 sys_rt_sigtimedwait(const sigset_t __user
*uthese
,
2056 siginfo_t __user
*uinfo
,
2057 const struct timespec __user
*uts
,
2066 /* XXX: Don't preclude handling different sized sigset_t's. */
2067 if (sigsetsize
!= sizeof(sigset_t
))
2070 if (copy_from_user(&these
, uthese
, sizeof(these
)))
2074 * Invert the set of allowed signals to get those we
2077 sigdelsetmask(&these
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2081 if (copy_from_user(&ts
, uts
, sizeof(ts
)))
2083 if (ts
.tv_nsec
>= 1000000000L || ts
.tv_nsec
< 0
2088 spin_lock_irq(¤t
->sighand
->siglock
);
2089 sig
= dequeue_signal(current
, &these
, &info
);
2091 timeout
= MAX_SCHEDULE_TIMEOUT
;
2093 timeout
= (timespec_to_jiffies(&ts
)
2094 + (ts
.tv_sec
|| ts
.tv_nsec
));
2097 /* None ready -- temporarily unblock those we're
2098 * interested while we are sleeping in so that we'll
2099 * be awakened when they arrive. */
2100 current
->real_blocked
= current
->blocked
;
2101 sigandsets(¤t
->blocked
, ¤t
->blocked
, &these
);
2102 recalc_sigpending();
2103 spin_unlock_irq(¤t
->sighand
->siglock
);
2105 timeout
= schedule_timeout_interruptible(timeout
);
2107 spin_lock_irq(¤t
->sighand
->siglock
);
2108 sig
= dequeue_signal(current
, &these
, &info
);
2109 current
->blocked
= current
->real_blocked
;
2110 siginitset(¤t
->real_blocked
, 0);
2111 recalc_sigpending();
2114 spin_unlock_irq(¤t
->sighand
->siglock
);
2119 if (copy_siginfo_to_user(uinfo
, &info
))
2132 sys_kill(int pid
, int sig
)
2134 struct siginfo info
;
2136 info
.si_signo
= sig
;
2138 info
.si_code
= SI_USER
;
2139 info
.si_pid
= current
->tgid
;
2140 info
.si_uid
= current
->uid
;
2142 return kill_something_info(sig
, &info
, pid
);
2145 static int do_tkill(int tgid
, int pid
, int sig
)
2148 struct siginfo info
;
2149 struct task_struct
*p
;
2152 info
.si_signo
= sig
;
2154 info
.si_code
= SI_TKILL
;
2155 info
.si_pid
= current
->tgid
;
2156 info
.si_uid
= current
->uid
;
2158 read_lock(&tasklist_lock
);
2159 p
= find_task_by_pid(pid
);
2160 if (p
&& (tgid
<= 0 || p
->tgid
== tgid
)) {
2161 error
= check_kill_permission(sig
, &info
, p
);
2163 * The null signal is a permissions and process existence
2164 * probe. No signal is actually delivered.
2166 if (!error
&& sig
&& p
->sighand
) {
2167 spin_lock_irq(&p
->sighand
->siglock
);
2168 handle_stop_signal(sig
, p
);
2169 error
= specific_send_sig_info(sig
, &info
, p
);
2170 spin_unlock_irq(&p
->sighand
->siglock
);
2173 read_unlock(&tasklist_lock
);
2179 * sys_tgkill - send signal to one specific thread
2180 * @tgid: the thread group ID of the thread
2181 * @pid: the PID of the thread
2182 * @sig: signal to be sent
2184 * This syscall also checks the @tgid and returns -ESRCH even if the PID
2185 * exists but it's not belonging to the target process anymore. This
2186 * method solves the problem of threads exiting and PIDs getting reused.
2188 asmlinkage
long sys_tgkill(int tgid
, int pid
, int sig
)
2190 /* This is only valid for single tasks */
2191 if (pid
<= 0 || tgid
<= 0)
2194 return do_tkill(tgid
, pid
, sig
);
2198 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2201 sys_tkill(int pid
, int sig
)
2203 /* This is only valid for single tasks */
2207 return do_tkill(0, pid
, sig
);
2211 sys_rt_sigqueueinfo(int pid
, int sig
, siginfo_t __user
*uinfo
)
2215 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2218 /* Not even root can pretend to send signals from the kernel.
2219 Nor can they impersonate a kill(), which adds source info. */
2220 if (info
.si_code
>= 0)
2222 info
.si_signo
= sig
;
2224 /* POSIX.1b doesn't mention process groups. */
2225 return kill_proc_info(sig
, &info
, pid
);
2228 int do_sigaction(int sig
, struct k_sigaction
*act
, struct k_sigaction
*oact
)
2230 struct k_sigaction
*k
;
2233 if (!valid_signal(sig
) || sig
< 1 || (act
&& sig_kernel_only(sig
)))
2236 k
= ¤t
->sighand
->action
[sig
-1];
2238 spin_lock_irq(¤t
->sighand
->siglock
);
2239 if (signal_pending(current
)) {
2241 * If there might be a fatal signal pending on multiple
2242 * threads, make sure we take it before changing the action.
2244 spin_unlock_irq(¤t
->sighand
->siglock
);
2245 return -ERESTARTNOINTR
;
2252 sigdelsetmask(&act
->sa
.sa_mask
,
2253 sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2257 * "Setting a signal action to SIG_IGN for a signal that is
2258 * pending shall cause the pending signal to be discarded,
2259 * whether or not it is blocked."
2261 * "Setting a signal action to SIG_DFL for a signal that is
2262 * pending and whose default action is to ignore the signal
2263 * (for example, SIGCHLD), shall cause the pending signal to
2264 * be discarded, whether or not it is blocked"
2266 if (act
->sa
.sa_handler
== SIG_IGN
||
2267 (act
->sa
.sa_handler
== SIG_DFL
&& sig_kernel_ignore(sig
))) {
2268 struct task_struct
*t
= current
;
2270 sigaddset(&mask
, sig
);
2271 rm_from_queue_full(&mask
, &t
->signal
->shared_pending
);
2273 rm_from_queue_full(&mask
, &t
->pending
);
2274 recalc_sigpending_tsk(t
);
2276 } while (t
!= current
);
2280 spin_unlock_irq(¤t
->sighand
->siglock
);
2285 do_sigaltstack (const stack_t __user
*uss
, stack_t __user
*uoss
, unsigned long sp
)
2291 oss
.ss_sp
= (void __user
*) current
->sas_ss_sp
;
2292 oss
.ss_size
= current
->sas_ss_size
;
2293 oss
.ss_flags
= sas_ss_flags(sp
);
2302 if (!access_ok(VERIFY_READ
, uss
, sizeof(*uss
))
2303 || __get_user(ss_sp
, &uss
->ss_sp
)
2304 || __get_user(ss_flags
, &uss
->ss_flags
)
2305 || __get_user(ss_size
, &uss
->ss_size
))
2309 if (on_sig_stack(sp
))
2315 * Note - this code used to test ss_flags incorrectly
2316 * old code may have been written using ss_flags==0
2317 * to mean ss_flags==SS_ONSTACK (as this was the only
2318 * way that worked) - this fix preserves that older
2321 if (ss_flags
!= SS_DISABLE
&& ss_flags
!= SS_ONSTACK
&& ss_flags
!= 0)
2324 if (ss_flags
== SS_DISABLE
) {
2329 if (ss_size
< MINSIGSTKSZ
)
2333 current
->sas_ss_sp
= (unsigned long) ss_sp
;
2334 current
->sas_ss_size
= ss_size
;
2339 if (copy_to_user(uoss
, &oss
, sizeof(oss
)))
2348 #ifdef __ARCH_WANT_SYS_SIGPENDING
2351 sys_sigpending(old_sigset_t __user
*set
)
2353 return do_sigpending(set
, sizeof(*set
));
2358 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2359 /* Some platforms have their own version with special arguments others
2360 support only sys_rt_sigprocmask. */
2363 sys_sigprocmask(int how
, old_sigset_t __user
*set
, old_sigset_t __user
*oset
)
2366 old_sigset_t old_set
, new_set
;
2370 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2372 new_set
&= ~(sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2374 spin_lock_irq(¤t
->sighand
->siglock
);
2375 old_set
= current
->blocked
.sig
[0];
2383 sigaddsetmask(¤t
->blocked
, new_set
);
2386 sigdelsetmask(¤t
->blocked
, new_set
);
2389 current
->blocked
.sig
[0] = new_set
;
2393 recalc_sigpending();
2394 spin_unlock_irq(¤t
->sighand
->siglock
);
2400 old_set
= current
->blocked
.sig
[0];
2403 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2410 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2412 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2414 sys_rt_sigaction(int sig
,
2415 const struct sigaction __user
*act
,
2416 struct sigaction __user
*oact
,
2419 struct k_sigaction new_sa
, old_sa
;
2422 /* XXX: Don't preclude handling different sized sigset_t's. */
2423 if (sigsetsize
!= sizeof(sigset_t
))
2427 if (copy_from_user(&new_sa
.sa
, act
, sizeof(new_sa
.sa
)))
2431 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
2434 if (copy_to_user(oact
, &old_sa
.sa
, sizeof(old_sa
.sa
)))
2440 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2442 #ifdef __ARCH_WANT_SYS_SGETMASK
2445 * For backwards compatibility. Functionality superseded by sigprocmask.
2451 return current
->blocked
.sig
[0];
2455 sys_ssetmask(int newmask
)
2459 spin_lock_irq(¤t
->sighand
->siglock
);
2460 old
= current
->blocked
.sig
[0];
2462 siginitset(¤t
->blocked
, newmask
& ~(sigmask(SIGKILL
)|
2464 recalc_sigpending();
2465 spin_unlock_irq(¤t
->sighand
->siglock
);
2469 #endif /* __ARCH_WANT_SGETMASK */
2471 #ifdef __ARCH_WANT_SYS_SIGNAL
2473 * For backwards compatibility. Functionality superseded by sigaction.
2475 asmlinkage
unsigned long
2476 sys_signal(int sig
, __sighandler_t handler
)
2478 struct k_sigaction new_sa
, old_sa
;
2481 new_sa
.sa
.sa_handler
= handler
;
2482 new_sa
.sa
.sa_flags
= SA_ONESHOT
| SA_NOMASK
;
2483 sigemptyset(&new_sa
.sa
.sa_mask
);
2485 ret
= do_sigaction(sig
, &new_sa
, &old_sa
);
2487 return ret
? ret
: (unsigned long)old_sa
.sa
.sa_handler
;
2489 #endif /* __ARCH_WANT_SYS_SIGNAL */
2491 #ifdef __ARCH_WANT_SYS_PAUSE
2496 current
->state
= TASK_INTERRUPTIBLE
;
2498 return -ERESTARTNOHAND
;
2503 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2504 asmlinkage
long sys_rt_sigsuspend(sigset_t __user
*unewset
, size_t sigsetsize
)
2508 /* XXX: Don't preclude handling different sized sigset_t's. */
2509 if (sigsetsize
!= sizeof(sigset_t
))
2512 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
2514 sigdelsetmask(&newset
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2516 spin_lock_irq(¤t
->sighand
->siglock
);
2517 current
->saved_sigmask
= current
->blocked
;
2518 current
->blocked
= newset
;
2519 recalc_sigpending();
2520 spin_unlock_irq(¤t
->sighand
->siglock
);
2522 current
->state
= TASK_INTERRUPTIBLE
;
2524 set_thread_flag(TIF_RESTORE_SIGMASK
);
2525 return -ERESTARTNOHAND
;
2527 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2529 __attribute__((weak
)) const char *arch_vma_name(struct vm_area_struct
*vma
)
2534 void __init
signals_init(void)
2536 sigqueue_cachep
= KMEM_CACHE(sigqueue
, SLAB_PANIC
);