]>
git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - kernel/signal.c
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/smp_lock.h>
16 #include <linux/init.h>
17 #include <linux/sched.h>
19 #include <linux/tty.h>
20 #include <linux/binfmts.h>
21 #include <linux/security.h>
22 #include <linux/syscalls.h>
23 #include <linux/ptrace.h>
24 #include <linux/signal.h>
25 #include <linux/capability.h>
26 #include <asm/param.h>
27 #include <asm/uaccess.h>
28 #include <asm/unistd.h>
29 #include <asm/siginfo.h>
30 #include "audit.h" /* audit_signal_info() */
33 * SLAB caches for signal bits.
36 static kmem_cache_t
*sigqueue_cachep
;
39 * In POSIX a signal is sent either to a specific thread (Linux task)
40 * or to the process as a whole (Linux thread group). How the signal
41 * is sent determines whether it's to one thread or the whole group,
42 * which determines which signal mask(s) are involved in blocking it
43 * from being delivered until later. When the signal is delivered,
44 * either it's caught or ignored by a user handler or it has a default
45 * effect that applies to the whole thread group (POSIX process).
47 * The possible effects an unblocked signal set to SIG_DFL can have are:
48 * ignore - Nothing Happens
49 * terminate - kill the process, i.e. all threads in the group,
50 * similar to exit_group. The group leader (only) reports
51 * WIFSIGNALED status to its parent.
52 * coredump - write a core dump file describing all threads using
53 * the same mm and then kill all those threads
54 * stop - stop all the threads in the group, i.e. TASK_STOPPED state
56 * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
57 * Other signals when not blocked and set to SIG_DFL behaves as follows.
58 * The job control signals also have other special effects.
60 * +--------------------+------------------+
61 * | POSIX signal | default action |
62 * +--------------------+------------------+
63 * | SIGHUP | terminate |
64 * | SIGINT | terminate |
65 * | SIGQUIT | coredump |
66 * | SIGILL | coredump |
67 * | SIGTRAP | coredump |
68 * | SIGABRT/SIGIOT | coredump |
69 * | SIGBUS | coredump |
70 * | SIGFPE | coredump |
71 * | SIGKILL | terminate(+) |
72 * | SIGUSR1 | terminate |
73 * | SIGSEGV | coredump |
74 * | SIGUSR2 | terminate |
75 * | SIGPIPE | terminate |
76 * | SIGALRM | terminate |
77 * | SIGTERM | terminate |
78 * | SIGCHLD | ignore |
79 * | SIGCONT | ignore(*) |
80 * | SIGSTOP | stop(*)(+) |
81 * | SIGTSTP | stop(*) |
82 * | SIGTTIN | stop(*) |
83 * | SIGTTOU | stop(*) |
85 * | SIGXCPU | coredump |
86 * | SIGXFSZ | coredump |
87 * | SIGVTALRM | terminate |
88 * | SIGPROF | terminate |
89 * | SIGPOLL/SIGIO | terminate |
90 * | SIGSYS/SIGUNUSED | coredump |
91 * | SIGSTKFLT | terminate |
92 * | SIGWINCH | ignore |
93 * | SIGPWR | terminate |
94 * | SIGRTMIN-SIGRTMAX | terminate |
95 * +--------------------+------------------+
96 * | non-POSIX signal | default action |
97 * +--------------------+------------------+
98 * | SIGEMT | coredump |
99 * +--------------------+------------------+
101 * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
102 * (*) Special job control effects:
103 * When SIGCONT is sent, it resumes the process (all threads in the group)
104 * from TASK_STOPPED state and also clears any pending/queued stop signals
105 * (any of those marked with "stop(*)"). This happens regardless of blocking,
106 * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
107 * any pending/queued SIGCONT signals; this happens regardless of blocking,
108 * catching, or ignored the stop signal, though (except for SIGSTOP) the
109 * default action of stopping the process may happen later or never.
113 #define M_SIGEMT M(SIGEMT)
118 #if SIGRTMIN > BITS_PER_LONG
119 #define M(sig) (1ULL << ((sig)-1))
121 #define M(sig) (1UL << ((sig)-1))
123 #define T(sig, mask) (M(sig) & (mask))
125 #define SIG_KERNEL_ONLY_MASK (\
126 M(SIGKILL) | M(SIGSTOP) )
128 #define SIG_KERNEL_STOP_MASK (\
129 M(SIGSTOP) | M(SIGTSTP) | M(SIGTTIN) | M(SIGTTOU) )
131 #define SIG_KERNEL_COREDUMP_MASK (\
132 M(SIGQUIT) | M(SIGILL) | M(SIGTRAP) | M(SIGABRT) | \
133 M(SIGFPE) | M(SIGSEGV) | M(SIGBUS) | M(SIGSYS) | \
134 M(SIGXCPU) | M(SIGXFSZ) | M_SIGEMT )
136 #define SIG_KERNEL_IGNORE_MASK (\
137 M(SIGCONT) | M(SIGCHLD) | M(SIGWINCH) | M(SIGURG) )
139 #define sig_kernel_only(sig) \
140 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_ONLY_MASK))
141 #define sig_kernel_coredump(sig) \
142 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_COREDUMP_MASK))
143 #define sig_kernel_ignore(sig) \
144 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_IGNORE_MASK))
145 #define sig_kernel_stop(sig) \
146 (((sig) < SIGRTMIN) && T(sig, SIG_KERNEL_STOP_MASK))
148 #define sig_needs_tasklist(sig) ((sig) == SIGCONT)
150 #define sig_user_defined(t, signr) \
151 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
152 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
154 #define sig_fatal(t, signr) \
155 (!T(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
156 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
158 static int sig_ignored(struct task_struct
*t
, int sig
)
160 void __user
* handler
;
163 * Tracers always want to know about signals..
165 if (t
->ptrace
& PT_PTRACED
)
169 * Blocked signals are never ignored, since the
170 * signal handler may change by the time it is
173 if (sigismember(&t
->blocked
, sig
))
176 /* Is it explicitly or implicitly ignored? */
177 handler
= t
->sighand
->action
[sig
-1].sa
.sa_handler
;
178 return handler
== SIG_IGN
||
179 (handler
== SIG_DFL
&& sig_kernel_ignore(sig
));
183 * Re-calculate pending state from the set of locally pending
184 * signals, globally pending signals, and blocked signals.
186 static inline int has_pending_signals(sigset_t
*signal
, sigset_t
*blocked
)
191 switch (_NSIG_WORDS
) {
193 for (i
= _NSIG_WORDS
, ready
= 0; --i
>= 0 ;)
194 ready
|= signal
->sig
[i
] &~ blocked
->sig
[i
];
197 case 4: ready
= signal
->sig
[3] &~ blocked
->sig
[3];
198 ready
|= signal
->sig
[2] &~ blocked
->sig
[2];
199 ready
|= signal
->sig
[1] &~ blocked
->sig
[1];
200 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
203 case 2: ready
= signal
->sig
[1] &~ blocked
->sig
[1];
204 ready
|= signal
->sig
[0] &~ blocked
->sig
[0];
207 case 1: ready
= signal
->sig
[0] &~ blocked
->sig
[0];
212 #define PENDING(p,b) has_pending_signals(&(p)->signal, (b))
214 fastcall
void recalc_sigpending_tsk(struct task_struct
*t
)
216 if (t
->signal
->group_stop_count
> 0 ||
218 PENDING(&t
->pending
, &t
->blocked
) ||
219 PENDING(&t
->signal
->shared_pending
, &t
->blocked
))
220 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
222 clear_tsk_thread_flag(t
, TIF_SIGPENDING
);
225 void recalc_sigpending(void)
227 recalc_sigpending_tsk(current
);
230 /* Given the mask, find the first available signal that should be serviced. */
233 next_signal(struct sigpending
*pending
, sigset_t
*mask
)
235 unsigned long i
, *s
, *m
, x
;
238 s
= pending
->signal
.sig
;
240 switch (_NSIG_WORDS
) {
242 for (i
= 0; i
< _NSIG_WORDS
; ++i
, ++s
, ++m
)
243 if ((x
= *s
&~ *m
) != 0) {
244 sig
= ffz(~x
) + i
*_NSIG_BPW
+ 1;
249 case 2: if ((x
= s
[0] &~ m
[0]) != 0)
251 else if ((x
= s
[1] &~ m
[1]) != 0)
258 case 1: if ((x
= *s
&~ *m
) != 0)
266 static struct sigqueue
*__sigqueue_alloc(struct task_struct
*t
, gfp_t flags
,
269 struct sigqueue
*q
= NULL
;
271 atomic_inc(&t
->user
->sigpending
);
272 if (override_rlimit
||
273 atomic_read(&t
->user
->sigpending
) <=
274 t
->signal
->rlim
[RLIMIT_SIGPENDING
].rlim_cur
)
275 q
= kmem_cache_alloc(sigqueue_cachep
, flags
);
276 if (unlikely(q
== NULL
)) {
277 atomic_dec(&t
->user
->sigpending
);
279 INIT_LIST_HEAD(&q
->list
);
281 q
->user
= get_uid(t
->user
);
286 static void __sigqueue_free(struct sigqueue
*q
)
288 if (q
->flags
& SIGQUEUE_PREALLOC
)
290 atomic_dec(&q
->user
->sigpending
);
292 kmem_cache_free(sigqueue_cachep
, q
);
295 void flush_sigqueue(struct sigpending
*queue
)
299 sigemptyset(&queue
->signal
);
300 while (!list_empty(&queue
->list
)) {
301 q
= list_entry(queue
->list
.next
, struct sigqueue
, list
);
302 list_del_init(&q
->list
);
308 * Flush all pending signals for a task.
310 void flush_signals(struct task_struct
*t
)
314 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
315 clear_tsk_thread_flag(t
,TIF_SIGPENDING
);
316 flush_sigqueue(&t
->pending
);
317 flush_sigqueue(&t
->signal
->shared_pending
);
318 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
322 * Flush all handlers for a task.
326 flush_signal_handlers(struct task_struct
*t
, int force_default
)
329 struct k_sigaction
*ka
= &t
->sighand
->action
[0];
330 for (i
= _NSIG
; i
!= 0 ; i
--) {
331 if (force_default
|| ka
->sa
.sa_handler
!= SIG_IGN
)
332 ka
->sa
.sa_handler
= SIG_DFL
;
334 sigemptyset(&ka
->sa
.sa_mask
);
340 /* Notify the system that a driver wants to block all signals for this
341 * process, and wants to be notified if any signals at all were to be
342 * sent/acted upon. If the notifier routine returns non-zero, then the
343 * signal will be acted upon after all. If the notifier routine returns 0,
344 * then then signal will be blocked. Only one block per process is
345 * allowed. priv is a pointer to private data that the notifier routine
346 * can use to determine if the signal should be blocked or not. */
349 block_all_signals(int (*notifier
)(void *priv
), void *priv
, sigset_t
*mask
)
353 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
354 current
->notifier_mask
= mask
;
355 current
->notifier_data
= priv
;
356 current
->notifier
= notifier
;
357 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
360 /* Notify the system that blocking has ended. */
363 unblock_all_signals(void)
367 spin_lock_irqsave(¤t
->sighand
->siglock
, flags
);
368 current
->notifier
= NULL
;
369 current
->notifier_data
= NULL
;
371 spin_unlock_irqrestore(¤t
->sighand
->siglock
, flags
);
374 static int collect_signal(int sig
, struct sigpending
*list
, siginfo_t
*info
)
376 struct sigqueue
*q
, *first
= NULL
;
377 int still_pending
= 0;
379 if (unlikely(!sigismember(&list
->signal
, sig
)))
383 * Collect the siginfo appropriate to this signal. Check if
384 * there is another siginfo for the same signal.
386 list_for_each_entry(q
, &list
->list
, list
) {
387 if (q
->info
.si_signo
== sig
) {
396 list_del_init(&first
->list
);
397 copy_siginfo(info
, &first
->info
);
398 __sigqueue_free(first
);
400 sigdelset(&list
->signal
, sig
);
403 /* Ok, it wasn't in the queue. This must be
404 a fast-pathed signal or we must have been
405 out of queue space. So zero out the info.
407 sigdelset(&list
->signal
, sig
);
408 info
->si_signo
= sig
;
417 static int __dequeue_signal(struct sigpending
*pending
, sigset_t
*mask
,
422 sig
= next_signal(pending
, mask
);
424 if (current
->notifier
) {
425 if (sigismember(current
->notifier_mask
, sig
)) {
426 if (!(current
->notifier
)(current
->notifier_data
)) {
427 clear_thread_flag(TIF_SIGPENDING
);
433 if (!collect_signal(sig
, pending
, info
))
443 * Dequeue a signal and return the element to the caller, which is
444 * expected to free it.
446 * All callers have to hold the siglock.
448 int dequeue_signal(struct task_struct
*tsk
, sigset_t
*mask
, siginfo_t
*info
)
450 int signr
= __dequeue_signal(&tsk
->pending
, mask
, info
);
452 signr
= __dequeue_signal(&tsk
->signal
->shared_pending
,
454 if (signr
&& unlikely(sig_kernel_stop(signr
))) {
456 * Set a marker that we have dequeued a stop signal. Our
457 * caller might release the siglock and then the pending
458 * stop signal it is about to process is no longer in the
459 * pending bitmasks, but must still be cleared by a SIGCONT
460 * (and overruled by a SIGKILL). So those cases clear this
461 * shared flag after we've set it. Note that this flag may
462 * remain set after the signal we return is ignored or
463 * handled. That doesn't matter because its only purpose
464 * is to alert stop-signal processing code when another
465 * processor has come along and cleared the flag.
467 if (!(tsk
->signal
->flags
& SIGNAL_GROUP_EXIT
))
468 tsk
->signal
->flags
|= SIGNAL_STOP_DEQUEUED
;
471 ((info
->si_code
& __SI_MASK
) == __SI_TIMER
) &&
472 info
->si_sys_private
){
474 * Release the siglock to ensure proper locking order
475 * of timer locks outside of siglocks. Note, we leave
476 * irqs disabled here, since the posix-timers code is
477 * about to disable them again anyway.
479 spin_unlock(&tsk
->sighand
->siglock
);
480 do_schedule_next_timer(info
);
481 spin_lock(&tsk
->sighand
->siglock
);
487 * Tell a process that it has a new active signal..
489 * NOTE! we rely on the previous spin_lock to
490 * lock interrupts for us! We can only be called with
491 * "siglock" held, and the local interrupt must
492 * have been disabled when that got acquired!
494 * No need to set need_resched since signal event passing
495 * goes through ->blocked
497 void signal_wake_up(struct task_struct
*t
, int resume
)
501 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
504 * For SIGKILL, we want to wake it up in the stopped/traced case.
505 * We don't check t->state here because there is a race with it
506 * executing another processor and just now entering stopped state.
507 * By using wake_up_state, we ensure the process will wake up and
508 * handle its death signal.
510 mask
= TASK_INTERRUPTIBLE
;
512 mask
|= TASK_STOPPED
| TASK_TRACED
;
513 if (!wake_up_state(t
, mask
))
518 * Remove signals in mask from the pending set and queue.
519 * Returns 1 if any signals were found.
521 * All callers must be holding the siglock.
523 * This version takes a sigset mask and looks at all signals,
524 * not just those in the first mask word.
526 static int rm_from_queue_full(sigset_t
*mask
, struct sigpending
*s
)
528 struct sigqueue
*q
, *n
;
531 sigandsets(&m
, mask
, &s
->signal
);
532 if (sigisemptyset(&m
))
535 signandsets(&s
->signal
, &s
->signal
, mask
);
536 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
537 if (sigismember(mask
, q
->info
.si_signo
)) {
538 list_del_init(&q
->list
);
545 * Remove signals in mask from the pending set and queue.
546 * Returns 1 if any signals were found.
548 * All callers must be holding the siglock.
550 static int rm_from_queue(unsigned long mask
, struct sigpending
*s
)
552 struct sigqueue
*q
, *n
;
554 if (!sigtestsetmask(&s
->signal
, mask
))
557 sigdelsetmask(&s
->signal
, mask
);
558 list_for_each_entry_safe(q
, n
, &s
->list
, list
) {
559 if (q
->info
.si_signo
< SIGRTMIN
&&
560 (mask
& sigmask(q
->info
.si_signo
))) {
561 list_del_init(&q
->list
);
569 * Bad permissions for sending the signal
571 static int check_kill_permission(int sig
, struct siginfo
*info
,
572 struct task_struct
*t
)
575 if (!valid_signal(sig
))
578 if ((info
== SEND_SIG_NOINFO
|| (!is_si_special(info
) && SI_FROMUSER(info
)))
579 && ((sig
!= SIGCONT
) ||
580 (current
->signal
->session
!= t
->signal
->session
))
581 && (current
->euid
^ t
->suid
) && (current
->euid
^ t
->uid
)
582 && (current
->uid
^ t
->suid
) && (current
->uid
^ t
->uid
)
583 && !capable(CAP_KILL
))
586 error
= security_task_kill(t
, info
, sig
);
588 audit_signal_info(sig
, t
); /* Let audit system see the signal */
593 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
);
596 * Handle magic process-wide effects of stop/continue signals.
597 * Unlike the signal actions, these happen immediately at signal-generation
598 * time regardless of blocking, ignoring, or handling. This does the
599 * actual continuing for SIGCONT, but not the actual stopping for stop
600 * signals. The process stop is done as a signal action for SIG_DFL.
602 static void handle_stop_signal(int sig
, struct task_struct
*p
)
604 struct task_struct
*t
;
606 if (p
->signal
->flags
& SIGNAL_GROUP_EXIT
)
608 * The process is in the middle of dying already.
612 if (sig_kernel_stop(sig
)) {
614 * This is a stop signal. Remove SIGCONT from all queues.
616 rm_from_queue(sigmask(SIGCONT
), &p
->signal
->shared_pending
);
619 rm_from_queue(sigmask(SIGCONT
), &t
->pending
);
622 } else if (sig
== SIGCONT
) {
624 * Remove all stop signals from all queues,
625 * and wake all threads.
627 if (unlikely(p
->signal
->group_stop_count
> 0)) {
629 * There was a group stop in progress. We'll
630 * pretend it finished before we got here. We are
631 * obliged to report it to the parent: if the
632 * SIGSTOP happened "after" this SIGCONT, then it
633 * would have cleared this pending SIGCONT. If it
634 * happened "before" this SIGCONT, then the parent
635 * got the SIGCHLD about the stop finishing before
636 * the continue happened. We do the notification
637 * now, and it's as if the stop had finished and
638 * the SIGCHLD was pending on entry to this kill.
640 p
->signal
->group_stop_count
= 0;
641 p
->signal
->flags
= SIGNAL_STOP_CONTINUED
;
642 spin_unlock(&p
->sighand
->siglock
);
643 do_notify_parent_cldstop(p
, CLD_STOPPED
);
644 spin_lock(&p
->sighand
->siglock
);
646 rm_from_queue(SIG_KERNEL_STOP_MASK
, &p
->signal
->shared_pending
);
650 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
653 * If there is a handler for SIGCONT, we must make
654 * sure that no thread returns to user mode before
655 * we post the signal, in case it was the only
656 * thread eligible to run the signal handler--then
657 * it must not do anything between resuming and
658 * running the handler. With the TIF_SIGPENDING
659 * flag set, the thread will pause and acquire the
660 * siglock that we hold now and until we've queued
661 * the pending signal.
663 * Wake up the stopped thread _after_ setting
666 state
= TASK_STOPPED
;
667 if (sig_user_defined(t
, SIGCONT
) && !sigismember(&t
->blocked
, SIGCONT
)) {
668 set_tsk_thread_flag(t
, TIF_SIGPENDING
);
669 state
|= TASK_INTERRUPTIBLE
;
671 wake_up_state(t
, state
);
676 if (p
->signal
->flags
& SIGNAL_STOP_STOPPED
) {
678 * We were in fact stopped, and are now continued.
679 * Notify the parent with CLD_CONTINUED.
681 p
->signal
->flags
= SIGNAL_STOP_CONTINUED
;
682 p
->signal
->group_exit_code
= 0;
683 spin_unlock(&p
->sighand
->siglock
);
684 do_notify_parent_cldstop(p
, CLD_CONTINUED
);
685 spin_lock(&p
->sighand
->siglock
);
688 * We are not stopped, but there could be a stop
689 * signal in the middle of being processed after
690 * being removed from the queue. Clear that too.
692 p
->signal
->flags
= 0;
694 } else if (sig
== SIGKILL
) {
696 * Make sure that any pending stop signal already dequeued
697 * is undone by the wakeup for SIGKILL.
699 p
->signal
->flags
= 0;
703 static int send_signal(int sig
, struct siginfo
*info
, struct task_struct
*t
,
704 struct sigpending
*signals
)
706 struct sigqueue
* q
= NULL
;
710 * fast-pathed signals for kernel-internal things like SIGSTOP
713 if (info
== SEND_SIG_FORCED
)
716 /* Real-time signals must be queued if sent by sigqueue, or
717 some other real-time mechanism. It is implementation
718 defined whether kill() does so. We attempt to do so, on
719 the principle of least surprise, but since kill is not
720 allowed to fail with EAGAIN when low on memory we just
721 make sure at least one signal gets delivered and don't
722 pass on the info struct. */
724 q
= __sigqueue_alloc(t
, GFP_ATOMIC
, (sig
< SIGRTMIN
&&
725 (is_si_special(info
) ||
726 info
->si_code
>= 0)));
728 list_add_tail(&q
->list
, &signals
->list
);
729 switch ((unsigned long) info
) {
730 case (unsigned long) SEND_SIG_NOINFO
:
731 q
->info
.si_signo
= sig
;
732 q
->info
.si_errno
= 0;
733 q
->info
.si_code
= SI_USER
;
734 q
->info
.si_pid
= current
->pid
;
735 q
->info
.si_uid
= current
->uid
;
737 case (unsigned long) SEND_SIG_PRIV
:
738 q
->info
.si_signo
= sig
;
739 q
->info
.si_errno
= 0;
740 q
->info
.si_code
= SI_KERNEL
;
745 copy_siginfo(&q
->info
, info
);
748 } else if (!is_si_special(info
)) {
749 if (sig
>= SIGRTMIN
&& info
->si_code
!= SI_USER
)
751 * Queue overflow, abort. We may abort if the signal was rt
752 * and sent by user using something other than kill().
758 sigaddset(&signals
->signal
, sig
);
762 #define LEGACY_QUEUE(sigptr, sig) \
763 (((sig) < SIGRTMIN) && sigismember(&(sigptr)->signal, (sig)))
767 specific_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
771 BUG_ON(!irqs_disabled());
772 assert_spin_locked(&t
->sighand
->siglock
);
774 /* Short-circuit ignored signals. */
775 if (sig_ignored(t
, sig
))
778 /* Support queueing exactly one non-rt signal, so that we
779 can get more detailed information about the cause of
781 if (LEGACY_QUEUE(&t
->pending
, sig
))
784 ret
= send_signal(sig
, info
, t
, &t
->pending
);
785 if (!ret
&& !sigismember(&t
->blocked
, sig
))
786 signal_wake_up(t
, sig
== SIGKILL
);
792 * Force a signal that the process can't ignore: if necessary
793 * we unblock the signal and change any SIG_IGN to SIG_DFL.
797 force_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*t
)
799 unsigned long int flags
;
802 spin_lock_irqsave(&t
->sighand
->siglock
, flags
);
803 if (t
->sighand
->action
[sig
-1].sa
.sa_handler
== SIG_IGN
) {
804 t
->sighand
->action
[sig
-1].sa
.sa_handler
= SIG_DFL
;
806 if (sigismember(&t
->blocked
, sig
)) {
807 sigdelset(&t
->blocked
, sig
);
809 recalc_sigpending_tsk(t
);
810 ret
= specific_send_sig_info(sig
, info
, t
);
811 spin_unlock_irqrestore(&t
->sighand
->siglock
, flags
);
817 force_sig_specific(int sig
, struct task_struct
*t
)
819 force_sig_info(sig
, SEND_SIG_FORCED
, t
);
823 * Test if P wants to take SIG. After we've checked all threads with this,
824 * it's equivalent to finding no threads not blocking SIG. Any threads not
825 * blocking SIG were ruled out because they are not running and already
826 * have pending signals. Such threads will dequeue from the shared queue
827 * as soon as they're available, so putting the signal on the shared queue
828 * will be equivalent to sending it to one such thread.
830 static inline int wants_signal(int sig
, struct task_struct
*p
)
832 if (sigismember(&p
->blocked
, sig
))
834 if (p
->flags
& PF_EXITING
)
838 if (p
->state
& (TASK_STOPPED
| TASK_TRACED
))
840 return task_curr(p
) || !signal_pending(p
);
844 __group_complete_signal(int sig
, struct task_struct
*p
)
846 struct task_struct
*t
;
849 * Now find a thread we can wake up to take the signal off the queue.
851 * If the main thread wants the signal, it gets first crack.
852 * Probably the least surprising to the average bear.
854 if (wants_signal(sig
, p
))
856 else if (thread_group_empty(p
))
858 * There is just one thread and it does not need to be woken.
859 * It will dequeue unblocked signals before it runs again.
864 * Otherwise try to find a suitable thread.
866 t
= p
->signal
->curr_target
;
868 /* restart balancing at this thread */
869 t
= p
->signal
->curr_target
= p
;
871 while (!wants_signal(sig
, t
)) {
873 if (t
== p
->signal
->curr_target
)
875 * No thread needs to be woken.
876 * Any eligible threads will see
877 * the signal in the queue soon.
881 p
->signal
->curr_target
= t
;
885 * Found a killable thread. If the signal will be fatal,
886 * then start taking the whole group down immediately.
888 if (sig_fatal(p
, sig
) && !(p
->signal
->flags
& SIGNAL_GROUP_EXIT
) &&
889 !sigismember(&t
->real_blocked
, sig
) &&
890 (sig
== SIGKILL
|| !(t
->ptrace
& PT_PTRACED
))) {
892 * This signal will be fatal to the whole group.
894 if (!sig_kernel_coredump(sig
)) {
896 * Start a group exit and wake everybody up.
897 * This way we don't have other threads
898 * running and doing things after a slower
899 * thread has the fatal signal pending.
901 p
->signal
->flags
= SIGNAL_GROUP_EXIT
;
902 p
->signal
->group_exit_code
= sig
;
903 p
->signal
->group_stop_count
= 0;
906 sigaddset(&t
->pending
.signal
, SIGKILL
);
907 signal_wake_up(t
, 1);
914 * There will be a core dump. We make all threads other
915 * than the chosen one go into a group stop so that nothing
916 * happens until it gets scheduled, takes the signal off
917 * the shared queue, and does the core dump. This is a
918 * little more complicated than strictly necessary, but it
919 * keeps the signal state that winds up in the core dump
920 * unchanged from the death state, e.g. which thread had
921 * the core-dump signal unblocked.
923 rm_from_queue(SIG_KERNEL_STOP_MASK
, &t
->pending
);
924 rm_from_queue(SIG_KERNEL_STOP_MASK
, &p
->signal
->shared_pending
);
925 p
->signal
->group_stop_count
= 0;
926 p
->signal
->group_exit_task
= t
;
929 p
->signal
->group_stop_count
++;
930 signal_wake_up(t
, 0);
933 wake_up_process(p
->signal
->group_exit_task
);
938 * The signal is already in the shared-pending queue.
939 * Tell the chosen thread to wake up and dequeue it.
941 signal_wake_up(t
, sig
== SIGKILL
);
946 __group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
950 assert_spin_locked(&p
->sighand
->siglock
);
951 handle_stop_signal(sig
, p
);
953 /* Short-circuit ignored signals. */
954 if (sig_ignored(p
, sig
))
957 if (LEGACY_QUEUE(&p
->signal
->shared_pending
, sig
))
958 /* This is a non-RT signal and we already have one queued. */
962 * Put this signal on the shared-pending queue, or fail with EAGAIN.
963 * We always use the shared queue for process-wide signals,
964 * to avoid several races.
966 ret
= send_signal(sig
, info
, p
, &p
->signal
->shared_pending
);
970 __group_complete_signal(sig
, p
);
975 * Nuke all other threads in the group.
977 void zap_other_threads(struct task_struct
*p
)
979 struct task_struct
*t
;
981 p
->signal
->flags
= SIGNAL_GROUP_EXIT
;
982 p
->signal
->group_stop_count
= 0;
984 if (thread_group_empty(p
))
987 for (t
= next_thread(p
); t
!= p
; t
= next_thread(t
)) {
989 * Don't bother with already dead threads
995 * We don't want to notify the parent, since we are
996 * killed as part of a thread group due to another
997 * thread doing an execve() or similar. So set the
998 * exit signal to -1 to allow immediate reaping of
999 * the process. But don't detach the thread group
1002 if (t
!= p
->group_leader
)
1003 t
->exit_signal
= -1;
1005 /* SIGKILL will be handled before any pending SIGSTOP */
1006 sigaddset(&t
->pending
.signal
, SIGKILL
);
1007 signal_wake_up(t
, 1);
1012 * Must be called under rcu_read_lock() or with tasklist_lock read-held.
1014 struct sighand_struct
*lock_task_sighand(struct task_struct
*tsk
, unsigned long *flags
)
1016 struct sighand_struct
*sighand
;
1019 sighand
= rcu_dereference(tsk
->sighand
);
1020 if (unlikely(sighand
== NULL
))
1023 spin_lock_irqsave(&sighand
->siglock
, *flags
);
1024 if (likely(sighand
== tsk
->sighand
))
1026 spin_unlock_irqrestore(&sighand
->siglock
, *flags
);
1032 int group_send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1034 unsigned long flags
;
1037 ret
= check_kill_permission(sig
, info
, p
);
1041 if (lock_task_sighand(p
, &flags
)) {
1042 ret
= __group_send_sig_info(sig
, info
, p
);
1043 unlock_task_sighand(p
, &flags
);
1051 * kill_pg_info() sends a signal to a process group: this is what the tty
1052 * control characters do (^C, ^Z etc)
1055 int __kill_pg_info(int sig
, struct siginfo
*info
, pid_t pgrp
)
1057 struct task_struct
*p
= NULL
;
1058 int retval
, success
;
1065 do_each_task_pid(pgrp
, PIDTYPE_PGID
, p
) {
1066 int err
= group_send_sig_info(sig
, info
, p
);
1069 } while_each_task_pid(pgrp
, PIDTYPE_PGID
, p
);
1070 return success
? 0 : retval
;
1074 kill_pg_info(int sig
, struct siginfo
*info
, pid_t pgrp
)
1078 read_lock(&tasklist_lock
);
1079 retval
= __kill_pg_info(sig
, info
, pgrp
);
1080 read_unlock(&tasklist_lock
);
1086 kill_proc_info(int sig
, struct siginfo
*info
, pid_t pid
)
1089 int acquired_tasklist_lock
= 0;
1090 struct task_struct
*p
;
1093 if (unlikely(sig_needs_tasklist(sig
))) {
1094 read_lock(&tasklist_lock
);
1095 acquired_tasklist_lock
= 1;
1097 p
= find_task_by_pid(pid
);
1100 error
= group_send_sig_info(sig
, info
, p
);
1101 if (unlikely(acquired_tasklist_lock
))
1102 read_unlock(&tasklist_lock
);
1107 /* like kill_proc_info(), but doesn't use uid/euid of "current" */
1108 int kill_proc_info_as_uid(int sig
, struct siginfo
*info
, pid_t pid
,
1109 uid_t uid
, uid_t euid
)
1112 struct task_struct
*p
;
1114 if (!valid_signal(sig
))
1117 read_lock(&tasklist_lock
);
1118 p
= find_task_by_pid(pid
);
1123 if ((info
== SEND_SIG_NOINFO
|| (!is_si_special(info
) && SI_FROMUSER(info
)))
1124 && (euid
!= p
->suid
) && (euid
!= p
->uid
)
1125 && (uid
!= p
->suid
) && (uid
!= p
->uid
)) {
1129 if (sig
&& p
->sighand
) {
1130 unsigned long flags
;
1131 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1132 ret
= __group_send_sig_info(sig
, info
, p
);
1133 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1136 read_unlock(&tasklist_lock
);
1139 EXPORT_SYMBOL_GPL(kill_proc_info_as_uid
);
1142 * kill_something_info() interprets pid in interesting ways just like kill(2).
1144 * POSIX specifies that kill(-1,sig) is unspecified, but what we have
1145 * is probably wrong. Should make it like BSD or SYSV.
1148 static int kill_something_info(int sig
, struct siginfo
*info
, int pid
)
1151 return kill_pg_info(sig
, info
, process_group(current
));
1152 } else if (pid
== -1) {
1153 int retval
= 0, count
= 0;
1154 struct task_struct
* p
;
1156 read_lock(&tasklist_lock
);
1157 for_each_process(p
) {
1158 if (p
->pid
> 1 && p
->tgid
!= current
->tgid
) {
1159 int err
= group_send_sig_info(sig
, info
, p
);
1165 read_unlock(&tasklist_lock
);
1166 return count
? retval
: -ESRCH
;
1167 } else if (pid
< 0) {
1168 return kill_pg_info(sig
, info
, -pid
);
1170 return kill_proc_info(sig
, info
, pid
);
1175 * These are for backward compatibility with the rest of the kernel source.
1179 * These two are the most common entry points. They send a signal
1180 * just to the specific thread.
1183 send_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1186 unsigned long flags
;
1189 * Make sure legacy kernel users don't send in bad values
1190 * (normal paths check this in check_kill_permission).
1192 if (!valid_signal(sig
))
1196 * We need the tasklist lock even for the specific
1197 * thread case (when we don't need to follow the group
1198 * lists) in order to avoid races with "p->sighand"
1199 * going away or changing from under us.
1201 read_lock(&tasklist_lock
);
1202 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1203 ret
= specific_send_sig_info(sig
, info
, p
);
1204 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1205 read_unlock(&tasklist_lock
);
1209 #define __si_special(priv) \
1210 ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO)
1213 send_sig(int sig
, struct task_struct
*p
, int priv
)
1215 return send_sig_info(sig
, __si_special(priv
), p
);
1219 * This is the entry point for "process-wide" signals.
1220 * They will go to an appropriate thread in the thread group.
1223 send_group_sig_info(int sig
, struct siginfo
*info
, struct task_struct
*p
)
1226 read_lock(&tasklist_lock
);
1227 ret
= group_send_sig_info(sig
, info
, p
);
1228 read_unlock(&tasklist_lock
);
1233 force_sig(int sig
, struct task_struct
*p
)
1235 force_sig_info(sig
, SEND_SIG_PRIV
, p
);
1239 * When things go south during signal handling, we
1240 * will force a SIGSEGV. And if the signal that caused
1241 * the problem was already a SIGSEGV, we'll want to
1242 * make sure we don't even try to deliver the signal..
1245 force_sigsegv(int sig
, struct task_struct
*p
)
1247 if (sig
== SIGSEGV
) {
1248 unsigned long flags
;
1249 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1250 p
->sighand
->action
[sig
- 1].sa
.sa_handler
= SIG_DFL
;
1251 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1253 force_sig(SIGSEGV
, p
);
1258 kill_pg(pid_t pgrp
, int sig
, int priv
)
1260 return kill_pg_info(sig
, __si_special(priv
), pgrp
);
1264 kill_proc(pid_t pid
, int sig
, int priv
)
1266 return kill_proc_info(sig
, __si_special(priv
), pid
);
1270 * These functions support sending signals using preallocated sigqueue
1271 * structures. This is needed "because realtime applications cannot
1272 * afford to lose notifications of asynchronous events, like timer
1273 * expirations or I/O completions". In the case of Posix Timers
1274 * we allocate the sigqueue structure from the timer_create. If this
1275 * allocation fails we are able to report the failure to the application
1276 * with an EAGAIN error.
1279 struct sigqueue
*sigqueue_alloc(void)
1283 if ((q
= __sigqueue_alloc(current
, GFP_KERNEL
, 0)))
1284 q
->flags
|= SIGQUEUE_PREALLOC
;
1288 void sigqueue_free(struct sigqueue
*q
)
1290 unsigned long flags
;
1291 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1293 * If the signal is still pending remove it from the
1296 if (unlikely(!list_empty(&q
->list
))) {
1297 spinlock_t
*lock
= ¤t
->sighand
->siglock
;
1298 read_lock(&tasklist_lock
);
1299 spin_lock_irqsave(lock
, flags
);
1300 if (!list_empty(&q
->list
))
1301 list_del_init(&q
->list
);
1302 spin_unlock_irqrestore(lock
, flags
);
1303 read_unlock(&tasklist_lock
);
1305 q
->flags
&= ~SIGQUEUE_PREALLOC
;
1309 int send_sigqueue(int sig
, struct sigqueue
*q
, struct task_struct
*p
)
1311 unsigned long flags
;
1314 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1317 * The rcu based delayed sighand destroy makes it possible to
1318 * run this without tasklist lock held. The task struct itself
1319 * cannot go away as create_timer did get_task_struct().
1321 * We return -1, when the task is marked exiting, so
1322 * posix_timer_event can redirect it to the group leader
1326 if (!likely(lock_task_sighand(p
, &flags
))) {
1331 if (unlikely(!list_empty(&q
->list
))) {
1333 * If an SI_TIMER entry is already queue just increment
1334 * the overrun count.
1336 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1337 q
->info
.si_overrun
++;
1340 /* Short-circuit ignored signals. */
1341 if (sig_ignored(p
, sig
)) {
1346 list_add_tail(&q
->list
, &p
->pending
.list
);
1347 sigaddset(&p
->pending
.signal
, sig
);
1348 if (!sigismember(&p
->blocked
, sig
))
1349 signal_wake_up(p
, sig
== SIGKILL
);
1352 unlock_task_sighand(p
, &flags
);
1360 send_group_sigqueue(int sig
, struct sigqueue
*q
, struct task_struct
*p
)
1362 unsigned long flags
;
1365 BUG_ON(!(q
->flags
& SIGQUEUE_PREALLOC
));
1367 read_lock(&tasklist_lock
);
1368 /* Since it_lock is held, p->sighand cannot be NULL. */
1369 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
1370 handle_stop_signal(sig
, p
);
1372 /* Short-circuit ignored signals. */
1373 if (sig_ignored(p
, sig
)) {
1378 if (unlikely(!list_empty(&q
->list
))) {
1380 * If an SI_TIMER entry is already queue just increment
1381 * the overrun count. Other uses should not try to
1382 * send the signal multiple times.
1384 BUG_ON(q
->info
.si_code
!= SI_TIMER
);
1385 q
->info
.si_overrun
++;
1390 * Put this signal on the shared-pending queue.
1391 * We always use the shared queue for process-wide signals,
1392 * to avoid several races.
1394 list_add_tail(&q
->list
, &p
->signal
->shared_pending
.list
);
1395 sigaddset(&p
->signal
->shared_pending
.signal
, sig
);
1397 __group_complete_signal(sig
, p
);
1399 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
1400 read_unlock(&tasklist_lock
);
1405 * Wake up any threads in the parent blocked in wait* syscalls.
1407 static inline void __wake_up_parent(struct task_struct
*p
,
1408 struct task_struct
*parent
)
1410 wake_up_interruptible_sync(&parent
->signal
->wait_chldexit
);
1414 * Let a parent know about the death of a child.
1415 * For a stopped/continued status change, use do_notify_parent_cldstop instead.
1418 void do_notify_parent(struct task_struct
*tsk
, int sig
)
1420 struct siginfo info
;
1421 unsigned long flags
;
1422 struct sighand_struct
*psig
;
1426 /* do_notify_parent_cldstop should have been called instead. */
1427 BUG_ON(tsk
->state
& (TASK_STOPPED
|TASK_TRACED
));
1429 BUG_ON(!tsk
->ptrace
&&
1430 (tsk
->group_leader
!= tsk
|| !thread_group_empty(tsk
)));
1432 info
.si_signo
= sig
;
1434 info
.si_pid
= tsk
->pid
;
1435 info
.si_uid
= tsk
->uid
;
1437 /* FIXME: find out whether or not this is supposed to be c*time. */
1438 info
.si_utime
= cputime_to_jiffies(cputime_add(tsk
->utime
,
1439 tsk
->signal
->utime
));
1440 info
.si_stime
= cputime_to_jiffies(cputime_add(tsk
->stime
,
1441 tsk
->signal
->stime
));
1443 info
.si_status
= tsk
->exit_code
& 0x7f;
1444 if (tsk
->exit_code
& 0x80)
1445 info
.si_code
= CLD_DUMPED
;
1446 else if (tsk
->exit_code
& 0x7f)
1447 info
.si_code
= CLD_KILLED
;
1449 info
.si_code
= CLD_EXITED
;
1450 info
.si_status
= tsk
->exit_code
>> 8;
1453 psig
= tsk
->parent
->sighand
;
1454 spin_lock_irqsave(&psig
->siglock
, flags
);
1455 if (!tsk
->ptrace
&& sig
== SIGCHLD
&&
1456 (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
||
1457 (psig
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDWAIT
))) {
1459 * We are exiting and our parent doesn't care. POSIX.1
1460 * defines special semantics for setting SIGCHLD to SIG_IGN
1461 * or setting the SA_NOCLDWAIT flag: we should be reaped
1462 * automatically and not left for our parent's wait4 call.
1463 * Rather than having the parent do it as a magic kind of
1464 * signal handler, we just set this to tell do_exit that we
1465 * can be cleaned up without becoming a zombie. Note that
1466 * we still call __wake_up_parent in this case, because a
1467 * blocked sys_wait4 might now return -ECHILD.
1469 * Whether we send SIGCHLD or not for SA_NOCLDWAIT
1470 * is implementation-defined: we do (if you don't want
1471 * it, just use SIG_IGN instead).
1473 tsk
->exit_signal
= -1;
1474 if (psig
->action
[SIGCHLD
-1].sa
.sa_handler
== SIG_IGN
)
1477 if (valid_signal(sig
) && sig
> 0)
1478 __group_send_sig_info(sig
, &info
, tsk
->parent
);
1479 __wake_up_parent(tsk
, tsk
->parent
);
1480 spin_unlock_irqrestore(&psig
->siglock
, flags
);
1483 static void do_notify_parent_cldstop(struct task_struct
*tsk
, int why
)
1485 struct siginfo info
;
1486 unsigned long flags
;
1487 struct task_struct
*parent
;
1488 struct sighand_struct
*sighand
;
1490 if (tsk
->ptrace
& PT_PTRACED
)
1491 parent
= tsk
->parent
;
1493 tsk
= tsk
->group_leader
;
1494 parent
= tsk
->real_parent
;
1497 info
.si_signo
= SIGCHLD
;
1499 info
.si_pid
= tsk
->pid
;
1500 info
.si_uid
= tsk
->uid
;
1502 /* FIXME: find out whether or not this is supposed to be c*time. */
1503 info
.si_utime
= cputime_to_jiffies(tsk
->utime
);
1504 info
.si_stime
= cputime_to_jiffies(tsk
->stime
);
1509 info
.si_status
= SIGCONT
;
1512 info
.si_status
= tsk
->signal
->group_exit_code
& 0x7f;
1515 info
.si_status
= tsk
->exit_code
& 0x7f;
1521 sighand
= parent
->sighand
;
1522 spin_lock_irqsave(&sighand
->siglock
, flags
);
1523 if (sighand
->action
[SIGCHLD
-1].sa
.sa_handler
!= SIG_IGN
&&
1524 !(sighand
->action
[SIGCHLD
-1].sa
.sa_flags
& SA_NOCLDSTOP
))
1525 __group_send_sig_info(SIGCHLD
, &info
, parent
);
1527 * Even if SIGCHLD is not generated, we must wake up wait4 calls.
1529 __wake_up_parent(tsk
, parent
);
1530 spin_unlock_irqrestore(&sighand
->siglock
, flags
);
1533 static inline int may_ptrace_stop(void)
1535 if (!likely(current
->ptrace
& PT_PTRACED
))
1538 if (unlikely(current
->parent
== current
->real_parent
&&
1539 (current
->ptrace
& PT_ATTACHED
)))
1542 if (unlikely(current
->signal
== current
->parent
->signal
) &&
1543 unlikely(current
->signal
->flags
& SIGNAL_GROUP_EXIT
))
1547 * Are we in the middle of do_coredump?
1548 * If so and our tracer is also part of the coredump stopping
1549 * is a deadlock situation, and pointless because our tracer
1550 * is dead so don't allow us to stop.
1551 * If SIGKILL was already sent before the caller unlocked
1552 * ->siglock we must see ->core_waiters != 0. Otherwise it
1553 * is safe to enter schedule().
1555 if (unlikely(current
->mm
->core_waiters
) &&
1556 unlikely(current
->mm
== current
->parent
->mm
))
1563 * This must be called with current->sighand->siglock held.
1565 * This should be the path for all ptrace stops.
1566 * We always set current->last_siginfo while stopped here.
1567 * That makes it a way to test a stopped process for
1568 * being ptrace-stopped vs being job-control-stopped.
1570 * If we actually decide not to stop at all because the tracer is gone,
1571 * we leave nostop_code in current->exit_code.
1573 static void ptrace_stop(int exit_code
, int nostop_code
, siginfo_t
*info
)
1576 * If there is a group stop in progress,
1577 * we must participate in the bookkeeping.
1579 if (current
->signal
->group_stop_count
> 0)
1580 --current
->signal
->group_stop_count
;
1582 current
->last_siginfo
= info
;
1583 current
->exit_code
= exit_code
;
1585 /* Let the debugger run. */
1586 set_current_state(TASK_TRACED
);
1587 spin_unlock_irq(¤t
->sighand
->siglock
);
1589 read_lock(&tasklist_lock
);
1590 if (may_ptrace_stop()) {
1591 do_notify_parent_cldstop(current
, CLD_TRAPPED
);
1592 read_unlock(&tasklist_lock
);
1596 * By the time we got the lock, our tracer went away.
1599 read_unlock(&tasklist_lock
);
1600 set_current_state(TASK_RUNNING
);
1601 current
->exit_code
= nostop_code
;
1605 * We are back. Now reacquire the siglock before touching
1606 * last_siginfo, so that we are sure to have synchronized with
1607 * any signal-sending on another CPU that wants to examine it.
1609 spin_lock_irq(¤t
->sighand
->siglock
);
1610 current
->last_siginfo
= NULL
;
1613 * Queued signals ignored us while we were stopped for tracing.
1614 * So check for any that we should take before resuming user mode.
1616 recalc_sigpending();
1619 void ptrace_notify(int exit_code
)
1623 BUG_ON((exit_code
& (0x7f | ~0xffff)) != SIGTRAP
);
1625 memset(&info
, 0, sizeof info
);
1626 info
.si_signo
= SIGTRAP
;
1627 info
.si_code
= exit_code
;
1628 info
.si_pid
= current
->pid
;
1629 info
.si_uid
= current
->uid
;
1631 /* Let the debugger run. */
1632 spin_lock_irq(¤t
->sighand
->siglock
);
1633 ptrace_stop(exit_code
, 0, &info
);
1634 spin_unlock_irq(¤t
->sighand
->siglock
);
1638 finish_stop(int stop_count
)
1641 * If there are no other threads in the group, or if there is
1642 * a group stop in progress and we are the last to stop,
1643 * report to the parent. When ptraced, every thread reports itself.
1645 if (stop_count
== 0 || (current
->ptrace
& PT_PTRACED
)) {
1646 read_lock(&tasklist_lock
);
1647 do_notify_parent_cldstop(current
, CLD_STOPPED
);
1648 read_unlock(&tasklist_lock
);
1653 * Now we don't run again until continued.
1655 current
->exit_code
= 0;
1659 * This performs the stopping for SIGSTOP and other stop signals.
1660 * We have to stop all threads in the thread group.
1661 * Returns nonzero if we've actually stopped and released the siglock.
1662 * Returns zero if we didn't stop and still hold the siglock.
1664 static int do_signal_stop(int signr
)
1666 struct signal_struct
*sig
= current
->signal
;
1669 if (!likely(sig
->flags
& SIGNAL_STOP_DEQUEUED
))
1672 if (sig
->group_stop_count
> 0) {
1674 * There is a group stop in progress. We don't need to
1675 * start another one.
1677 stop_count
= --sig
->group_stop_count
;
1680 * There is no group stop already in progress.
1681 * We must initiate one now.
1683 struct task_struct
*t
;
1685 sig
->group_exit_code
= signr
;
1688 for (t
= next_thread(current
); t
!= current
; t
= next_thread(t
))
1690 * Setting state to TASK_STOPPED for a group
1691 * stop is always done with the siglock held,
1692 * so this check has no races.
1694 if (!t
->exit_state
&&
1695 !(t
->state
& (TASK_STOPPED
|TASK_TRACED
))) {
1697 signal_wake_up(t
, 0);
1699 sig
->group_stop_count
= stop_count
;
1702 if (stop_count
== 0)
1703 sig
->flags
= SIGNAL_STOP_STOPPED
;
1704 current
->exit_code
= sig
->group_exit_code
;
1705 __set_current_state(TASK_STOPPED
);
1707 spin_unlock_irq(¤t
->sighand
->siglock
);
1708 finish_stop(stop_count
);
1713 * Do appropriate magic when group_stop_count > 0.
1714 * We return nonzero if we stopped, after releasing the siglock.
1715 * We return zero if we still hold the siglock and should look
1716 * for another signal without checking group_stop_count again.
1718 static int handle_group_stop(void)
1722 if (current
->signal
->group_exit_task
== current
) {
1724 * Group stop is so we can do a core dump,
1725 * We are the initiating thread, so get on with it.
1727 current
->signal
->group_exit_task
= NULL
;
1731 if (current
->signal
->flags
& SIGNAL_GROUP_EXIT
)
1733 * Group stop is so another thread can do a core dump,
1734 * or else we are racing against a death signal.
1735 * Just punt the stop so we can get the next signal.
1740 * There is a group stop in progress. We stop
1741 * without any associated signal being in our queue.
1743 stop_count
= --current
->signal
->group_stop_count
;
1744 if (stop_count
== 0)
1745 current
->signal
->flags
= SIGNAL_STOP_STOPPED
;
1746 current
->exit_code
= current
->signal
->group_exit_code
;
1747 set_current_state(TASK_STOPPED
);
1748 spin_unlock_irq(¤t
->sighand
->siglock
);
1749 finish_stop(stop_count
);
1753 int get_signal_to_deliver(siginfo_t
*info
, struct k_sigaction
*return_ka
,
1754 struct pt_regs
*regs
, void *cookie
)
1756 sigset_t
*mask
= ¤t
->blocked
;
1762 spin_lock_irq(¤t
->sighand
->siglock
);
1764 struct k_sigaction
*ka
;
1766 if (unlikely(current
->signal
->group_stop_count
> 0) &&
1767 handle_group_stop())
1770 signr
= dequeue_signal(current
, mask
, info
);
1773 break; /* will return 0 */
1775 if ((current
->ptrace
& PT_PTRACED
) && signr
!= SIGKILL
) {
1776 ptrace_signal_deliver(regs
, cookie
);
1778 /* Let the debugger run. */
1779 ptrace_stop(signr
, signr
, info
);
1781 /* We're back. Did the debugger cancel the sig? */
1782 signr
= current
->exit_code
;
1786 current
->exit_code
= 0;
1788 /* Update the siginfo structure if the signal has
1789 changed. If the debugger wanted something
1790 specific in the siginfo structure then it should
1791 have updated *info via PTRACE_SETSIGINFO. */
1792 if (signr
!= info
->si_signo
) {
1793 info
->si_signo
= signr
;
1795 info
->si_code
= SI_USER
;
1796 info
->si_pid
= current
->parent
->pid
;
1797 info
->si_uid
= current
->parent
->uid
;
1800 /* If the (new) signal is now blocked, requeue it. */
1801 if (sigismember(¤t
->blocked
, signr
)) {
1802 specific_send_sig_info(signr
, info
, current
);
1807 ka
= ¤t
->sighand
->action
[signr
-1];
1808 if (ka
->sa
.sa_handler
== SIG_IGN
) /* Do nothing. */
1810 if (ka
->sa
.sa_handler
!= SIG_DFL
) {
1811 /* Run the handler. */
1814 if (ka
->sa
.sa_flags
& SA_ONESHOT
)
1815 ka
->sa
.sa_handler
= SIG_DFL
;
1817 break; /* will return non-zero "signr" value */
1821 * Now we are doing the default action for this signal.
1823 if (sig_kernel_ignore(signr
)) /* Default is nothing. */
1826 /* Init gets no signals it doesn't want. */
1827 if (current
== child_reaper
)
1830 if (sig_kernel_stop(signr
)) {
1832 * The default action is to stop all threads in
1833 * the thread group. The job control signals
1834 * do nothing in an orphaned pgrp, but SIGSTOP
1835 * always works. Note that siglock needs to be
1836 * dropped during the call to is_orphaned_pgrp()
1837 * because of lock ordering with tasklist_lock.
1838 * This allows an intervening SIGCONT to be posted.
1839 * We need to check for that and bail out if necessary.
1841 if (signr
!= SIGSTOP
) {
1842 spin_unlock_irq(¤t
->sighand
->siglock
);
1844 /* signals can be posted during this window */
1846 if (is_orphaned_pgrp(process_group(current
)))
1849 spin_lock_irq(¤t
->sighand
->siglock
);
1852 if (likely(do_signal_stop(signr
))) {
1853 /* It released the siglock. */
1858 * We didn't actually stop, due to a race
1859 * with SIGCONT or something like that.
1864 spin_unlock_irq(¤t
->sighand
->siglock
);
1867 * Anything else is fatal, maybe with a core dump.
1869 current
->flags
|= PF_SIGNALED
;
1870 if (sig_kernel_coredump(signr
)) {
1872 * If it was able to dump core, this kills all
1873 * other threads in the group and synchronizes with
1874 * their demise. If we lost the race with another
1875 * thread getting here, it set group_exit_code
1876 * first and our do_group_exit call below will use
1877 * that value and ignore the one we pass it.
1879 do_coredump((long)signr
, signr
, regs
);
1883 * Death signals, no core dump.
1885 do_group_exit(signr
);
1888 spin_unlock_irq(¤t
->sighand
->siglock
);
1892 EXPORT_SYMBOL(recalc_sigpending
);
1893 EXPORT_SYMBOL_GPL(dequeue_signal
);
1894 EXPORT_SYMBOL(flush_signals
);
1895 EXPORT_SYMBOL(force_sig
);
1896 EXPORT_SYMBOL(kill_pg
);
1897 EXPORT_SYMBOL(kill_proc
);
1898 EXPORT_SYMBOL(ptrace_notify
);
1899 EXPORT_SYMBOL(send_sig
);
1900 EXPORT_SYMBOL(send_sig_info
);
1901 EXPORT_SYMBOL(sigprocmask
);
1902 EXPORT_SYMBOL(block_all_signals
);
1903 EXPORT_SYMBOL(unblock_all_signals
);
1907 * System call entry points.
1910 asmlinkage
long sys_restart_syscall(void)
1912 struct restart_block
*restart
= ¤t_thread_info()->restart_block
;
1913 return restart
->fn(restart
);
1916 long do_no_restart_syscall(struct restart_block
*param
)
1922 * We don't need to get the kernel lock - this is all local to this
1923 * particular thread.. (and that's good, because this is _heavily_
1924 * used by various programs)
1928 * This is also useful for kernel threads that want to temporarily
1929 * (or permanently) block certain signals.
1931 * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel
1932 * interface happily blocks "unblockable" signals like SIGKILL
1935 int sigprocmask(int how
, sigset_t
*set
, sigset_t
*oldset
)
1939 spin_lock_irq(¤t
->sighand
->siglock
);
1941 *oldset
= current
->blocked
;
1946 sigorsets(¤t
->blocked
, ¤t
->blocked
, set
);
1949 signandsets(¤t
->blocked
, ¤t
->blocked
, set
);
1952 current
->blocked
= *set
;
1957 recalc_sigpending();
1958 spin_unlock_irq(¤t
->sighand
->siglock
);
1964 sys_rt_sigprocmask(int how
, sigset_t __user
*set
, sigset_t __user
*oset
, size_t sigsetsize
)
1966 int error
= -EINVAL
;
1967 sigset_t old_set
, new_set
;
1969 /* XXX: Don't preclude handling different sized sigset_t's. */
1970 if (sigsetsize
!= sizeof(sigset_t
))
1975 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
1977 sigdelsetmask(&new_set
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
1979 error
= sigprocmask(how
, &new_set
, &old_set
);
1985 spin_lock_irq(¤t
->sighand
->siglock
);
1986 old_set
= current
->blocked
;
1987 spin_unlock_irq(¤t
->sighand
->siglock
);
1991 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
1999 long do_sigpending(void __user
*set
, unsigned long sigsetsize
)
2001 long error
= -EINVAL
;
2004 if (sigsetsize
> sizeof(sigset_t
))
2007 spin_lock_irq(¤t
->sighand
->siglock
);
2008 sigorsets(&pending
, ¤t
->pending
.signal
,
2009 ¤t
->signal
->shared_pending
.signal
);
2010 spin_unlock_irq(¤t
->sighand
->siglock
);
2012 /* Outside the lock because only this thread touches it. */
2013 sigandsets(&pending
, ¤t
->blocked
, &pending
);
2016 if (!copy_to_user(set
, &pending
, sigsetsize
))
2024 sys_rt_sigpending(sigset_t __user
*set
, size_t sigsetsize
)
2026 return do_sigpending(set
, sigsetsize
);
2029 #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER
2031 int copy_siginfo_to_user(siginfo_t __user
*to
, siginfo_t
*from
)
2035 if (!access_ok (VERIFY_WRITE
, to
, sizeof(siginfo_t
)))
2037 if (from
->si_code
< 0)
2038 return __copy_to_user(to
, from
, sizeof(siginfo_t
))
2041 * If you change siginfo_t structure, please be sure
2042 * this code is fixed accordingly.
2043 * It should never copy any pad contained in the structure
2044 * to avoid security leaks, but must copy the generic
2045 * 3 ints plus the relevant union member.
2047 err
= __put_user(from
->si_signo
, &to
->si_signo
);
2048 err
|= __put_user(from
->si_errno
, &to
->si_errno
);
2049 err
|= __put_user((short)from
->si_code
, &to
->si_code
);
2050 switch (from
->si_code
& __SI_MASK
) {
2052 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2053 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2056 err
|= __put_user(from
->si_tid
, &to
->si_tid
);
2057 err
|= __put_user(from
->si_overrun
, &to
->si_overrun
);
2058 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2061 err
|= __put_user(from
->si_band
, &to
->si_band
);
2062 err
|= __put_user(from
->si_fd
, &to
->si_fd
);
2065 err
|= __put_user(from
->si_addr
, &to
->si_addr
);
2066 #ifdef __ARCH_SI_TRAPNO
2067 err
|= __put_user(from
->si_trapno
, &to
->si_trapno
);
2071 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2072 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2073 err
|= __put_user(from
->si_status
, &to
->si_status
);
2074 err
|= __put_user(from
->si_utime
, &to
->si_utime
);
2075 err
|= __put_user(from
->si_stime
, &to
->si_stime
);
2077 case __SI_RT
: /* This is not generated by the kernel as of now. */
2078 case __SI_MESGQ
: /* But this is */
2079 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2080 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2081 err
|= __put_user(from
->si_ptr
, &to
->si_ptr
);
2083 default: /* this is just in case for now ... */
2084 err
|= __put_user(from
->si_pid
, &to
->si_pid
);
2085 err
|= __put_user(from
->si_uid
, &to
->si_uid
);
2094 sys_rt_sigtimedwait(const sigset_t __user
*uthese
,
2095 siginfo_t __user
*uinfo
,
2096 const struct timespec __user
*uts
,
2105 /* XXX: Don't preclude handling different sized sigset_t's. */
2106 if (sigsetsize
!= sizeof(sigset_t
))
2109 if (copy_from_user(&these
, uthese
, sizeof(these
)))
2113 * Invert the set of allowed signals to get those we
2116 sigdelsetmask(&these
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2120 if (copy_from_user(&ts
, uts
, sizeof(ts
)))
2122 if (ts
.tv_nsec
>= 1000000000L || ts
.tv_nsec
< 0
2127 spin_lock_irq(¤t
->sighand
->siglock
);
2128 sig
= dequeue_signal(current
, &these
, &info
);
2130 timeout
= MAX_SCHEDULE_TIMEOUT
;
2132 timeout
= (timespec_to_jiffies(&ts
)
2133 + (ts
.tv_sec
|| ts
.tv_nsec
));
2136 /* None ready -- temporarily unblock those we're
2137 * interested while we are sleeping in so that we'll
2138 * be awakened when they arrive. */
2139 current
->real_blocked
= current
->blocked
;
2140 sigandsets(¤t
->blocked
, ¤t
->blocked
, &these
);
2141 recalc_sigpending();
2142 spin_unlock_irq(¤t
->sighand
->siglock
);
2144 timeout
= schedule_timeout_interruptible(timeout
);
2146 spin_lock_irq(¤t
->sighand
->siglock
);
2147 sig
= dequeue_signal(current
, &these
, &info
);
2148 current
->blocked
= current
->real_blocked
;
2149 siginitset(¤t
->real_blocked
, 0);
2150 recalc_sigpending();
2153 spin_unlock_irq(¤t
->sighand
->siglock
);
2158 if (copy_siginfo_to_user(uinfo
, &info
))
2171 sys_kill(int pid
, int sig
)
2173 struct siginfo info
;
2175 info
.si_signo
= sig
;
2177 info
.si_code
= SI_USER
;
2178 info
.si_pid
= current
->tgid
;
2179 info
.si_uid
= current
->uid
;
2181 return kill_something_info(sig
, &info
, pid
);
2184 static int do_tkill(int tgid
, int pid
, int sig
)
2187 struct siginfo info
;
2188 struct task_struct
*p
;
2191 info
.si_signo
= sig
;
2193 info
.si_code
= SI_TKILL
;
2194 info
.si_pid
= current
->tgid
;
2195 info
.si_uid
= current
->uid
;
2197 read_lock(&tasklist_lock
);
2198 p
= find_task_by_pid(pid
);
2199 if (p
&& (tgid
<= 0 || p
->tgid
== tgid
)) {
2200 error
= check_kill_permission(sig
, &info
, p
);
2202 * The null signal is a permissions and process existence
2203 * probe. No signal is actually delivered.
2205 if (!error
&& sig
&& p
->sighand
) {
2206 spin_lock_irq(&p
->sighand
->siglock
);
2207 handle_stop_signal(sig
, p
);
2208 error
= specific_send_sig_info(sig
, &info
, p
);
2209 spin_unlock_irq(&p
->sighand
->siglock
);
2212 read_unlock(&tasklist_lock
);
2218 * sys_tgkill - send signal to one specific thread
2219 * @tgid: the thread group ID of the thread
2220 * @pid: the PID of the thread
2221 * @sig: signal to be sent
2223 * This syscall also checks the tgid and returns -ESRCH even if the PID
2224 * exists but it's not belonging to the target process anymore. This
2225 * method solves the problem of threads exiting and PIDs getting reused.
2227 asmlinkage
long sys_tgkill(int tgid
, int pid
, int sig
)
2229 /* This is only valid for single tasks */
2230 if (pid
<= 0 || tgid
<= 0)
2233 return do_tkill(tgid
, pid
, sig
);
2237 * Send a signal to only one task, even if it's a CLONE_THREAD task.
2240 sys_tkill(int pid
, int sig
)
2242 /* This is only valid for single tasks */
2246 return do_tkill(0, pid
, sig
);
2250 sys_rt_sigqueueinfo(int pid
, int sig
, siginfo_t __user
*uinfo
)
2254 if (copy_from_user(&info
, uinfo
, sizeof(siginfo_t
)))
2257 /* Not even root can pretend to send signals from the kernel.
2258 Nor can they impersonate a kill(), which adds source info. */
2259 if (info
.si_code
>= 0)
2261 info
.si_signo
= sig
;
2263 /* POSIX.1b doesn't mention process groups. */
2264 return kill_proc_info(sig
, &info
, pid
);
2267 int do_sigaction(int sig
, struct k_sigaction
*act
, struct k_sigaction
*oact
)
2269 struct k_sigaction
*k
;
2272 if (!valid_signal(sig
) || sig
< 1 || (act
&& sig_kernel_only(sig
)))
2275 k
= ¤t
->sighand
->action
[sig
-1];
2277 spin_lock_irq(¤t
->sighand
->siglock
);
2278 if (signal_pending(current
)) {
2280 * If there might be a fatal signal pending on multiple
2281 * threads, make sure we take it before changing the action.
2283 spin_unlock_irq(¤t
->sighand
->siglock
);
2284 return -ERESTARTNOINTR
;
2291 sigdelsetmask(&act
->sa
.sa_mask
,
2292 sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2296 * "Setting a signal action to SIG_IGN for a signal that is
2297 * pending shall cause the pending signal to be discarded,
2298 * whether or not it is blocked."
2300 * "Setting a signal action to SIG_DFL for a signal that is
2301 * pending and whose default action is to ignore the signal
2302 * (for example, SIGCHLD), shall cause the pending signal to
2303 * be discarded, whether or not it is blocked"
2305 if (act
->sa
.sa_handler
== SIG_IGN
||
2306 (act
->sa
.sa_handler
== SIG_DFL
&& sig_kernel_ignore(sig
))) {
2307 struct task_struct
*t
= current
;
2309 sigaddset(&mask
, sig
);
2310 rm_from_queue_full(&mask
, &t
->signal
->shared_pending
);
2312 rm_from_queue_full(&mask
, &t
->pending
);
2313 recalc_sigpending_tsk(t
);
2315 } while (t
!= current
);
2319 spin_unlock_irq(¤t
->sighand
->siglock
);
2324 do_sigaltstack (const stack_t __user
*uss
, stack_t __user
*uoss
, unsigned long sp
)
2330 oss
.ss_sp
= (void __user
*) current
->sas_ss_sp
;
2331 oss
.ss_size
= current
->sas_ss_size
;
2332 oss
.ss_flags
= sas_ss_flags(sp
);
2341 if (!access_ok(VERIFY_READ
, uss
, sizeof(*uss
))
2342 || __get_user(ss_sp
, &uss
->ss_sp
)
2343 || __get_user(ss_flags
, &uss
->ss_flags
)
2344 || __get_user(ss_size
, &uss
->ss_size
))
2348 if (on_sig_stack(sp
))
2354 * Note - this code used to test ss_flags incorrectly
2355 * old code may have been written using ss_flags==0
2356 * to mean ss_flags==SS_ONSTACK (as this was the only
2357 * way that worked) - this fix preserves that older
2360 if (ss_flags
!= SS_DISABLE
&& ss_flags
!= SS_ONSTACK
&& ss_flags
!= 0)
2363 if (ss_flags
== SS_DISABLE
) {
2368 if (ss_size
< MINSIGSTKSZ
)
2372 current
->sas_ss_sp
= (unsigned long) ss_sp
;
2373 current
->sas_ss_size
= ss_size
;
2378 if (copy_to_user(uoss
, &oss
, sizeof(oss
)))
2387 #ifdef __ARCH_WANT_SYS_SIGPENDING
2390 sys_sigpending(old_sigset_t __user
*set
)
2392 return do_sigpending(set
, sizeof(*set
));
2397 #ifdef __ARCH_WANT_SYS_SIGPROCMASK
2398 /* Some platforms have their own version with special arguments others
2399 support only sys_rt_sigprocmask. */
2402 sys_sigprocmask(int how
, old_sigset_t __user
*set
, old_sigset_t __user
*oset
)
2405 old_sigset_t old_set
, new_set
;
2409 if (copy_from_user(&new_set
, set
, sizeof(*set
)))
2411 new_set
&= ~(sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2413 spin_lock_irq(¤t
->sighand
->siglock
);
2414 old_set
= current
->blocked
.sig
[0];
2422 sigaddsetmask(¤t
->blocked
, new_set
);
2425 sigdelsetmask(¤t
->blocked
, new_set
);
2428 current
->blocked
.sig
[0] = new_set
;
2432 recalc_sigpending();
2433 spin_unlock_irq(¤t
->sighand
->siglock
);
2439 old_set
= current
->blocked
.sig
[0];
2442 if (copy_to_user(oset
, &old_set
, sizeof(*oset
)))
2449 #endif /* __ARCH_WANT_SYS_SIGPROCMASK */
2451 #ifdef __ARCH_WANT_SYS_RT_SIGACTION
2453 sys_rt_sigaction(int sig
,
2454 const struct sigaction __user
*act
,
2455 struct sigaction __user
*oact
,
2458 struct k_sigaction new_sa
, old_sa
;
2461 /* XXX: Don't preclude handling different sized sigset_t's. */
2462 if (sigsetsize
!= sizeof(sigset_t
))
2466 if (copy_from_user(&new_sa
.sa
, act
, sizeof(new_sa
.sa
)))
2470 ret
= do_sigaction(sig
, act
? &new_sa
: NULL
, oact
? &old_sa
: NULL
);
2473 if (copy_to_user(oact
, &old_sa
.sa
, sizeof(old_sa
.sa
)))
2479 #endif /* __ARCH_WANT_SYS_RT_SIGACTION */
2481 #ifdef __ARCH_WANT_SYS_SGETMASK
2484 * For backwards compatibility. Functionality superseded by sigprocmask.
2490 return current
->blocked
.sig
[0];
2494 sys_ssetmask(int newmask
)
2498 spin_lock_irq(¤t
->sighand
->siglock
);
2499 old
= current
->blocked
.sig
[0];
2501 siginitset(¤t
->blocked
, newmask
& ~(sigmask(SIGKILL
)|
2503 recalc_sigpending();
2504 spin_unlock_irq(¤t
->sighand
->siglock
);
2508 #endif /* __ARCH_WANT_SGETMASK */
2510 #ifdef __ARCH_WANT_SYS_SIGNAL
2512 * For backwards compatibility. Functionality superseded by sigaction.
2514 asmlinkage
unsigned long
2515 sys_signal(int sig
, __sighandler_t handler
)
2517 struct k_sigaction new_sa
, old_sa
;
2520 new_sa
.sa
.sa_handler
= handler
;
2521 new_sa
.sa
.sa_flags
= SA_ONESHOT
| SA_NOMASK
;
2522 sigemptyset(&new_sa
.sa
.sa_mask
);
2524 ret
= do_sigaction(sig
, &new_sa
, &old_sa
);
2526 return ret
? ret
: (unsigned long)old_sa
.sa
.sa_handler
;
2528 #endif /* __ARCH_WANT_SYS_SIGNAL */
2530 #ifdef __ARCH_WANT_SYS_PAUSE
2535 current
->state
= TASK_INTERRUPTIBLE
;
2537 return -ERESTARTNOHAND
;
2542 #ifdef __ARCH_WANT_SYS_RT_SIGSUSPEND
2543 asmlinkage
long sys_rt_sigsuspend(sigset_t __user
*unewset
, size_t sigsetsize
)
2547 /* XXX: Don't preclude handling different sized sigset_t's. */
2548 if (sigsetsize
!= sizeof(sigset_t
))
2551 if (copy_from_user(&newset
, unewset
, sizeof(newset
)))
2553 sigdelsetmask(&newset
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
2555 spin_lock_irq(¤t
->sighand
->siglock
);
2556 current
->saved_sigmask
= current
->blocked
;
2557 current
->blocked
= newset
;
2558 recalc_sigpending();
2559 spin_unlock_irq(¤t
->sighand
->siglock
);
2561 current
->state
= TASK_INTERRUPTIBLE
;
2563 set_thread_flag(TIF_RESTORE_SIGMASK
);
2564 return -ERESTARTNOHAND
;
2566 #endif /* __ARCH_WANT_SYS_RT_SIGSUSPEND */
2568 void __init
signals_init(void)
2571 kmem_cache_create("sigqueue",
2572 sizeof(struct sigqueue
),
2573 __alignof__(struct sigqueue
),
2574 SLAB_PANIC
, NULL
, NULL
);