2 * linux/kernel/signal.c
4 * Copyright (C) 1991, 1992 Linus Torvalds
6 * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson
8 * 2003-06-02 Jim Houston - Concurrent Computer Corp.
9 * Changes to use preallocated sigqueue structures
10 * to allow signals to be sent reliably.
13 #include <linux/config.h>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/smp_lock.h>
17 #include <linux/init.h>
18 #include <linux/sched.h>
20 #include <linux/tty.h>
21 #include <linux/binfmts.h>
22 #include <linux/security.h>
23 #include <linux/syscalls.h>
24 #include <linux/ptrace.h>
25 #include <linux/signal.h>
26 #include <linux/capability.h>
27 #include <asm/param.h>
28 #include <asm/uaccess.h>
29 #include <asm/unistd.h>
30 #include <asm/siginfo.h>
31 #include "audit.h" /* audit_signal_info() */
34 * SLAB caches for signal bits.
37 static kmem_cache_t
*sigqueue_cachep
;
40 * In POSIX a signal is sent either to a specific thread (Linux task)
41 * or to the process as a whole (Linux thread group). How the signal
42 * is sent determines whether it's to one thread or the whole group,
43 * which determines which signal mask(s) are involved in blocking it
44 * from being delivered until later. When the signal is delivered,
45 * either it's caught or ignored by a user handler or it has a default
46 * effect that applies to the whole thread group (POSIX process).
48 * The possible effects an unblocked signal set to SIG_DFL can have are:
49 * ignore - Nothing Happens
50 * terminate - kill the process, i.e. all threads in the group,
51 * similar to exit_group. The group leader (only) reports
52 * WIFSIGNALED status to its parent.
53 * coredump - write a core dump file describing all threads using
54 * the same mm and then kill all those threads
55 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
57 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
58 * Other signals when not blocked and set to SIG_DFL behaves as follows.
59 * The job control signals also have other special effects.
61 * +--------------------+------------------+
62 * | POSIX signal | default action |
63 * +--------------------+------------------+
64 * | SIGHUP | terminate |
65 * | SIGINT | terminate |
66 * | SIGQUIT | coredump |
67 * | SIGILL | coredump |
68 * | SIGTRAP | coredump |
69 * | SIGABRT/SIGIOT | coredump |
70 * | SIGBUS | coredump |
71 * | SIGFPE | coredump |
72 * | SIGKILL | terminate(+) |
73 * | SIGUSR1 | terminate |
74 * | SIGSEGV | coredump |
75 * | SIGUSR2 | terminate |
76 * | SIGPIPE | terminate |
77 * | SIGALRM | terminate |
78 * | SIGTERM | terminate |
79 * | SIGCHLD | ignore |
80 * | SIGCONT | ignore(*) |
81 * | SIGSTOP | stop(*)(+) |
82 * | SIGTSTP | stop(*) |
83 * | SIGTTIN | stop(*) |
84 * | SIGTTOU | stop(*) |
86 * | SIGXCPU | coredump |
87 * | SIGXFSZ | coredump |
88 * | SIGVTALRM | terminate |
89 * | SIGPROF | terminate |
90 * | SIGPOLL/SIGIO | terminate |
91 * | SIGSYS/SIGUNUSED | coredump |
92 * | SIGSTKFLT | terminate |
93 * | SIGWINCH | ignore |
94 * | SIGPWR | terminate |
95 * | SIGRTMIN-SIGRTMAX | terminate |
96 * +--------------------+------------------+
97 * | non-POSIX signal | default action |
98 * +--------------------+------------------+
99 * | SIGEMT | coredump |
100 * +--------------------+------------------+
102 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
103 * (*) Special job control effects:
104 * When SIGCONT is sent, it resumes the process (all threads in the group)
105 * from TASK_STOPPED state and also clears any pending/queued stop signals
106 * (any of those marked with "stop(*)"). This happens regardless of blocking,
107 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
108 * any pending/queued SIGCONT signals; this happens regardless of blocking,
109 * catching, or ignored the stop signal, though (except for SIGSTOP) the
110 * default action of stopping the process may happen later or never.
114 #define M_SIGEMT M(SIGEMT)
119 #if SIGRTMIN > BITS_PER_LONG
120 #define M(sig) (1ULL << ((sig)-1))
122 #define M(sig) (1UL << ((sig)-1))
124 #define T(sig, mask) (M(sig) & (mask))
126 #define SIG_KERNEL_ONLY_MASK (\
127 M(SIGKILL) | M(SIGSTOP) )
129 #define SIG_KERNEL_STOP_MASK (\
130 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
132 #define SIG_KERNEL_COREDUMP_MASK (\
133 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
134 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
135 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
137 #define SIG_KERNEL_IGNORE_MASK (\
138 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
140 #define sig_kernel_only(sig) \
141 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
142 #define sig_kernel_coredump(sig) \
143 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
144 #define sig_kernel_ignore(sig) \
145 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
146 #define sig_kernel_stop(sig) \
147 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
149 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
151 #define sig_user_defined(t, signr) \
152 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
153 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
155 #define sig_fatal(t, signr) \
156 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
157 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
159 static int sig_ignored(struct task_struct
*t
, int sig
)
161 void __user
* handler
;
164 * Tracers always want to know about signals..
166 if (t
->ptrace
& PT_PTRACED
)
170 * Blocked signals are never ignored, since the
171 * signal handler may change by the time it is
174 if (sigismember(&t
->blocked
, sig
))
177 /* Is it explicitly or implicitly ignored? */
178 handler
= t
->sighand
->action
[sig
-1].sa
.sa_handler
;
179 return handler
== SIG_IGN
||
180 (handler
== SIG_DFL
&& sig_kernel_ignore(sig
));
184 * Re-calculate pending state from the set of locally pending
185 * signals, globally pending signals, and blocked signals.
187 static inline int has_pending_signals(sigset_t
*signal
, sigset_t
*blocked
)
192 switch (_NSIG_WORDS
) {
194 for (i
= _NSIG_WORDS
, ready
= 0; --i
>= 0 ;)
195 ready
|= signal
->sig
[i
] &~ blocked
->sig
[i
];
198 case 4: ready
= signal
->sig
[3] &~ blocked
->sig
[3];
199 ready
|= signal
->sig
[2] &~ blocked
->sig
[2];
200 ready
|= signal
->sig
[1] &~ blocked
->sig
[1];
201 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
204 case 2: ready
= signal
->sig
[1] &~ blocked
->sig
[1];
205 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
208 case 1: ready
= signal
->sig
[0] &~ blocked
->sig
[0];
213 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
215 fastcall
void recalc_sigpending_tsk(struct task_struct
*t
)
217 if (t
->signal
->group_stop_count
> 0 ||
219 PENDING(&t
->pending
, &t
->blocked
) ||
220 PENDING(&t
->signal
->shared_pending
, &t
->blocked
))
221 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
223 clear_tsk_thread_flag(t
, TIF_SIGPENDING
);
226 void recalc_sigpending(void)
228 recalc_sigpending_tsk(current
);
231 /* Given the mask, find the first available signal that should be serviced. */
234 next_signal(struct sigpending
*pending
, sigset_t
*mask
)
236 unsigned long i
, *s
, *m
, x
;
239 s
= pending
->signal
.sig
;
241 switch (_NSIG_WORDS
) {
243 for (i
= 0; i
< _NSIG_WORDS
; ++i
, ++s
, ++m
)
244 if ((x
= *s
&~ *m
) != 0) {
245 sig
= ffz(~x
) + i
*_NSIG_BPW
+ 1;
250 case 2: if ((x
= s
[0] &~ m
[0]) != 0)
252 else if ((x
= s
[1] &~ m
[1]) != 0)
259 case 1: if ((x
= *s
&~ *m
) != 0)
267 static struct sigqueue
*__sigqueue_alloc(struct task_struct
*t
, gfp_t flags
,
270 struct sigqueue
*q
= NULL
;
272 atomic_inc(&t
->user
->sigpending
);
273 if (override_rlimit
||
274 atomic_read(&t
->user
->sigpending
) <=
275 t
->signal
->rlim
[RLIMIT_SIGPENDING
].rlim_cur
)
276 q
= kmem_cache_alloc(sigqueue_cachep
, flags
);
277 if (unlikely(q
== NULL
)) {
278 atomic_dec(&t
->user
->sigpending
);
280 INIT_LIST_HEAD(&q
->list
);
282 q
->user
= get_uid(t
->user
);
287 static void __sigqueue_free(struct sigqueue
*q
)
289 if (q
->flags
& SIGQUEUE_PREALLOC
)
291 atomic_dec(&q
->user
->sigpending
);
293 kmem_cache_free(sigqueue_cachep
, q
);
296 void flush_sigqueue(struct sigpending
*queue
)
300 sigemptyset(&queue
->signal
);
301 while (!list_empty(&queue
->list
)) {
302 q
= list_entry(queue
->list
.next
, struct sigqueue
, list
);
303 list_del_init(&q
->list
);
309 * Flush all pending signals for a task.
311 void flush_signals(struct task_struct
*t
)
315 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
316 clear_tsk_thread_flag(t
,TIF_SIGPENDING
);
317 flush_sigqueue(&t
->pending
);
318 flush_sigqueue(&t
->signal
->shared_pending
);
319 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
323 * Flush all handlers for a task.
327 flush_signal_handlers(struct task_struct
*t
, int force_default
)
330 struct k_sigaction
*ka
= &t
->sighand
->action
[0];
331 for (i
= _NSIG
; i
!= 0 ; i
--) {
332 if (force_default
|| ka
->sa
.sa_handler
!= SIG_IGN
)
333 ka
->sa
.sa_handler
= SIG_DFL
;
335 sigemptyset(&ka
->sa
.sa_mask
);
341 /* Notify the system that a driver wants to block all signals for this
342 * process, and wants to be notified if any signals at all were to be
343 * sent/acted upon. If the notifier routine returns non-zero, then the
344 * signal will be acted upon after all. If the notifier routine returns 0,
345 * then then signal will be blocked. Only one block per process is
346 * allowed. priv is a pointer to private data that the notifier routine
347 * can use to determine if the signal should be blocked or not. */
350 block_all_signals(int (*notifier
)(void *priv
), void *priv
, sigset_t
*mask
)
354 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
355 current
->notifier_mask
= mask
;
356 current
->notifier_data
= priv
;
357 current
->notifier
= notifier
;
358 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
361 /* Notify the system that blocking has ended. */
364 unblock_all_signals(void)
368 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
369 current
->notifier
= NULL
;
370 current
->notifier_data
= NULL
;
372 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
375 static int collect_signal(int sig
, struct sigpending
*list
, siginfo_t
*info
)
377 struct sigqueue
*q
, *first
= NULL
;
378 int still_pending
= 0;
380 if (unlikely(!sigismember(&list
->signal
, sig
)))
384 * Collect the siginfo appropriate to this signal. Check if
385 * there is another siginfo for the same signal.
387 list_for_each_entry(q
, &list
->list
, list
) {
388 if (q
->info
.si_signo
== sig
) {
397 list_del_init(&first
->list
);
398 copy_siginfo(info
, &first
->info
);
399 __sigqueue_free(first
);
401 sigdelset(&list
->signal
, sig
);
404 /* Ok, it wasn't in the queue. This must be
405 a fast-pathed signal or we must have been
406 out of queue space. So zero out the info.
408 sigdelset(&list
->signal
, sig
);
409 info
->si_signo
= sig
;
418 static int __dequeue_signal(struct sigpending
*pending
, sigset_t
*mask
,
423 sig
= next_signal(pending
, mask
);
425 if (current
->notifier
) {
426 if (sigismember(current
->notifier_mask
, sig
)) {
427 if (!(current
->notifier
)(current
->notifier_data
)) {
428 clear_thread_flag(TIF_SIGPENDING
);
434 if (!collect_signal(sig
, pending
, info
))
444 * Dequeue a signal and return the element to the caller, which is
445 * expected to free it.
447 * All callers have to hold the siglock.
449 int dequeue_signal(struct task_struct
*tsk
, sigset_t
*mask
, siginfo_t
*info
)
451 int signr
= __dequeue_signal(&tsk
->pending
, mask
, info
);
453 signr
= __dequeue_signal(&tsk
->signal
->shared_pending
,
455 if (signr
&& unlikely(sig_kernel_stop(signr
))) {
457 * Set a marker that we have dequeued a stop signal. Our
458 * caller might release the siglock and then the pending
459 * stop signal it is about to process is no longer in the
460 * pending bitmasks, but must still be cleared by a SIGCONT
461 * (and overruled by a SIGKILL). So those cases clear this
462 * shared flag after we've set it. Note that this flag may
463 * remain set after the signal we return is ignored or
464 * handled. That doesn't matter because its only purpose
465 * is to alert stop-signal processing code when another
466 * processor has come along and cleared the flag.
468 if (!(tsk
->signal
->flags
& SIGNAL_GROUP_EXIT
))
469 tsk
->signal
->flags
|= SIGNAL_STOP_DEQUEUED
;
472 ((info
->si_code
& __SI_MASK
) == __SI_TIMER
) &&
473 info
->si_sys_private
){
475 * Release the siglock to ensure proper locking order
476 * of timer locks outside of siglocks. Note, we leave
477 * irqs disabled here, since the posix-timers code is
478 * about to disable them again anyway.
480 spin_unlock(&tsk
->sighand
->siglock
);
481 do_schedule_next_timer(info
);
482 spin_lock(&tsk
->sighand
->siglock
);
488 * Tell a process that it has a new active signal..
490 * NOTE! we rely on the previous spin_lock to
491 * lock interrupts for us! We can only be called with
492 * "siglock" held, and the local interrupt must
493 * have been disabled when that got acquired!
495 * No need to set need_resched since signal event passing
496 * goes through ->blocked
498 void signal_wake_up(struct task_struct
*t
, int resume
)
502 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
505 * For SIGKILL, we want to wake it up in the stopped/traced case.
506 * We don't check t->state here because there is a race with it
507 * executing another processor and just now entering stopped state.
508 * By using wake_up_state, we ensure the process will wake up and
509 * handle its death signal.
511 mask
= TASK_INTERRUPTIBLE
;
513 mask
|= TASK_STOPPED
| TASK_TRACED
;
514 if (!wake_up_state(t
, mask
))
519 * Remove signals in mask from the pending set and queue.
520 * Returns 1 if any signals were found.
522 * All callers must be holding the siglock.
524 * This version takes a sigset mask and looks at all signals,
525 * not just those in the first mask word.
527 static int rm_from_queue_full(sigset_t
*mask
, struct sigpending
*s
)
529 struct sigqueue
*q
, *n
;
532 sigandsets(&m
, mask
, &s
->signal
);
533 if (sigisemptyset(&m
))
536 signandsets(&s
->signal
, &s
->signal
, mask
);
537 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
538 if (sigismember(mask
, q
->info
.si_signo
)) {
539 list_del_init(&q
->list
);
546 * Remove signals in mask from the pending set and queue.
547 * Returns 1 if any signals were found.
549 * All callers must be holding the siglock.
551 static int rm_from_queue(unsigned long mask
, struct sigpending
*s
)
553 struct sigqueue
*q
, *n
;
555 if (!sigtestsetmask(&s
->signal
, mask
))
558 sigdelsetmask(&s
->signal
, mask
);
559 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
560 if (q
->info
.si_signo
< SIGRTMIN
&&
561 (mask
& sigmask(q
->info
.si_signo
))) {
562 list_del_init(&q
->list
);
570 * Bad permissions for sending the signal
572 static int check_kill_permission(int sig
, struct siginfo
*info
,
573 struct task_struct
*t
)
576 if (!valid_signal(sig
))
579 if ((info
== SEND_SIG_NOINFO
|| (!is_si_special(info
) && SI_FROMUSER(info
)))
580 && ((sig
!= SIGCONT
) ||
581 (current
->signal
->session
!= t
->signal
->session
))
582 && (current
->euid
^ t
->suid
) && (current
->euid
^ t
->uid
)
583 && (current
->uid
^ t
->suid
) && (current
->uid
^ t
->uid
)
584 && !capable(CAP_KILL
))
587 error
= security_task_kill(t
, info
, sig
, 0);
589 audit_signal_info(sig
, t
); /* Let audit system see the signal */
594 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
);
597 * Handle magic process-wide effects of stop/continue signals.
598 * Unlike the signal actions, these happen immediately at signal-generation
599 * time regardless of blocking, ignoring, or handling. This does the
600 * actual continuing for SIGCONT, but not the actual stopping for stop
601 * signals. The process stop is done as a signal action for SIG_DFL.
603 static void handle_stop_signal(int sig
, struct task_struct
*p
)
605 struct task_struct
*t
;
607 if (p
->signal
->flags
& SIGNAL_GROUP_EXIT
)
609 * The process is in the middle of dying already.
613 if (sig_kernel_stop(sig
)) {
615 * This is a stop signal. Remove SIGCONT from all queues.
617 rm_from_queue(sigmask(SIGCONT
), &p
->signal
->shared_pending
);
620 rm_from_queue(sigmask(SIGCONT
), &t
->pending
);
623 } else if (sig
== SIGCONT
) {
625 * Remove all stop signals from all queues,
626 * and wake all threads.
628 if (unlikely(p
->signal
->group_stop_count
> 0)) {
630 * There was a group stop in progress. We'll
631 * pretend it finished before we got here. We are
632 * obliged to report it to the parent: if the
633 * SIGSTOP happened "after" this SIGCONT, then it
634 * would have cleared this pending SIGCONT. If it
635 * happened "before" this SIGCONT, then the parent
636 * got the SIGCHLD about the stop finishing before
637 * the continue happened. We do the notification
638 * now, and it's as if the stop had finished and
639 * the SIGCHLD was pending on entry to this kill.
641 p
->signal
->group_stop_count
= 0;
642 p
->signal
->flags
= SIGNAL_STOP_CONTINUED
;
643 spin_unlock(&p
->sighand
->siglock
);
644 do_notify_parent_cldstop(p
, CLD_STOPPED
);
645 spin_lock(&p
->sighand
->siglock
);
647 rm_from_queue(SIG_KERNEL_STOP_MASK
, &p
->signal
->shared_pending
);
651 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
654 * If there is a handler for SIGCONT, we must make
655 * sure that no thread returns to user mode before
656 * we post the signal, in case it was the only
657 * thread eligible to run the signal handler--then
658 * it must not do anything between resuming and
659 * running the handler. With the TIF_SIGPENDING
660 * flag set, the thread will pause and acquire the
661 * siglock that we hold now and until we've queued
662 * the pending signal.
664 * Wake up the stopped thread _after_ setting
667 state
= TASK_STOPPED
;
668 if (sig_user_defined(t
, SIGCONT
) && !sigismember(&t
->blocked
, SIGCONT
)) {
669 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
670 state
|= TASK_INTERRUPTIBLE
;
672 wake_up_state(t
, state
);
677 if (p
->signal
->flags
& SIGNAL_STOP_STOPPED
) {
679 * We were in fact stopped, and are now continued.
680 * Notify the parent with CLD_CONTINUED.
682 p
->signal
->flags
= SIGNAL_STOP_CONTINUED
;
683 p
->signal
->group_exit_code
= 0;
684 spin_unlock(&p
->sighand
->siglock
);
685 do_notify_parent_cldstop(p
, CLD_CONTINUED
);
686 spin_lock(&p
->sighand
->siglock
);
689 * We are not stopped, but there could be a stop
690 * signal in the middle of being processed after
691 * being removed from the queue. Clear that too.
693 p
->signal
->flags
= 0;
695 } else if (sig
== SIGKILL
) {
697 * Make sure that any pending stop signal already dequeued
698 * is undone by the wakeup for SIGKILL.
700 p
->signal
->flags
= 0;
704 static int send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
705 struct sigpending
*signals
)
707 struct sigqueue
* q
= NULL
;
711 * fast-pathed signals for kernel-internal things like SIGSTOP
714 if (info
== SEND_SIG_FORCED
)
717 /* Real-time signals must be queued if sent by sigqueue, or
718 some other real-time mechanism. It is implementation
719 defined whether kill() does so. We attempt to do so, on
720 the principle of least surprise, but since kill is not
721 allowed to fail with EAGAIN when low on memory we just
722 make sure at least one signal gets delivered and don't
723 pass on the info struct. */
725 q
= __sigqueue_alloc(t
, GFP_ATOMIC
, (sig
< SIGRTMIN
&&
726 (is_si_special(info
) ||
727 info
->si_code
>= 0)));
729 list_add_tail(&q
->list
, &signals
->list
);
730 switch ((unsigned long) info
) {
731 case (unsigned long) SEND_SIG_NOINFO
:
732 q
->info
.si_signo
= sig
;
733 q
->info
.si_errno
= 0;
734 q
->info
.si_code
= SI_USER
;
735 q
->info
.si_pid
= current
->pid
;
736 q
->info
.si_uid
= current
->uid
;
738 case (unsigned long) SEND_SIG_PRIV
:
739 q
->info
.si_signo
= sig
;
740 q
->info
.si_errno
= 0;
741 q
->info
.si_code
= SI_KERNEL
;
746 copy_siginfo(&q
->info
, info
);
749 } else if (!is_si_special(info
)) {
750 if (sig
>= SIGRTMIN
&& info
->si_code
!= SI_USER
)
752 * Queue overflow, abort. We may abort if the signal was rt
753 * and sent by user using something other than kill().
759 sigaddset(&signals
->signal
, sig
);
763 #define LEGACY_QUEUE(sigptr, sig) \
764 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
768 specific_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
772 BUG_ON(!irqs_disabled());
773 assert_spin_locked(&t
->sighand
->siglock
);
775 /* Short-circuit ignored signals. */
776 if (sig_ignored(t
, sig
))
779 /* Support queueing exactly one non-rt signal, so that we
780 can get more detailed information about the cause of
782 if (LEGACY_QUEUE(&t
->pending
, sig
))
785 ret
= send_signal(sig
, info
, t
, &t
->pending
);
786 if (!ret
&& !sigismember(&t
->blocked
, sig
))
787 signal_wake_up(t
, sig
== SIGKILL
);
793 * Force a signal that the process can't ignore: if necessary
794 * we unblock the signal and change any SIG_IGN to SIG_DFL.
798 force_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
800 unsigned long int flags
;
803 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
804 if (t
->sighand
->action
[sig
-1].sa
.sa_handler
== SIG_IGN
) {
805 t
->sighand
->action
[sig
-1].sa
.sa_handler
= SIG_DFL
;
807 if (sigismember(&t
->blocked
, sig
)) {
808 sigdelset(&t
->blocked
, sig
);
810 recalc_sigpending_tsk(t
);
811 ret
= specific_send_sig_info(sig
, info
, t
);
812 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
818 force_sig_specific(int sig
, struct task_struct
*t
)
820 force_sig_info(sig
, SEND_SIG_FORCED
, t
);
824 * Test if P wants to take SIG. After we've checked all threads with this,
825 * it's equivalent to finding no threads not blocking SIG. Any threads not
826 * blocking SIG were ruled out because they are not running and already
827 * have pending signals. Such threads will dequeue from the shared queue
828 * as soon as they're available, so putting the signal on the shared queue
829 * will be equivalent to sending it to one such thread.
831 static inline int wants_signal(int sig
, struct task_struct
*p
)
833 if (sigismember(&p
->blocked
, sig
))
835 if (p
->flags
& PF_EXITING
)
839 if (p
->state
& (TASK_STOPPED
| TASK_TRACED
))
841 return task_curr(p
) || !signal_pending(p
);
845 __group_complete_signal(int sig
, struct task_struct
*p
)
847 struct task_struct
*t
;
850 * Now find a thread we can wake up to take the signal off the queue.
852 * If the main thread wants the signal, it gets first crack.
853 * Probably the least surprising to the average bear.
855 if (wants_signal(sig
, p
))
857 else if (thread_group_empty(p
))
859 * There is just one thread and it does not need to be woken.
860 * It will dequeue unblocked signals before it runs again.
865 * Otherwise try to find a suitable thread.
867 t
= p
->signal
->curr_target
;
869 /* restart balancing at this thread */
870 t
= p
->signal
->curr_target
= p
;
872 while (!wants_signal(sig
, t
)) {
874 if (t
== p
->signal
->curr_target
)
876 * No thread needs to be woken.
877 * Any eligible threads will see
878 * the signal in the queue soon.
882 p
->signal
->curr_target
= t
;
886 * Found a killable thread. If the signal will be fatal,
887 * then start taking the whole group down immediately.
889 if (sig_fatal(p
, sig
) && !(p
->signal
->flags
& SIGNAL_GROUP_EXIT
) &&
890 !sigismember(&t
->real_blocked
, sig
) &&
891 (sig
== SIGKILL
|| !(t
->ptrace
& PT_PTRACED
))) {
893 * This signal will be fatal to the whole group.
895 if (!sig_kernel_coredump(sig
)) {
897 * Start a group exit and wake everybody up.
898 * This way we don't have other threads
899 * running and doing things after a slower
900 * thread has the fatal signal pending.
902 p
->signal
->flags
= SIGNAL_GROUP_EXIT
;
903 p
->signal
->group_exit_code
= sig
;
904 p
->signal
->group_stop_count
= 0;
907 sigaddset(&t
->pending
.signal
, SIGKILL
);
908 signal_wake_up(t
, 1);
915 * There will be a core dump. We make all threads other
916 * than the chosen one go into a group stop so that nothing
917 * happens until it gets scheduled, takes the signal off
918 * the shared queue, and does the core dump. This is a
919 * little more complicated than strictly necessary, but it
920 * keeps the signal state that winds up in the core dump
921 * unchanged from the death state, e.g. which thread had
922 * the core-dump signal unblocked.
924 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
925 rm_from_queue(SIG_KERNEL_STOP_MASK
, &p
->signal
->shared_pending
);
926 p
->signal
->group_stop_count
= 0;
927 p
->signal
->group_exit_task
= t
;
930 p
->signal
->group_stop_count
++;
931 signal_wake_up(t
, 0);
934 wake_up_process(p
->signal
->group_exit_task
);
939 * The signal is already in the shared-pending queue.
940 * Tell the chosen thread to wake up and dequeue it.
942 signal_wake_up(t
, sig
== SIGKILL
);
947 __group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
951 assert_spin_locked(&p
->sighand
->siglock
);
952 handle_stop_signal(sig
, p
);
954 /* Short-circuit ignored signals. */
955 if (sig_ignored(p
, sig
))
958 if (LEGACY_QUEUE(&p
->signal
->shared_pending
, sig
))
959 /* This is a non-RT signal and we already have one queued. */
963 * Put this signal on the shared-pending queue, or fail with EAGAIN.
964 * We always use the shared queue for process-wide signals,
965 * to avoid several races.
967 ret
= send_signal(sig
, info
, p
, &p
->signal
->shared_pending
);
971 __group_complete_signal(sig
, p
);
976 * Nuke all other threads in the group.
978 void zap_other_threads(struct task_struct
*p
)
980 struct task_struct
*t
;
982 p
->signal
->flags
= SIGNAL_GROUP_EXIT
;
983 p
->signal
->group_stop_count
= 0;
985 if (thread_group_empty(p
))
988 for (t
= next_thread(p
); t
!= p
; t
= next_thread(t
)) {
990 * Don't bother with already dead threads
996 * We don't want to notify the parent, since we are
997 * killed as part of a thread group due to another
998 * thread doing an execve() or similar. So set the
999 * exit signal to -1 to allow immediate reaping of
1000 * the process. But don't detach the thread group
1003 if (t
!= p
->group_leader
)
1004 t
->exit_signal
= -1;
1006 /* SIGKILL will be handled before any pending SIGSTOP */
1007 sigaddset(&t
->pending
.signal
, SIGKILL
);
1008 signal_wake_up(t
, 1);
1013 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1015 struct sighand_struct
*lock_task_sighand(struct task_struct
*tsk
, unsigned long *flags
)
1017 struct sighand_struct
*sighand
;
1020 sighand
= rcu_dereference(tsk
->sighand
);
1021 if (unlikely(sighand
== NULL
))
1024 spin_lock_irqsave(&sighand
->siglock
, *flags
);
1025 if (likely(sighand
== tsk
->sighand
))
1027 spin_unlock_irqrestore(&sighand
->siglock
, *flags
);
1033 int group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1035 unsigned long flags
;
1038 ret
= check_kill_permission(sig
, info
, p
);
1042 if (lock_task_sighand(p
, &flags
)) {
1043 ret
= __group_send_sig_info(sig
, info
, p
);
1044 unlock_task_sighand(p
, &flags
);
1052 * kill_pg_info() sends a signal to a process group: this is what the tty
1053 * control characters do (^C, ^Z etc)
1056 int __kill_pg_info(int sig
, struct siginfo
*info
, pid_t pgrp
)
1058 struct task_struct
*p
= NULL
;
1059 int retval
, success
;
1066 do_each_task_pid(pgrp
, PIDTYPE_PGID
, p
) {
1067 int err
= group_send_sig_info(sig
, info
, p
);
1070 } while_each_task_pid(pgrp
, PIDTYPE_PGID
, p
);
1071 return success
? 0 : retval
;
1075 kill_pg_info(int sig
, struct siginfo
*info
, pid_t pgrp
)
1079 read_lock(&tasklist_lock
);
1080 retval
= __kill_pg_info(sig
, info
, pgrp
);
1081 read_unlock(&tasklist_lock
);
1087 kill_proc_info(int sig
, struct siginfo
*info
, pid_t pid
)
1090 int acquired_tasklist_lock
= 0;
1091 struct task_struct
*p
;
1094 if (unlikely(sig_needs_tasklist(sig
))) {
1095 read_lock(&tasklist_lock
);
1096 acquired_tasklist_lock
= 1;
1098 p
= find_task_by_pid(pid
);
1101 error
= group_send_sig_info(sig
, info
, p
);
1102 if (unlikely(acquired_tasklist_lock
))
1103 read_unlock(&tasklist_lock
);
1108 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1109 int kill_proc_info_as_uid(int sig
, struct siginfo
*info
, pid_t pid
,
1110 uid_t uid
, uid_t euid
, u32 secid
)
1113 struct task_struct
*p
;
1115 if (!valid_signal(sig
))
1118 read_lock(&tasklist_lock
);
1119 p
= find_task_by_pid(pid
);
1124 if ((info
== SEND_SIG_NOINFO
|| (!is_si_special(info
) && SI_FROMUSER(info
)))
1125 && (euid
!= p
->suid
) && (euid
!= p
->uid
)
1126 && (uid
!= p
->suid
) && (uid
!= p
->uid
)) {
1130 ret
= security_task_kill(p
, info
, sig
, secid
);
1133 if (sig
&& p
->sighand
) {
1134 unsigned long flags
;
1135 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1136 ret
= __group_send_sig_info(sig
, info
, p
);
1137 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1140 read_unlock(&tasklist_lock
);
1143 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid
);
1146 * kill_something_info() interprets pid in interesting ways just like kill(2).
1148 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1149 * is probably wrong. Should make it like BSD or SYSV.
1152 static int kill_something_info(int sig
, struct siginfo
*info
, int pid
)
1155 return kill_pg_info(sig
, info
, process_group(current
));
1156 } else if (pid
== -1) {
1157 int retval
= 0, count
= 0;
1158 struct task_struct
* p
;
1160 read_lock(&tasklist_lock
);
1161 for_each_process(p
) {
1162 if (p
->pid
> 1 && p
->tgid
!= current
->tgid
) {
1163 int err
= group_send_sig_info(sig
, info
, p
);
1169 read_unlock(&tasklist_lock
);
1170 return count
? retval
: -ESRCH
;
1171 } else if (pid
< 0) {
1172 return kill_pg_info(sig
, info
, -pid
);
1174 return kill_proc_info(sig
, info
, pid
);
1179 * These are for backward compatibility with the rest of the kernel source.
1183 * These two are the most common entry points. They send a signal
1184 * just to the specific thread.
1187 send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1190 unsigned long flags
;
1193 * Make sure legacy kernel users don't send in bad values
1194 * (normal paths check this in check_kill_permission).
1196 if (!valid_signal(sig
))
1200 * We need the tasklist lock even for the specific
1201 * thread case (when we don't need to follow the group
1202 * lists) in order to avoid races with "p->sighand"
1203 * going away or changing from under us.
1205 read_lock(&tasklist_lock
);
1206 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1207 ret
= specific_send_sig_info(sig
, info
, p
);
1208 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1209 read_unlock(&tasklist_lock
);
1213 #define __si_special(priv) \
1214 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1217 send_sig(int sig
, struct task_struct
*p
, int priv
)
1219 return send_sig_info(sig
, __si_special(priv
), p
);
1223 * This is the entry point for "process-wide" signals.
1224 * They will go to an appropriate thread in the thread group.
1227 send_group_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1230 read_lock(&tasklist_lock
);
1231 ret
= group_send_sig_info(sig
, info
, p
);
1232 read_unlock(&tasklist_lock
);
1237 force_sig(int sig
, struct task_struct
*p
)
1239 force_sig_info(sig
, SEND_SIG_PRIV
, p
);
1243 * When things go south during signal handling, we
1244 * will force a SIGSEGV. And if the signal that caused
1245 * the problem was already a SIGSEGV, we'll want to
1246 * make sure we don't even try to deliver the signal..
1249 force_sigsegv(int sig
, struct task_struct
*p
)
1251 if (sig
== SIGSEGV
) {
1252 unsigned long flags
;
1253 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1254 p
->sighand
->action
[sig
- 1].sa
.sa_handler
= SIG_DFL
;
1255 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1257 force_sig(SIGSEGV
, p
);
1262 kill_pg(pid_t pgrp
, int sig
, int priv
)
1264 return kill_pg_info(sig
, __si_special(priv
), pgrp
);
1268 kill_proc(pid_t pid
, int sig
, int priv
)
1270 return kill_proc_info(sig
, __si_special(priv
), pid
);
1274 * These functions support sending signals using preallocated sigqueue
1275 * structures. This is needed "because realtime applications cannot
1276 * afford to lose notifications of asynchronous events, like timer
1277 * expirations or I/O completions". In the case of Posix Timers
1278 * we allocate the sigqueue structure from the timer_create. If this
1279 * allocation fails we are able to report the failure to the application
1280 * with an EAGAIN error.
1283 struct sigqueue
*sigqueue_alloc(void)
1287 if ((q
= __sigqueue_alloc(current
, GFP_KERNEL
, 0)))
1288 q
->flags
|= SIGQUEUE_PREALLOC
;
1292 void sigqueue_free(struct sigqueue
*q
)
1294 unsigned long flags
;
1295 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1297 * If the signal is still pending remove it from the
1300 if (unlikely(!list_empty(&q
->list
))) {
1301 spinlock_t
*lock
= ¤t
->sighand
->siglock
;
1302 read_lock(&tasklist_lock
);
1303 spin_lock_irqsave(lock
, flags
);
1304 if (!list_empty(&q
->list
))
1305 list_del_init(&q
->list
);
1306 spin_unlock_irqrestore(lock
, flags
);
1307 read_unlock(&tasklist_lock
);
1309 q
->flags
&= ~SIGQUEUE_PREALLOC
;
1313 int send_sigqueue(int sig
, struct sigqueue
*q
, struct task_struct
*p
)
1315 unsigned long flags
;
1318 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1321 * The rcu based delayed sighand destroy makes it possible to
1322 * run this without tasklist lock held. The task struct itself
1323 * cannot go away as create_timer did get_task_struct().
1325 * We return -1, when the task is marked exiting, so
1326 * posix_timer_event can redirect it to the group leader
1330 if (!likely(lock_task_sighand(p
, &flags
))) {
1335 if (unlikely(!list_empty(&q
->list
))) {
1337 * If an SI_TIMER entry is already queue just increment
1338 * the overrun count.
1340 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1341 q
->info
.si_overrun
++;
1344 /* Short-circuit ignored signals. */
1345 if (sig_ignored(p
, sig
)) {
1350 list_add_tail(&q
->list
, &p
->pending
.list
);
1351 sigaddset(&p
->pending
.signal
, sig
);
1352 if (!sigismember(&p
->blocked
, sig
))
1353 signal_wake_up(p
, sig
== SIGKILL
);
1356 unlock_task_sighand(p
, &flags
);
1364 send_group_sigqueue(int sig
, struct sigqueue
*q
, struct task_struct
*p
)
1366 unsigned long flags
;
1369 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1371 read_lock(&tasklist_lock
);
1372 /* Since it_lock is held, p->sighand cannot be NULL. */
1373 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1374 handle_stop_signal(sig
, p
);
1376 /* Short-circuit ignored signals. */
1377 if (sig_ignored(p
, sig
)) {
1382 if (unlikely(!list_empty(&q
->list
))) {
1384 * If an SI_TIMER entry is already queue just increment
1385 * the overrun count. Other uses should not try to
1386 * send the signal multiple times.
1388 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1389 q
->info
.si_overrun
++;
1394 * Put this signal on the shared-pending queue.
1395 * We always use the shared queue for process-wide signals,
1396 * to avoid several races.
1398 list_add_tail(&q
->list
, &p
->signal
->shared_pending
.list
);
1399 sigaddset(&p
->signal
->shared_pending
.signal
, sig
);
1401 __group_complete_signal(sig
, p
);
1403 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1404 read_unlock(&tasklist_lock
);
1409 * Wake up any threads in the parent blocked in wait* syscalls.
1411 static inline void __wake_up_parent(struct task_struct
*p
,
1412 struct task_struct
*parent
)
1414 wake_up_interruptible_sync(&parent
->signal
->wait_chldexit
);
1418 * Let a parent know about the death of a child.
1419 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1422 void do_notify_parent(struct task_struct
*tsk
, int sig
)
1424 struct siginfo info
;
1425 unsigned long flags
;
1426 struct sighand_struct
*psig
;
1430 /* do_notify_parent_cldstop should have been called instead. */
1431 BUG_ON(tsk
->state
& (TASK_STOPPED
|TASK_TRACED
));
1433 BUG_ON(!tsk
->ptrace
&&
1434 (tsk
->group_leader
!= tsk
|| !thread_group_empty(tsk
)));
1436 info
.si_signo
= sig
;
1438 info
.si_pid
= tsk
->pid
;
1439 info
.si_uid
= tsk
->uid
;
1441 /* FIXME: find out whether or not this is supposed to be c*time. */
1442 info
.si_utime
= cputime_to_jiffies(cputime_add(tsk
->utime
,
1443 tsk
->signal
->utime
));
1444 info
.si_stime
= cputime_to_jiffies(cputime_add(tsk
->stime
,
1445 tsk
->signal
->stime
));
1447 info
.si_status
= tsk
->exit_code
& 0x7f;
1448 if (tsk
->exit_code
& 0x80)
1449 info
.si_code
= CLD_DUMPED
;
1450 else if (tsk
->exit_code
& 0x7f)
1451 info
.si_code
= CLD_KILLED
;
1453 info
.si_code
= CLD_EXITED
;
1454 info
.si_status
= tsk
->exit_code
>> 8;
1457 psig
= tsk
->parent
->sighand
;
1458 spin_lock_irqsave(&psig
->siglock
, flags
);
1459 if (!tsk
->ptrace
&& sig
== SIGCHLD
&&
1460 (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
||
1461 (psig
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDWAIT
))) {
1463 * We are exiting and our parent doesn't care. POSIX.1
1464 * defines special semantics for setting SIGCHLD to SIG_IGN
1465 * or setting the SA_NOCLDWAIT flag: we should be reaped
1466 * automatically and not left for our parent's wait4 call.
1467 * Rather than having the parent do it as a magic kind of
1468 * signal handler, we just set this to tell do_exit that we
1469 * can be cleaned up without becoming a zombie. Note that
1470 * we still call __wake_up_parent in this case, because a
1471 * blocked sys_wait4 might now return -ECHILD.
1473 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1474 * is implementation-defined: we do (if you don't want
1475 * it, just use SIG_IGN instead).
1477 tsk
->exit_signal
= -1;
1478 if (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
)
1481 if (valid_signal(sig
) && sig
> 0)
1482 __group_send_sig_info(sig
, &info
, tsk
->parent
);
1483 __wake_up_parent(tsk
, tsk
->parent
);
1484 spin_unlock_irqrestore(&psig
->siglock
, flags
);
1487 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
)
1489 struct siginfo info
;
1490 unsigned long flags
;
1491 struct task_struct
*parent
;
1492 struct sighand_struct
*sighand
;
1494 if (tsk
->ptrace
& PT_PTRACED
)
1495 parent
= tsk
->parent
;
1497 tsk
= tsk
->group_leader
;
1498 parent
= tsk
->real_parent
;
1501 info
.si_signo
= SIGCHLD
;
1503 info
.si_pid
= tsk
->pid
;
1504 info
.si_uid
= tsk
->uid
;
1506 /* FIXME: find out whether or not this is supposed to be c*time. */
1507 info
.si_utime
= cputime_to_jiffies(tsk
->utime
);
1508 info
.si_stime
= cputime_to_jiffies(tsk
->stime
);
1513 info
.si_status
= SIGCONT
;
1516 info
.si_status
= tsk
->signal
->group_exit_code
& 0x7f;
1519 info
.si_status
= tsk
->exit_code
& 0x7f;
1525 sighand
= parent
->sighand
;
1526 spin_lock_irqsave(&sighand
->siglock
, flags
);
1527 if (sighand
->action
[SIGCHLD
-1].sa
.sa_handler
!= SIG_IGN
&&
1528 !(sighand
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDSTOP
))
1529 __group_send_sig_info(SIGCHLD
, &info
, parent
);
1531 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1533 __wake_up_parent(tsk
, parent
);
1534 spin_unlock_irqrestore(&sighand
->siglock
, flags
);
1537 static inline int may_ptrace_stop(void)
1539 if (!likely(current
->ptrace
& PT_PTRACED
))
1542 if (unlikely(current
->parent
== current
->real_parent
&&
1543 (current
->ptrace
& PT_ATTACHED
)))
1546 if (unlikely(current
->signal
== current
->parent
->signal
) &&
1547 unlikely(current
->signal
->flags
& SIGNAL_GROUP_EXIT
))
1551 * Are we in the middle of do_coredump?
1552 * If so and our tracer is also part of the coredump stopping
1553 * is a deadlock situation, and pointless because our tracer
1554 * is dead so don't allow us to stop.
1555 * If SIGKILL was already sent before the caller unlocked
1556 * ->siglock we must see ->core_waiters != 0. Otherwise it
1557 * is safe to enter schedule().
1559 if (unlikely(current
->mm
->core_waiters
) &&
1560 unlikely(current
->mm
== current
->parent
->mm
))
1567 * This must be called with current->sighand->siglock held.
1569 * This should be the path for all ptrace stops.
1570 * We always set current->last_siginfo while stopped here.
1571 * That makes it a way to test a stopped process for
1572 * being ptrace-stopped vs being job-control-stopped.
1574 * If we actually decide not to stop at all because the tracer is gone,
1575 * we leave nostop_code in current->exit_code.
1577 static void ptrace_stop(int exit_code
, int nostop_code
, siginfo_t
*info
)
1580 * If there is a group stop in progress,
1581 * we must participate in the bookkeeping.
1583 if (current
->signal
->group_stop_count
> 0)
1584 --current
->signal
->group_stop_count
;
1586 current
->last_siginfo
= info
;
1587 current
->exit_code
= exit_code
;
1589 /* Let the debugger run. */
1590 set_current_state(TASK_TRACED
);
1591 spin_unlock_irq(¤t
->sighand
->siglock
);
1593 read_lock(&tasklist_lock
);
1594 if (may_ptrace_stop()) {
1595 do_notify_parent_cldstop(current
, CLD_TRAPPED
);
1596 read_unlock(&tasklist_lock
);
1600 * By the time we got the lock, our tracer went away.
1603 read_unlock(&tasklist_lock
);
1604 set_current_state(TASK_RUNNING
);
1605 current
->exit_code
= nostop_code
;
1609 * We are back. Now reacquire the siglock before touching
1610 * last_siginfo, so that we are sure to have synchronized with
1611 * any signal-sending on another CPU that wants to examine it.
1613 spin_lock_irq(¤t
->sighand
->siglock
);
1614 current
->last_siginfo
= NULL
;
1617 * Queued signals ignored us while we were stopped for tracing.
1618 * So check for any that we should take before resuming user mode.
1620 recalc_sigpending();
1623 void ptrace_notify(int exit_code
)
1627 BUG_ON((exit_code
& (0x7f | ~0xffff)) != SIGTRAP
);
1629 memset(&info
, 0, sizeof info
);
1630 info
.si_signo
= SIGTRAP
;
1631 info
.si_code
= exit_code
;
1632 info
.si_pid
= current
->pid
;
1633 info
.si_uid
= current
->uid
;
1635 /* Let the debugger run. */
1636 spin_lock_irq(¤t
->sighand
->siglock
);
1637 ptrace_stop(exit_code
, 0, &info
);
1638 spin_unlock_irq(¤t
->sighand
->siglock
);
1642 finish_stop(int stop_count
)
1645 * If there are no other threads in the group, or if there is
1646 * a group stop in progress and we are the last to stop,
1647 * report to the parent. When ptraced, every thread reports itself.
1649 if (stop_count
== 0 || (current
->ptrace
& PT_PTRACED
)) {
1650 read_lock(&tasklist_lock
);
1651 do_notify_parent_cldstop(current
, CLD_STOPPED
);
1652 read_unlock(&tasklist_lock
);
1657 * Now we don't run again until continued.
1659 current
->exit_code
= 0;
1663 * This performs the stopping for SIGSTOP and other stop signals.
1664 * We have to stop all threads in the thread group.
1665 * Returns nonzero if we've actually stopped and released the siglock.
1666 * Returns zero if we didn't stop and still hold the siglock.
1668 static int do_signal_stop(int signr
)
1670 struct signal_struct
*sig
= current
->signal
;
1673 if (!likely(sig
->flags
& SIGNAL_STOP_DEQUEUED
))
1676 if (sig
->group_stop_count
> 0) {
1678 * There is a group stop in progress. We don't need to
1679 * start another one.
1681 stop_count
= --sig
->group_stop_count
;
1684 * There is no group stop already in progress.
1685 * We must initiate one now.
1687 struct task_struct
*t
;
1689 sig
->group_exit_code
= signr
;
1692 for (t
= next_thread(current
); t
!= current
; t
= next_thread(t
))
1694 * Setting state to TASK_STOPPED for a group
1695 * stop is always done with the siglock held,
1696 * so this check has no races.
1698 if (!t
->exit_state
&&
1699 !(t
->state
& (TASK_STOPPED
|TASK_TRACED
))) {
1701 signal_wake_up(t
, 0);
1703 sig
->group_stop_count
= stop_count
;
1706 if (stop_count
== 0)
1707 sig
->flags
= SIGNAL_STOP_STOPPED
;
1708 current
->exit_code
= sig
->group_exit_code
;
1709 __set_current_state(TASK_STOPPED
);
1711 spin_unlock_irq(¤t
->sighand
->siglock
);
1712 finish_stop(stop_count
);
1717 * Do appropriate magic when group_stop_count > 0.
1718 * We return nonzero if we stopped, after releasing the siglock.
1719 * We return zero if we still hold the siglock and should look
1720 * for another signal without checking group_stop_count again.
1722 static int handle_group_stop(void)
1726 if (current
->signal
->group_exit_task
== current
) {
1728 * Group stop is so we can do a core dump,
1729 * We are the initiating thread, so get on with it.
1731 current
->signal
->group_exit_task
= NULL
;
1735 if (current
->signal
->flags
& SIGNAL_GROUP_EXIT
)
1737 * Group stop is so another thread can do a core dump,
1738 * or else we are racing against a death signal.
1739 * Just punt the stop so we can get the next signal.
1744 * There is a group stop in progress. We stop
1745 * without any associated signal being in our queue.
1747 stop_count
= --current
->signal
->group_stop_count
;
1748 if (stop_count
== 0)
1749 current
->signal
->flags
= SIGNAL_STOP_STOPPED
;
1750 current
->exit_code
= current
->signal
->group_exit_code
;
1751 set_current_state(TASK_STOPPED
);
1752 spin_unlock_irq(¤t
->sighand
->siglock
);
1753 finish_stop(stop_count
);
1757 int get_signal_to_deliver(siginfo_t
*info
, struct k_sigaction
*return_ka
,
1758 struct pt_regs
*regs
, void *cookie
)
1760 sigset_t
*mask
= ¤t
->blocked
;
1766 spin_lock_irq(¤t
->sighand
->siglock
);
1768 struct k_sigaction
*ka
;
1770 if (unlikely(current
->signal
->group_stop_count
> 0) &&
1771 handle_group_stop())
1774 signr
= dequeue_signal(current
, mask
, info
);
1777 break; /* will return 0 */
1779 if ((current
->ptrace
& PT_PTRACED
) && signr
!= SIGKILL
) {
1780 ptrace_signal_deliver(regs
, cookie
);
1782 /* Let the debugger run. */
1783 ptrace_stop(signr
, signr
, info
);
1785 /* We're back. Did the debugger cancel the sig? */
1786 signr
= current
->exit_code
;
1790 current
->exit_code
= 0;
1792 /* Update the siginfo structure if the signal has
1793 changed. If the debugger wanted something
1794 specific in the siginfo structure then it should
1795 have updated *info via PTRACE_SETSIGINFO. */
1796 if (signr
!= info
->si_signo
) {
1797 info
->si_signo
= signr
;
1799 info
->si_code
= SI_USER
;
1800 info
->si_pid
= current
->parent
->pid
;
1801 info
->si_uid
= current
->parent
->uid
;
1804 /* If the (new) signal is now blocked, requeue it. */
1805 if (sigismember(¤t
->blocked
, signr
)) {
1806 specific_send_sig_info(signr
, info
, current
);
1811 ka
= ¤t
->sighand
->action
[signr
-1];
1812 if (ka
->sa
.sa_handler
== SIG_IGN
) /* Do nothing. */
1814 if (ka
->sa
.sa_handler
!= SIG_DFL
) {
1815 /* Run the handler. */
1818 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
1819 ka
->sa
.sa_handler
= SIG_DFL
;
1821 break; /* will return non-zero "signr" value */
1825 * Now we are doing the default action for this signal.
1827 if (sig_kernel_ignore(signr
)) /* Default is nothing. */
1830 /* Init gets no signals it doesn't want. */
1831 if (current
== child_reaper
)
1834 if (sig_kernel_stop(signr
)) {
1836 * The default action is to stop all threads in
1837 * the thread group. The job control signals
1838 * do nothing in an orphaned pgrp, but SIGSTOP
1839 * always works. Note that siglock needs to be
1840 * dropped during the call to is_orphaned_pgrp()
1841 * because of lock ordering with tasklist_lock.
1842 * This allows an intervening SIGCONT to be posted.
1843 * We need to check for that and bail out if necessary.
1845 if (signr
!= SIGSTOP
) {
1846 spin_unlock_irq(¤t
->sighand
->siglock
);
1848 /* signals can be posted during this window */
1850 if (is_orphaned_pgrp(process_group(current
)))
1853 spin_lock_irq(¤t
->sighand
->siglock
);
1856 if (likely(do_signal_stop(signr
))) {
1857 /* It released the siglock. */
1862 * We didn't actually stop, due to a race
1863 * with SIGCONT or something like that.
1868 spin_unlock_irq(¤t
->sighand
->siglock
);
1871 * Anything else is fatal, maybe with a core dump.
1873 current
->flags
|= PF_SIGNALED
;
1874 if (sig_kernel_coredump(signr
)) {
1876 * If it was able to dump core, this kills all
1877 * other threads in the group and synchronizes with
1878 * their demise. If we lost the race with another
1879 * thread getting here, it set group_exit_code
1880 * first and our do_group_exit call below will use
1881 * that value and ignore the one we pass it.
1883 do_coredump((long)signr
, signr
, regs
);
1887 * Death signals, no core dump.
1889 do_group_exit(signr
);
1892 spin_unlock_irq(¤t
->sighand
->siglock
);
1896 EXPORT_SYMBOL(recalc_sigpending
);
1897 EXPORT_SYMBOL_GPL(dequeue_signal
);
1898 EXPORT_SYMBOL(flush_signals
);
1899 EXPORT_SYMBOL(force_sig
);
1900 EXPORT_SYMBOL(kill_pg
);
1901 EXPORT_SYMBOL(kill_proc
);
1902 EXPORT_SYMBOL(ptrace_notify
);
1903 EXPORT_SYMBOL(send_sig
);
1904 EXPORT_SYMBOL(send_sig_info
);
1905 EXPORT_SYMBOL(sigprocmask
);
1906 EXPORT_SYMBOL(block_all_signals
);
1907 EXPORT_SYMBOL(unblock_all_signals
);
1911 * System call entry points.
1914 asmlinkage
long sys_restart_syscall(void)
1916 struct restart_block
*restart
= ¤t_thread_info()->restart_block
;
1917 return restart
->fn(restart
);
1920 long do_no_restart_syscall(struct restart_block
*param
)
1926 * We don't need to get the kernel lock - this is all local to this
1927 * particular thread.. (and that's good, because this is _heavily_
1928 * used by various programs)
1932 * This is also useful for kernel threads that want to temporarily
1933 * (or permanently) block certain signals.
1935 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1936 * interface happily blocks "unblockable" signals like SIGKILL
1939 int sigprocmask(int how
, sigset_t
*set
, sigset_t
*oldset
)
1943 spin_lock_irq(¤t
->sighand
->siglock
);
1945 *oldset
= current
->blocked
;
1950 sigorsets(¤t
->blocked
, ¤t
->blocked
, set
);
1953 signandsets(¤t
->blocked
, ¤t
->blocked
, set
);
1956 current
->blocked
= *set
;
1961 recalc_sigpending();
1962 spin_unlock_irq(¤t
->sighand
->siglock
);
1968 sys_rt_sigprocmask(int how
, sigset_t __user
*set
, sigset_t __user
*oset
, size_t sigsetsize
)
1970 int error
= -EINVAL
;
1971 sigset_t old_set
, new_set
;
1973 /* XXX: Don't preclude handling different sized sigset_t's. */
1974 if (sigsetsize
!= sizeof(sigset_t
))
1979 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
1981 sigdelsetmask(&new_set
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
1983 error
= sigprocmask(how
, &new_set
, &old_set
);
1989 spin_lock_irq(¤t
->sighand
->siglock
);
1990 old_set
= current
->blocked
;
1991 spin_unlock_irq(¤t
->sighand
->siglock
);
1995 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2003 long do_sigpending(void __user
*set
, unsigned long sigsetsize
)
2005 long error
= -EINVAL
;
2008 if (sigsetsize
> sizeof(sigset_t
))
2011 spin_lock_irq(¤t
->sighand
->siglock
);
2012 sigorsets(&pending
, ¤t
->pending
.signal
,
2013 ¤t
->signal
->shared_pending
.signal
);
2014 spin_unlock_irq(¤t
->sighand
->siglock
);
2016 /* Outside the lock because only this thread touches it. */
2017 sigandsets(&pending
, ¤t
->blocked
, &pending
);
2020 if (!copy_to_user(set
, &pending
, sigsetsize
))
2028 sys_rt_sigpending(sigset_t __user
*set
, size_t sigsetsize
)
2030 return do_sigpending(set
, sigsetsize
);
2033 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2035 int copy_siginfo_to_user(siginfo_t __user
*to
, siginfo_t
*from
)
2039 if (!access_ok (VERIFY_WRITE
, to
, sizeof(siginfo_t
)))
2041 if (from
->si_code
< 0)
2042 return __copy_to_user(to
, from
, sizeof(siginfo_t
))
2045 * If you change siginfo_t structure, please be sure
2046 * this code is fixed accordingly.
2047 * It should never copy any pad contained in the structure
2048 * to avoid security leaks, but must copy the generic
2049 * 3 ints plus the relevant union member.
2051 err
= __put_user(from
->si_signo
, &to
->si_signo
);
2052 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
2053 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
2054 switch (from
->si_code
& __SI_MASK
) {
2056 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2057 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2060 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
2061 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
2062 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2065 err
|= __put_user(from
->si_band
, &to
->si_band
);
2066 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
2069 err
|= __put_user(from
->si_addr
, &to
->si_addr
);
2070 #ifdef __ARCH_SI_TRAPNO
2071 err
|= __put_user(from
->si_trapno
, &to
->si_trapno
);
2075 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2076 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2077 err
|= __put_user(from
->si_status
, &to
->si_status
);
2078 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
2079 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
2081 case __SI_RT
: /* This is not generated by the kernel as of now. */
2082 case __SI_MESGQ
: /* But this is */
2083 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2084 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2085 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2087 default: /* this is just in case for now ... */
2088 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2089 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2098 sys_rt_sigtimedwait(const sigset_t __user
*uthese
,
2099 siginfo_t __user
*uinfo
,
2100 const struct timespec __user
*uts
,
2109 /* XXX: Don't preclude handling different sized sigset_t's. */
2110 if (sigsetsize
!= sizeof(sigset_t
))
2113 if (copy_from_user(&these
, uthese
, sizeof(these
)))
2117 * Invert the set of allowed signals to get those we
2120 sigdelsetmask(&these
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2124 if (copy_from_user(&ts
, uts
, sizeof(ts
)))
2126 if (ts
.tv_nsec
>= 1000000000L || ts
.tv_nsec
< 0
2131 spin_lock_irq(¤t
->sighand
->siglock
);
2132 sig
= dequeue_signal(current
, &these
, &info
);
2134 timeout
= MAX_SCHEDULE_TIMEOUT
;
2136 timeout
= (timespec_to_jiffies(&ts
)
2137 + (ts
.tv_sec
|| ts
.tv_nsec
));
2140 /* None ready -- temporarily unblock those we're
2141 * interested while we are sleeping in so that we'll
2142 * be awakened when they arrive. */
2143 current
->real_blocked
= current
->blocked
;
2144 sigandsets(¤t
->blocked
, ¤t
->blocked
, &these
);
2145 recalc_sigpending();
2146 spin_unlock_irq(¤t
->sighand
->siglock
);
2148 timeout
= schedule_timeout_interruptible(timeout
);
2150 spin_lock_irq(¤t
->sighand
->siglock
);
2151 sig
= dequeue_signal(current
, &these
, &info
);
2152 current
->blocked
= current
->real_blocked
;
2153 siginitset(¤t
->real_blocked
, 0);
2154 recalc_sigpending();
2157 spin_unlock_irq(¤t
->sighand
->siglock
);
2162 if (copy_siginfo_to_user(uinfo
, &info
))
2175 sys_kill(int pid
, int sig
)
2177 struct siginfo info
;
2179 info
.si_signo
= sig
;
2181 info
.si_code
= SI_USER
;
2182 info
.si_pid
= current
->tgid
;
2183 info
.si_uid
= current
->uid
;
2185 return kill_something_info(sig
, &info
, pid
);
2188 static int do_tkill(int tgid
, int pid
, int sig
)
2191 struct siginfo info
;
2192 struct task_struct
*p
;
2195 info
.si_signo
= sig
;
2197 info
.si_code
= SI_TKILL
;
2198 info
.si_pid
= current
->tgid
;
2199 info
.si_uid
= current
->uid
;
2201 read_lock(&tasklist_lock
);
2202 p
= find_task_by_pid(pid
);
2203 if (p
&& (tgid
<= 0 || p
->tgid
== tgid
)) {
2204 error
= check_kill_permission(sig
, &info
, p
);
2206 * The null signal is a permissions and process existence
2207 * probe. No signal is actually delivered.
2209 if (!error
&& sig
&& p
->sighand
) {
2210 spin_lock_irq(&p
->sighand
->siglock
);
2211 handle_stop_signal(sig
, p
);
2212 error
= specific_send_sig_info(sig
, &info
, p
);
2213 spin_unlock_irq(&p
->sighand
->siglock
);
2216 read_unlock(&tasklist_lock
);
2222 * sys_tgkill - send signal to one specific thread
2223 * @tgid: the thread group ID of the thread
2224 * @pid: the PID of the thread
2225 * @sig: signal to be sent
2227 * This syscall also checks the tgid and returns -ESRCH even if the PID
2228 * exists but it's not belonging to the target process anymore. This
2229 * method solves the problem of threads exiting and PIDs getting reused.
2231 asmlinkage
long sys_tgkill(int tgid
, int pid
, int sig
)
2233 /* This is only valid for single tasks */
2234 if (pid
<= 0 || tgid
<= 0)
2237 return do_tkill(tgid
, pid
, sig
);
2241 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2244 sys_tkill(int pid
, int sig
)
2246 /* This is only valid for single tasks */
2250 return do_tkill(0, pid
, sig
);
2254 sys_rt_sigqueueinfo(int pid
, int sig
, siginfo_t __user
*uinfo
)
2258 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2261 /* Not even root can pretend to send signals from the kernel.
2262 Nor can they impersonate a kill(), which adds source info. */
2263 if (info
.si_code
>= 0)
2265 info
.si_signo
= sig
;
2267 /* POSIX.1b doesn't mention process groups. */
2268 return kill_proc_info(sig
, &info
, pid
);
2271 int do_sigaction(int sig
, struct k_sigaction
*act
, struct k_sigaction
*oact
)
2273 struct k_sigaction
*k
;
2276 if (!valid_signal(sig
) || sig
< 1 || (act
&& sig_kernel_only(sig
)))
2279 k
= ¤t
->sighand
->action
[sig
-1];
2281 spin_lock_irq(¤t
->sighand
->siglock
);
2282 if (signal_pending(current
)) {
2284 * If there might be a fatal signal pending on multiple
2285 * threads, make sure we take it before changing the action.
2287 spin_unlock_irq(¤t
->sighand
->siglock
);
2288 return -ERESTARTNOINTR
;
2295 sigdelsetmask(&act
->sa
.sa_mask
,
2296 sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2300 * "Setting a signal action to SIG_IGN for a signal that is
2301 * pending shall cause the pending signal to be discarded,
2302 * whether or not it is blocked."
2304 * "Setting a signal action to SIG_DFL for a signal that is
2305 * pending and whose default action is to ignore the signal
2306 * (for example, SIGCHLD), shall cause the pending signal to
2307 * be discarded, whether or not it is blocked"
2309 if (act
->sa
.sa_handler
== SIG_IGN
||
2310 (act
->sa
.sa_handler
== SIG_DFL
&& sig_kernel_ignore(sig
))) {
2311 struct task_struct
*t
= current
;
2313 sigaddset(&mask
, sig
);
2314 rm_from_queue_full(&mask
, &t
->signal
->shared_pending
);
2316 rm_from_queue_full(&mask
, &t
->pending
);
2317 recalc_sigpending_tsk(t
);
2319 } while (t
!= current
);
2323 spin_unlock_irq(¤t
->sighand
->siglock
);
2328 do_sigaltstack (const stack_t __user
*uss
, stack_t __user
*uoss
, unsigned long sp
)
2334 oss
.ss_sp
= (void __user
*) current
->sas_ss_sp
;
2335 oss
.ss_size
= current
->sas_ss_size
;
2336 oss
.ss_flags
= sas_ss_flags(sp
);
2345 if (!access_ok(VERIFY_READ
, uss
, sizeof(*uss
))
2346 || __get_user(ss_sp
, &uss
->ss_sp
)
2347 || __get_user(ss_flags
, &uss
->ss_flags
)
2348 || __get_user(ss_size
, &uss
->ss_size
))
2352 if (on_sig_stack(sp
))
2358 * Note - this code used to test ss_flags incorrectly
2359 * old code may have been written using ss_flags==0
2360 * to mean ss_flags==SS_ONSTACK (as this was the only
2361 * way that worked) - this fix preserves that older
2364 if (ss_flags
!= SS_DISABLE
&& ss_flags
!= SS_ONSTACK
&& ss_flags
!= 0)
2367 if (ss_flags
== SS_DISABLE
) {
2372 if (ss_size
< MINSIGSTKSZ
)
2376 current
->sas_ss_sp
= (unsigned long) ss_sp
;
2377 current
->sas_ss_size
= ss_size
;
2382 if (copy_to_user(uoss
, &oss
, sizeof(oss
)))
2391 #ifdef __ARCH_WANT_SYS_SIGPENDING
2394 sys_sigpending(old_sigset_t __user
*set
)
2396 return do_sigpending(set
, sizeof(*set
));
2401 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2402 /* Some platforms have their own version with special arguments others
2403 support only sys_rt_sigprocmask. */
2406 sys_sigprocmask(int how
, old_sigset_t __user
*set
, old_sigset_t __user
*oset
)
2409 old_sigset_t old_set
, new_set
;
2413 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2415 new_set
&= ~(sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2417 spin_lock_irq(¤t
->sighand
->siglock
);
2418 old_set
= current
->blocked
.sig
[0];
2426 sigaddsetmask(¤t
->blocked
, new_set
);
2429 sigdelsetmask(¤t
->blocked
, new_set
);
2432 current
->blocked
.sig
[0] = new_set
;
2436 recalc_sigpending();
2437 spin_unlock_irq(¤t
->sighand
->siglock
);
2443 old_set
= current
->blocked
.sig
[0];
2446 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2453 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2455 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2457 sys_rt_sigaction(int sig
,
2458 const struct sigaction __user
*act
,
2459 struct sigaction __user
*oact
,
2462 struct k_sigaction new_sa
, old_sa
;
2465 /* XXX: Don't preclude handling different sized sigset_t's. */
2466 if (sigsetsize
!= sizeof(sigset_t
))
2470 if (copy_from_user(&new_sa
.sa
, act
, sizeof(new_sa
.sa
)))
2474 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
2477 if (copy_to_user(oact
, &old_sa
.sa
, sizeof(old_sa
.sa
)))
2483 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2485 #ifdef __ARCH_WANT_SYS_SGETMASK
2488 * For backwards compatibility. Functionality superseded by sigprocmask.
2494 return current
->blocked
.sig
[0];
2498 sys_ssetmask(int newmask
)
2502 spin_lock_irq(¤t
->sighand
->siglock
);
2503 old
= current
->blocked
.sig
[0];
2505 siginitset(¤t
->blocked
, newmask
& ~(sigmask(SIGKILL
)|
2507 recalc_sigpending();
2508 spin_unlock_irq(¤t
->sighand
->siglock
);
2512 #endif /* __ARCH_WANT_SGETMASK */
2514 #ifdef __ARCH_WANT_SYS_SIGNAL
2516 * For backwards compatibility. Functionality superseded by sigaction.
2518 asmlinkage
unsigned long
2519 sys_signal(int sig
, __sighandler_t handler
)
2521 struct k_sigaction new_sa
, old_sa
;
2524 new_sa
.sa
.sa_handler
= handler
;
2525 new_sa
.sa
.sa_flags
= SA_ONESHOT
| SA_NOMASK
;
2526 sigemptyset(&new_sa
.sa
.sa_mask
);
2528 ret
= do_sigaction(sig
, &new_sa
, &old_sa
);
2530 return ret
? ret
: (unsigned long)old_sa
.sa
.sa_handler
;
2532 #endif /* __ARCH_WANT_SYS_SIGNAL */
2534 #ifdef __ARCH_WANT_SYS_PAUSE
2539 current
->state
= TASK_INTERRUPTIBLE
;
2541 return -ERESTARTNOHAND
;
2546 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2547 asmlinkage
long sys_rt_sigsuspend(sigset_t __user
*unewset
, size_t sigsetsize
)
2551 /* XXX: Don't preclude handling different sized sigset_t's. */
2552 if (sigsetsize
!= sizeof(sigset_t
))
2555 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
2557 sigdelsetmask(&newset
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2559 spin_lock_irq(¤t
->sighand
->siglock
);
2560 current
->saved_sigmask
= current
->blocked
;
2561 current
->blocked
= newset
;
2562 recalc_sigpending();
2563 spin_unlock_irq(¤t
->sighand
->siglock
);
2565 current
->state
= TASK_INTERRUPTIBLE
;
2567 set_thread_flag(TIF_RESTORE_SIGMASK
);
2568 return -ERESTARTNOHAND
;
2570 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2572 void __init
signals_init(void)
2575 kmem_cache_create("sigqueue",
2576 sizeof(struct sigqueue
),
2577 __alignof__(struct sigqueue
),
2578 SLAB_PANIC
, NULL
, NULL
);