Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : #ifndef _LINUX_SIGNAL_H
3 : : #define _LINUX_SIGNAL_H
4 : :
5 : : #include <linux/bug.h>
6 : : #include <linux/signal_types.h>
7 : : #include <linux/string.h>
8 : :
9 : : struct task_struct;
10 : :
11 : : /* for sysctl */
12 : : extern int print_fatal_signals;
13 : :
14 : 2076 : static inline void copy_siginfo(kernel_siginfo_t *to,
15 : : const kernel_siginfo_t *from)
16 : : {
17 [ - + ]: 1025 : memcpy(to, from, sizeof(*to));
18 : 1051 : }
19 : :
20 : 5467 : static inline void clear_siginfo(kernel_siginfo_t *info)
21 : : {
22 [ - - - - : 5467 : memset(info, 0, sizeof(*info));
- - - - -
- - - - -
- ]
23 : : }
24 : :
25 : : #define SI_EXPANSION_SIZE (sizeof(struct siginfo) - sizeof(struct kernel_siginfo))
26 : :
27 : : int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from);
28 : : int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from);
29 : :
30 : : enum siginfo_layout {
31 : : SIL_KILL,
32 : : SIL_TIMER,
33 : : SIL_POLL,
34 : : SIL_FAULT,
35 : : SIL_FAULT_MCEERR,
36 : : SIL_FAULT_BNDERR,
37 : : SIL_FAULT_PKUERR,
38 : : SIL_CHLD,
39 : : SIL_RT,
40 : : SIL_SYS,
41 : : };
42 : :
43 : : enum siginfo_layout siginfo_layout(unsigned sig, int si_code);
44 : :
45 : : /*
46 : : * Define some primitives to manipulate sigset_t.
47 : : */
48 : :
49 : : #ifndef __HAVE_ARCH_SIG_BITOPS
50 : : #include <linux/bitops.h>
51 : :
52 : : /* We don't use <linux/bitops.h> for these because there is no need to
53 : : be atomic. */
54 : 44700 : static inline void sigaddset(sigset_t *set, int _sig)
55 : : {
56 : 44700 : unsigned long sig = _sig - 1;
57 : 44700 : if (_NSIG_WORDS == 1)
58 [ - + - - ]: 44089 : set->sig[0] |= 1UL << sig;
59 : : else
60 : : set->sig[sig / _NSIG_BPW] |= 1UL << (sig % _NSIG_BPW);
61 : 41530 : }
62 : :
63 : 1025 : static inline void sigdelset(sigset_t *set, int _sig)
64 : : {
65 : 1025 : unsigned long sig = _sig - 1;
66 : 1025 : if (_NSIG_WORDS == 1)
67 [ + - ]: 1025 : set->sig[0] &= ~(1UL << sig);
68 : : else
69 : : set->sig[sig / _NSIG_BPW] &= ~(1UL << (sig % _NSIG_BPW));
70 : 0 : }
71 : :
72 : 80656 : static inline int sigismember(sigset_t *set, int _sig)
73 : : {
74 : 80656 : unsigned long sig = _sig - 1;
75 : 80656 : if (_NSIG_WORDS == 1)
76 [ + + + + : 33118 : return 1 & (set->sig[0] >> sig);
+ + + + -
- + + + -
- - ]
77 : : else
78 : : return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
79 : : }
80 : :
81 : : #endif /* __HAVE_ARCH_SIG_BITOPS */
82 : :
83 : 4290 : static inline int sigisemptyset(sigset_t *set)
84 : : {
85 : 4290 : switch (_NSIG_WORDS) {
86 : : case 4:
87 : : return (set->sig[3] | set->sig[2] |
88 : : set->sig[1] | set->sig[0]) == 0;
89 : : case 2:
90 : : return (set->sig[1] | set->sig[0]) == 0;
91 : : case 1:
92 [ - - - - : 4290 : return set->sig[0] == 0;
- + ]
93 : : default:
94 : : BUILD_BUG();
95 : : return 0;
96 : : }
97 : : }
98 : :
99 : 9295 : static inline int sigequalsets(const sigset_t *set1, const sigset_t *set2)
100 : : {
101 : 9295 : switch (_NSIG_WORDS) {
102 : : case 4:
103 : : return (set1->sig[3] == set2->sig[3]) &&
104 : : (set1->sig[2] == set2->sig[2]) &&
105 : : (set1->sig[1] == set2->sig[1]) &&
106 : : (set1->sig[0] == set2->sig[0]);
107 : : case 2:
108 : : return (set1->sig[1] == set2->sig[1]) &&
109 : : (set1->sig[0] == set2->sig[0]);
110 : : case 1:
111 [ + + ]: 9295 : return set1->sig[0] == set2->sig[0];
112 : : }
113 : : return 0;
114 : : }
115 : :
116 : : #define sigmask(sig) (1UL << ((sig) - 1))
117 : :
118 : : #ifndef __HAVE_ARCH_SIG_SETOPS
119 : : #include <linux/string.h>
120 : :
121 : : #define _SIG_SET_BINOP(name, op) \
122 : : static inline void name(sigset_t *r, const sigset_t *a, const sigset_t *b) \
123 : : { \
124 : : unsigned long a0, a1, a2, a3, b0, b1, b2, b3; \
125 : : \
126 : : switch (_NSIG_WORDS) { \
127 : : case 4: \
128 : : a3 = a->sig[3]; a2 = a->sig[2]; \
129 : : b3 = b->sig[3]; b2 = b->sig[2]; \
130 : : r->sig[3] = op(a3, b3); \
131 : : r->sig[2] = op(a2, b2); \
132 : : /* fall through */ \
133 : : case 2: \
134 : : a1 = a->sig[1]; b1 = b->sig[1]; \
135 : : r->sig[1] = op(a1, b1); \
136 : : /* fall through */ \
137 : : case 1: \
138 : : a0 = a->sig[0]; b0 = b->sig[0]; \
139 : : r->sig[0] = op(a0, b0); \
140 : : break; \
141 : : default: \
142 : : BUILD_BUG(); \
143 : : } \
144 : : }
145 : :
146 : : #define _sig_or(x,y) ((x) | (y))
147 [ + - ]: 1833 : _SIG_SET_BINOP(sigorsets, _sig_or)
148 : :
149 : : #define _sig_and(x,y) ((x) & (y))
150 [ - - - + ]: 4290 : _SIG_SET_BINOP(sigandsets, _sig_and)
151 : :
152 : : #define _sig_andn(x,y) ((x) & ~(y))
153 : 3900 : _SIG_SET_BINOP(sigandnsets, _sig_andn)
154 : :
155 : : #undef _SIG_SET_BINOP
156 : : #undef _sig_or
157 : : #undef _sig_and
158 : : #undef _sig_andn
159 : :
160 : : #define _SIG_SET_OP(name, op) \
161 : : static inline void name(sigset_t *set) \
162 : : { \
163 : : switch (_NSIG_WORDS) { \
164 : : case 4: set->sig[3] = op(set->sig[3]); \
165 : : set->sig[2] = op(set->sig[2]); \
166 : : /* fall through */ \
167 : : case 2: set->sig[1] = op(set->sig[1]); \
168 : : /* fall through */ \
169 : : case 1: set->sig[0] = op(set->sig[0]); \
170 : : break; \
171 : : default: \
172 : : BUILD_BUG(); \
173 : : } \
174 : : }
175 : :
176 : : #define _sig_not(x) (~(x))
177 [ + + ]: 481 : _SIG_SET_OP(signotset, _sig_not)
178 : :
179 : : #undef _SIG_SET_OP
180 : : #undef _sig_not
181 : :
182 : 381972 : static inline void sigemptyset(sigset_t *set)
183 : : {
184 : 381972 : switch (_NSIG_WORDS) {
185 : : default:
186 : : memset(set, 0, sizeof(sigset_t));
187 : : break;
188 : : case 2: set->sig[1] = 0;
189 : : /* fall through */
190 : 381972 : case 1: set->sig[0] = 0;
191 : 359018 : break;
192 : : }
193 : 10894 : }
194 : :
195 : : static inline void sigfillset(sigset_t *set)
196 : : {
197 : : switch (_NSIG_WORDS) {
198 : : default:
199 : : memset(set, -1, sizeof(sigset_t));
200 : : break;
201 : : case 2: set->sig[1] = -1;
202 : : /* fall through */
203 : : case 1: set->sig[0] = -1;
204 : : break;
205 : : }
206 : : }
207 : :
208 : : /* Some extensions for manipulating the low 32 signals in particular. */
209 : :
210 : 0 : static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
211 : : {
212 : 0 : set->sig[0] |= mask;
213 : 0 : }
214 : :
215 : 36244 : static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
216 : : {
217 [ + + ]: 36244 : set->sig[0] &= ~mask;
218 : 0 : }
219 : :
220 : : static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
221 : : {
222 : : return (set->sig[0] & mask) != 0;
223 : : }
224 : :
225 : 13 : static inline void siginitset(sigset_t *set, unsigned long mask)
226 : : {
227 : 13 : set->sig[0] = mask;
228 : 13 : switch (_NSIG_WORDS) {
229 : : default:
230 : : memset(&set->sig[1], 0, sizeof(long)*(_NSIG_WORDS-1));
231 : : break;
232 : : case 2: set->sig[1] = 0;
233 : 13 : case 1: ;
234 : : }
235 : 0 : }
236 : :
237 : : static inline void siginitsetinv(sigset_t *set, unsigned long mask)
238 : : {
239 : : set->sig[0] = ~mask;
240 : : switch (_NSIG_WORDS) {
241 : : default:
242 : : memset(&set->sig[1], -1, sizeof(long)*(_NSIG_WORDS-1));
243 : : break;
244 : : case 2: set->sig[1] = -1;
245 : : case 1: ;
246 : : }
247 : : }
248 : :
249 : : #endif /* __HAVE_ARCH_SIG_SETOPS */
250 : :
251 : 12060 : static inline void init_sigpending(struct sigpending *sig)
252 : : {
253 : 12060 : sigemptyset(&sig->signal);
254 : 12060 : INIT_LIST_HEAD(&sig->list);
255 : : }
256 : :
257 : : extern void flush_sigqueue(struct sigpending *queue);
258 : :
259 : : /* Test if 'sig' is valid signal. Use this instead of testing _NSIG directly */
260 : 33934 : static inline int valid_signal(unsigned long sig)
261 : : {
262 [ + - + - : 33934 : return sig <= _NSIG ? 1 : 0;
- - - - -
- - - +
- ]
263 : : }
264 : :
265 : : struct timespec;
266 : : struct pt_regs;
267 : : enum pid_type;
268 : :
269 : : extern int next_signal(struct sigpending *pending, sigset_t *mask);
270 : : extern int do_send_sig_info(int sig, struct kernel_siginfo *info,
271 : : struct task_struct *p, enum pid_type type);
272 : : extern int group_send_sig_info(int sig, struct kernel_siginfo *info,
273 : : struct task_struct *p, enum pid_type type);
274 : : extern int __group_send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
275 : : extern int sigprocmask(int, sigset_t *, sigset_t *);
276 : : extern void set_current_blocked(sigset_t *);
277 : : extern void __set_current_blocked(const sigset_t *);
278 : : extern int show_unhandled_signals;
279 : :
280 : : extern bool get_signal(struct ksignal *ksig);
281 : : extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
282 : : extern void exit_signals(struct task_struct *tsk);
283 : : extern void kernel_sigaction(int, __sighandler_t);
284 : :
285 : : #define SIG_KTHREAD ((__force __sighandler_t)2)
286 : : #define SIG_KTHREAD_KERNEL ((__force __sighandler_t)3)
287 : :
288 : 0 : static inline void allow_signal(int sig)
289 : : {
290 : : /*
291 : : * Kernel threads handle their own signals. Let the signal code
292 : : * know it'll be handled, so that they don't get converted to
293 : : * SIGKILL or just silently dropped.
294 : : */
295 : 0 : kernel_sigaction(sig, SIG_KTHREAD);
296 : 0 : }
297 : :
298 : 0 : static inline void allow_kernel_signal(int sig)
299 : : {
300 : : /*
301 : : * Kernel threads handle their own signals. Let the signal code
302 : : * know signals sent by the kernel will be handled, so that they
303 : : * don't get silently dropped.
304 : : */
305 : 0 : kernel_sigaction(sig, SIG_KTHREAD_KERNEL);
306 : : }
307 : :
308 : : static inline void disallow_signal(int sig)
309 : : {
310 : : kernel_sigaction(sig, SIG_IGN);
311 : : }
312 : :
313 : : extern struct kmem_cache *sighand_cachep;
314 : :
315 : : extern bool unhandled_signal(struct task_struct *tsk, int sig);
316 : :
317 : : /*
318 : : * In POSIX a signal is sent either to a specific thread (Linux task)
319 : : * or to the process as a whole (Linux thread group). How the signal
320 : : * is sent determines whether it's to one thread or the whole group,
321 : : * which determines which signal mask(s) are involved in blocking it
322 : : * from being delivered until later. When the signal is delivered,
323 : : * either it's caught or ignored by a user handler or it has a default
324 : : * effect that applies to the whole thread group (POSIX process).
325 : : *
326 : : * The possible effects an unblocked signal set to SIG_DFL can have are:
327 : : * ignore - Nothing Happens
328 : : * terminate - kill the process, i.e. all threads in the group,
329 : : * similar to exit_group. The group leader (only) reports
330 : : * WIFSIGNALED status to its parent.
331 : : * coredump - write a core dump file describing all threads using
332 : : * the same mm and then kill all those threads
333 : : * stop - stop all the threads in the group, i.e. TASK_STOPPED state
334 : : *
335 : : * SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.
336 : : * Other signals when not blocked and set to SIG_DFL behaves as follows.
337 : : * The job control signals also have other special effects.
338 : : *
339 : : * +--------------------+------------------+
340 : : * | POSIX signal | default action |
341 : : * +--------------------+------------------+
342 : : * | SIGHUP | terminate |
343 : : * | SIGINT | terminate |
344 : : * | SIGQUIT | coredump |
345 : : * | SIGILL | coredump |
346 : : * | SIGTRAP | coredump |
347 : : * | SIGABRT/SIGIOT | coredump |
348 : : * | SIGBUS | coredump |
349 : : * | SIGFPE | coredump |
350 : : * | SIGKILL | terminate(+) |
351 : : * | SIGUSR1 | terminate |
352 : : * | SIGSEGV | coredump |
353 : : * | SIGUSR2 | terminate |
354 : : * | SIGPIPE | terminate |
355 : : * | SIGALRM | terminate |
356 : : * | SIGTERM | terminate |
357 : : * | SIGCHLD | ignore |
358 : : * | SIGCONT | ignore(*) |
359 : : * | SIGSTOP | stop(*)(+) |
360 : : * | SIGTSTP | stop(*) |
361 : : * | SIGTTIN | stop(*) |
362 : : * | SIGTTOU | stop(*) |
363 : : * | SIGURG | ignore |
364 : : * | SIGXCPU | coredump |
365 : : * | SIGXFSZ | coredump |
366 : : * | SIGVTALRM | terminate |
367 : : * | SIGPROF | terminate |
368 : : * | SIGPOLL/SIGIO | terminate |
369 : : * | SIGSYS/SIGUNUSED | coredump |
370 : : * | SIGSTKFLT | terminate |
371 : : * | SIGWINCH | ignore |
372 : : * | SIGPWR | terminate |
373 : : * | SIGRTMIN-SIGRTMAX | terminate |
374 : : * +--------------------+------------------+
375 : : * | non-POSIX signal | default action |
376 : : * +--------------------+------------------+
377 : : * | SIGEMT | coredump |
378 : : * +--------------------+------------------+
379 : : *
380 : : * (+) For SIGKILL and SIGSTOP the action is "always", not just "default".
381 : : * (*) Special job control effects:
382 : : * When SIGCONT is sent, it resumes the process (all threads in the group)
383 : : * from TASK_STOPPED state and also clears any pending/queued stop signals
384 : : * (any of those marked with "stop(*)"). This happens regardless of blocking,
385 : : * catching, or ignoring SIGCONT. When any stop signal is sent, it clears
386 : : * any pending/queued SIGCONT signals; this happens regardless of blocking,
387 : : * catching, or ignored the stop signal, though (except for SIGSTOP) the
388 : : * default action of stopping the process may happen later or never.
389 : : */
390 : :
391 : : #ifdef SIGEMT
392 : : #define SIGEMT_MASK rt_sigmask(SIGEMT)
393 : : #else
394 : : #define SIGEMT_MASK 0
395 : : #endif
396 : :
397 : : #if SIGRTMIN > BITS_PER_LONG
398 : : #define rt_sigmask(sig) (1ULL << ((sig)-1))
399 : : #else
400 : : #define rt_sigmask(sig) sigmask(sig)
401 : : #endif
402 : :
403 : : #define siginmask(sig, mask) \
404 : : ((sig) > 0 && (sig) < SIGRTMIN && (rt_sigmask(sig) & (mask)))
405 : :
406 : : #define SIG_KERNEL_ONLY_MASK (\
407 : : rt_sigmask(SIGKILL) | rt_sigmask(SIGSTOP))
408 : :
409 : : #define SIG_KERNEL_STOP_MASK (\
410 : : rt_sigmask(SIGSTOP) | rt_sigmask(SIGTSTP) | \
411 : : rt_sigmask(SIGTTIN) | rt_sigmask(SIGTTOU) )
412 : :
413 : : #define SIG_KERNEL_COREDUMP_MASK (\
414 : : rt_sigmask(SIGQUIT) | rt_sigmask(SIGILL) | \
415 : : rt_sigmask(SIGTRAP) | rt_sigmask(SIGABRT) | \
416 : : rt_sigmask(SIGFPE) | rt_sigmask(SIGSEGV) | \
417 : : rt_sigmask(SIGBUS) | rt_sigmask(SIGSYS) | \
418 : : rt_sigmask(SIGXCPU) | rt_sigmask(SIGXFSZ) | \
419 : : SIGEMT_MASK )
420 : :
421 : : #define SIG_KERNEL_IGNORE_MASK (\
422 : : rt_sigmask(SIGCONT) | rt_sigmask(SIGCHLD) | \
423 : : rt_sigmask(SIGWINCH) | rt_sigmask(SIGURG) )
424 : :
425 : : #define SIG_SPECIFIC_SICODES_MASK (\
426 : : rt_sigmask(SIGILL) | rt_sigmask(SIGFPE) | \
427 : : rt_sigmask(SIGSEGV) | rt_sigmask(SIGBUS) | \
428 : : rt_sigmask(SIGTRAP) | rt_sigmask(SIGCHLD) | \
429 : : rt_sigmask(SIGPOLL) | rt_sigmask(SIGSYS) | \
430 : : SIGEMT_MASK )
431 : :
432 : : #define sig_kernel_only(sig) siginmask(sig, SIG_KERNEL_ONLY_MASK)
433 : : #define sig_kernel_coredump(sig) siginmask(sig, SIG_KERNEL_COREDUMP_MASK)
434 : : #define sig_kernel_ignore(sig) siginmask(sig, SIG_KERNEL_IGNORE_MASK)
435 : : #define sig_kernel_stop(sig) siginmask(sig, SIG_KERNEL_STOP_MASK)
436 : : #define sig_specific_sicodes(sig) siginmask(sig, SIG_SPECIFIC_SICODES_MASK)
437 : :
438 : : #define sig_fatal(t, signr) \
439 : : (!siginmask(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
440 : : (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
441 : :
442 : : void signals_init(void);
443 : :
444 : : int restore_altstack(const stack_t __user *);
445 : : int __save_altstack(stack_t __user *, unsigned long);
446 : :
447 : : #define save_altstack_ex(uss, sp) do { \
448 : : stack_t __user *__uss = uss; \
449 : : struct task_struct *t = current; \
450 : : put_user_ex((void __user *)t->sas_ss_sp, &__uss->ss_sp); \
451 : : put_user_ex(t->sas_ss_flags, &__uss->ss_flags); \
452 : : put_user_ex(t->sas_ss_size, &__uss->ss_size); \
453 : : if (t->sas_ss_flags & SS_AUTODISARM) \
454 : : sas_ss_reset(t); \
455 : : } while (0);
456 : :
457 : : #ifdef CONFIG_PROC_FS
458 : : struct seq_file;
459 : : extern void render_sigset_t(struct seq_file *, const char *, sigset_t *);
460 : : #endif
461 : :
462 : : #endif /* _LINUX_SIGNAL_H */
|
