#include <linux/list.h>
#include <uapi/linux/signal.h>
#include <linux/bitops.h>
#include <linux/string.h>
Go to the source code of this file.
|
| #define | SIGQUEUE_PREALLOC 1 |
| |
| #define | sigmask(sig) (1UL << ((sig) - 1)) |
| |
| #define | _SIG_SET_BINOP(name, op) |
| |
| #define | _sig_or(x, y) ((x) | (y)) |
| |
| #define | _sig_and(x, y) ((x) & (y)) |
| |
| #define | _sig_andn(x, y) ((x) & ~(y)) |
| |
| #define | _SIG_SET_OP(name, op) |
| |
| #define | _sig_not(x) (~(x)) |
| |
| #define | SIGEMT_MASK 0 |
| |
| #define | rt_sigmask(sig) sigmask(sig) |
| |
| #define | siginmask(sig, mask) (rt_sigmask(sig) & (mask)) |
| |
| #define | SIG_KERNEL_ONLY_MASK |
| |
| #define | SIG_KERNEL_STOP_MASK |
| |
| #define | SIG_KERNEL_COREDUMP_MASK |
| |
| #define | SIG_KERNEL_IGNORE_MASK |
| |
| #define | sig_kernel_only(sig) (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_ONLY_MASK)) |
| |
| #define | sig_kernel_coredump(sig) (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_COREDUMP_MASK)) |
| |
| #define | sig_kernel_ignore(sig) (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_IGNORE_MASK)) |
| |
| #define | sig_kernel_stop(sig) (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_STOP_MASK)) |
| |
| #define | sig_user_defined(t, signr) |
| |
| #define | sig_fatal(t, signr) |
| |
|
| void | flush_sigqueue (struct sigpending *queue) |
| |
| int | next_signal (struct sigpending *pending, sigset_t *mask) |
| |
| int | do_send_sig_info (int sig, struct siginfo *info, struct task_struct *p, bool group) |
| |
| int | group_send_sig_info (int sig, struct siginfo *info, struct task_struct *p) |
| |
| int | __group_send_sig_info (int, struct siginfo *, struct task_struct *) |
| |
| long | do_rt_tgsigqueueinfo (pid_t tgid, pid_t pid, int sig, siginfo_t *info) |
| |
| long | do_sigpending (void __user *, unsigned long) |
| |
| int | do_sigtimedwait (const sigset_t *, siginfo_t *, const struct timespec *) |
| |
| int | sigprocmask (int, sigset_t *, sigset_t *) |
| |
| void | set_current_blocked (sigset_t *) |
| |
| void | __set_current_blocked (const sigset_t *) |
| |
| int | sigsuspend (sigset_t *) |
| |
| int | get_signal_to_deliver (siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie) |
| |
| void | signal_delivered (int sig, siginfo_t *info, struct k_sigaction *ka, struct pt_regs *regs, int stepping) |
| |
| void | exit_signals (struct task_struct *tsk) |
| |
| int | unhandled_signal (struct task_struct *tsk, int sig) |
| |
| void | signals_init (void) |
| |
| #define _sig_and |
( |
|
x, |
|
|
|
y |
|
) |
| ((x) & (y)) |
| #define _sig_andn |
( |
|
x, |
|
|
|
y |
|
) |
| ((x) & ~(y)) |
| #define _sig_not |
( |
|
x | ) |
(~(x)) |
| #define _sig_or |
( |
|
x, |
|
|
|
y |
|
) |
| ((x) | (y)) |
| #define _SIG_SET_BINOP |
( |
|
name, |
|
|
|
op |
|
) |
| |
Value:
{ \
extern void _NSIG_WORDS_is_unsupported_size(void); \
unsigned
long a0,
a1,
a2,
a3, b0, b1, b2, b3; \
\
case 4: \
a3 =
a->sig[3]; a2 =
a->sig[2]; \
b3 =
b->sig[3]; b2 =
b->sig[2]; \
r->sig[3] =
op(a3, b3); \
r->sig[2] =
op(a2, b2); \
case 2: \
a1 =
a->sig[1]; b1 =
b->sig[1]; \
r->sig[1] =
op(a1, b1); \
case 1: \
a0 =
a->sig[0]; b0 =
b->sig[0]; \
r->sig[0] =
op(a0, b0); \
break; \
default: \
_NSIG_WORDS_is_unsupported_size(); \
} \
}
Definition at line 95 of file signal.h.
| #define _SIG_SET_OP |
( |
|
name, |
|
|
|
op |
|
) |
| |
Value:
{ \
extern void _NSIG_WORDS_is_unsupported_size(void); \
\
case 4:
set->sig[3] =
op(
set->sig[3]); \
set->sig[2] =
op(
set->sig[2]); \
case 2:
set->sig[1] =
op(
set->sig[1]); \
case 1:
set->sig[0] =
op(
set->sig[0]); \
break; \
default: \
_NSIG_WORDS_is_unsupported_size(); \
} \
}
Definition at line 133 of file signal.h.
| #define sig_fatal |
( |
|
t, |
|
|
|
signr |
|
) |
| |
Value:
(
t)->sighand->action[(signr)-1].sa.sa_handler ==
SIG_DFL)
Definition at line 382 of file signal.h.
| #define SIG_KERNEL_COREDUMP_MASK |
| #define SIG_KERNEL_IGNORE_MASK |
| #define SIG_KERNEL_ONLY_MASK |
| #define SIG_KERNEL_STOP_MASK |
| #define sig_user_defined |
( |
|
t, |
|
|
|
signr |
|
) |
| |
Value:(((
t)->sighand->action[(signr)-1].sa.sa_handler !=
SIG_DFL) && \
((
t)->sighand->action[(signr)-1].
sa.sa_handler !=
SIG_IGN))
Definition at line 378 of file signal.h.
| #define sigmask |
( |
|
sig | ) |
(1UL << ((sig) - 1)) |
| #define SIGQUEUE_PREALLOC 1 |
do_sigtimedwait - wait for queued signals specified in : queued signals to wait for : if non-null, the signal's siginfo is returned here : upper bound on process time suspension
Definition at line 2749 of file signal.c.
set_current_blocked - change current->blocked mask : new mask
It is wrong to change ->blocked directly, this helper should be used to ensure the process can't miss a shared signal we are going to block.
Definition at line 2537 of file signal.c.
signal_delivered - : number of signal being delivered : siginfo_t of signal being delivered : sigaction setting that chose the handler : user register state : nonzero if debugger single-step or block-step in use
This function should be called when a signal has succesfully been delivered. It updates the blocked signals accordingly (->sa.sa_mask is always blocked, and the signal itself is blocked unless SA_NODEFER is set in ->sa.sa_flags. Tracing is notified.
Definition at line 2389 of file signal.c.
| int show_unhandled_signals |
1.8.2