1
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
9struct task_struct;
10
11
12extern int print_fatal_signals;
13
14static inline void copy_siginfo(kernel_siginfo_t *to,
15 const kernel_siginfo_t *from)
16{
17 memcpy(to, from, sizeof(*to));
18}
19
20static inline void clear_siginfo(kernel_siginfo_t *info)
21{
22 memset(info, 0, sizeof(*info));
23}
24
25#define SI_EXPANSION_SIZE (sizeof(struct siginfo) - sizeof(struct kernel_siginfo))
26
27static inline void copy_siginfo_to_external(siginfo_t *to,
28 const kernel_siginfo_t *from)
29{
30 memcpy(to, from, sizeof(*from));
31 memset(((char *)to) + sizeof(struct kernel_siginfo), 0,
32 SI_EXPANSION_SIZE);
33}
34
35int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from);
36int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from);
37
38enum siginfo_layout {
39 SIL_KILL,
40 SIL_TIMER,
41 SIL_POLL,
42 SIL_FAULT,
43 SIL_FAULT_TRAPNO,
44 SIL_FAULT_MCEERR,
45 SIL_FAULT_BNDERR,
46 SIL_FAULT_PKUERR,
47 SIL_FAULT_PERF_EVENT,
48 SIL_CHLD,
49 SIL_RT,
50 SIL_SYS,
51};
52
53enum siginfo_layout siginfo_layout(unsigned sig, int si_code);
54
55
56
57
58
59#ifndef __HAVE_ARCH_SIG_BITOPS
60#include <linux/bitops.h>
61
62
63
64static inline void sigaddset(sigset_t *set, int _sig)
65{
66 unsigned long sig = _sig - 1;
67 if (_NSIG_WORDS == 1)
68 set->sig[0] |= 1UL << sig;
69 else
70 set->sig[sig / _NSIG_BPW] |= 1UL << (sig % _NSIG_BPW);
71}
72
73static inline void sigdelset(sigset_t *set, int _sig)
74{
75 unsigned long sig = _sig - 1;
76 if (_NSIG_WORDS == 1)
77 set->sig[0] &= ~(1UL << sig);
78 else
79 set->sig[sig / _NSIG_BPW] &= ~(1UL << (sig % _NSIG_BPW));
80}
81
82static inline int sigismember(sigset_t *set, int _sig)
83{
84 unsigned long sig = _sig - 1;
85 if (_NSIG_WORDS == 1)
86 return 1 & (set->sig[0] >> sig);
87 else
88 return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
89}
90
91#endif
92
93static inline int sigisemptyset(sigset_t *set)
94{
95 switch (_NSIG_WORDS) {
96 case 4:
97 return (set->sig[3] | set->sig[2] |
98 set->sig[1] | set->sig[0]) == 0;
99 case 2:
100 return (set->sig[1] | set->sig[0]) == 0;
101 case 1:
102 return set->sig[0] == 0;
103 default:
104 BUILD_BUG();
105 return 0;
106 }
107}
108
109static inline int sigequalsets(const sigset_t *set1, const sigset_t *set2)
110{
111 switch (_NSIG_WORDS) {
112 case 4:
113 return (set1->sig[3] == set2->sig[3]) &&
114 (set1->sig[2] == set2->sig[2]) &&
115 (set1->sig[1] == set2->sig[1]) &&
116 (set1->sig[0] == set2->sig[0]);
117 case 2:
118 return (set1->sig[1] == set2->sig[1]) &&
119 (set1->sig[0] == set2->sig[0]);
120 case 1:
121 return set1->sig[0] == set2->sig[0];
122 }
123 return 0;
124}
125
126#define sigmask(sig) (1UL << ((sig) - 1))
127
128#ifndef __HAVE_ARCH_SIG_SETOPS
129#include <linux/string.h>
130
131#define _SIG_SET_BINOP(name, op) \
132static inline void name(sigset_t *r, const sigset_t *a, const sigset_t *b) \
133{ \
134 unsigned long a0, a1, a2, a3, b0, b1, b2, b3; \
135 \
136 switch (_NSIG_WORDS) { \
137 case 4: \
138 a3 = a->sig[3]; a2 = a->sig[2]; \
139 b3 = b->sig[3]; b2 = b->sig[2]; \
140 r->sig[3] = op(a3, b3); \
141 r->sig[2] = op(a2, b2); \
142 fallthrough; \
143 case 2: \
144 a1 = a->sig[1]; b1 = b->sig[1]; \
145 r->sig[1] = op(a1, b1); \
146 fallthrough; \
147 case 1: \
148 a0 = a->sig[0]; b0 = b->sig[0]; \
149 r->sig[0] = op(a0, b0); \
150 break; \
151 default: \
152 BUILD_BUG(); \
153 } \
154}
155
156#define _sig_or(x,y) ((x) | (y))
157_SIG_SET_BINOP(sigorsets, _sig_or)
158
159#define _sig_and(x,y) ((x) & (y))
160_SIG_SET_BINOP(sigandsets, _sig_and)
161
162#define _sig_andn(x,y) ((x) & ~(y))
163_SIG_SET_BINOP(sigandnsets, _sig_andn)
164
165#undef _SIG_SET_BINOP
166#undef _sig_or
167#undef _sig_and
168#undef _sig_andn
169
170#define _SIG_SET_OP(name, op) \
171static inline void name(sigset_t *set) \
172{ \
173 switch (_NSIG_WORDS) { \
174 case 4: set->sig[3] = op(set->sig[3]); \
175 set->sig[2] = op(set->sig[2]); \
176 fallthrough; \
177 case 2: set->sig[1] = op(set->sig[1]); \
178 fallthrough; \
179 case 1: set->sig[0] = op(set->sig[0]); \
180 break; \
181 default: \
182 BUILD_BUG(); \
183 } \
184}
185
186#define _sig_not(x) (~(x))
187_SIG_SET_OP(signotset, _sig_not)
188
189#undef _SIG_SET_OP
190#undef _sig_not
191
192static inline void sigemptyset(sigset_t *set)
193{
194 switch (_NSIG_WORDS) {
195 default:
196 memset(set, 0, sizeof(sigset_t));
197 break;
198 case 2: set->sig[1] = 0;
199 fallthrough;
200 case 1: set->sig[0] = 0;
201 break;
202 }
203}
204
205static inline void sigfillset(sigset_t *set)
206{
207 switch (_NSIG_WORDS) {
208 default:
209 memset(set, -1, sizeof(sigset_t));
210 break;
211 case 2: set->sig[1] = -1;
212 fallthrough;
213 case 1: set->sig[0] = -1;
214 break;
215 }
216}
217
218
219
220static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
221{
222 set->sig[0] |= mask;
223}
224
225static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
226{
227 set->sig[0] &= ~mask;
228}
229
230static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
231{
232 return (set->sig[0] & mask) != 0;
233}
234
235static inline void siginitset(sigset_t *set, unsigned long mask)
236{
237 set->sig[0] = mask;
238 switch (_NSIG_WORDS) {
239 default:
240 memset(&set->sig[1], 0, sizeof(long)*(_NSIG_WORDS-1));
241 break;
242 case 2: set->sig[1] = 0;
243 break;
244 case 1: ;
245 }
246}
247
248static inline void siginitsetinv(sigset_t *set, unsigned long mask)
249{
250 set->sig[0] = ~mask;
251 switch (_NSIG_WORDS) {
252 default:
253 memset(&set->sig[1], -1, sizeof(long)*(_NSIG_WORDS-1));
254 break;
255 case 2: set->sig[1] = -1;
256 break;
257 case 1: ;
258 }
259}
260
261#endif
262
263static inline void init_sigpending(struct sigpending *sig)
264{
265 sigemptyset(&sig->signal);
266 INIT_LIST_HEAD(&sig->list);
267}
268
269extern void flush_sigqueue(struct sigpending *queue);
270
271
272static inline int valid_signal(unsigned long sig)
273{
274 return sig <= _NSIG ? 1 : 0;
275}
276
277struct timespec;
278struct pt_regs;
279enum pid_type;
280
281extern int next_signal(struct sigpending *pending, sigset_t *mask);
282extern int do_send_sig_info(int sig, struct kernel_siginfo *info,
283 struct task_struct *p, enum pid_type type);
284extern int group_send_sig_info(int sig, struct kernel_siginfo *info,
285 struct task_struct *p, enum pid_type type);
286extern int __group_send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
287extern int sigprocmask(int, sigset_t *, sigset_t *);
288extern void set_current_blocked(sigset_t *);
289extern void __set_current_blocked(const sigset_t *);
290extern int show_unhandled_signals;
291
292extern bool get_signal(struct ksignal *ksig);
293extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
294extern void exit_signals(struct task_struct *tsk);
295extern void kernel_sigaction(int, __sighandler_t);
296
297#define SIG_KTHREAD ((__force __sighandler_t)2)
298#define SIG_KTHREAD_KERNEL ((__force __sighandler_t)3)
299
300static inline void allow_signal(int sig)
301{
302
303
304
305
306
307 kernel_sigaction(sig, SIG_KTHREAD);
308}
309
310static inline void allow_kernel_signal(int sig)
311{
312
313
314
315
316
317 kernel_sigaction(sig, SIG_KTHREAD_KERNEL);
318}
319
320static inline void disallow_signal(int sig)
321{
322 kernel_sigaction(sig, SIG_IGN);
323}
324
325extern struct kmem_cache *sighand_cachep;
326
327extern bool unhandled_signal(struct task_struct *tsk, int sig);
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403#ifdef SIGEMT
404#define SIGEMT_MASK rt_sigmask(SIGEMT)
405#else
406#define SIGEMT_MASK 0
407#endif
408
409#if SIGRTMIN > BITS_PER_LONG
410#define rt_sigmask(sig) (1ULL << ((sig)-1))
411#else
412#define rt_sigmask(sig) sigmask(sig)
413#endif
414
415#define siginmask(sig, mask) \
416 ((sig) > 0 && (sig) < SIGRTMIN && (rt_sigmask(sig) & (mask)))
417
418#define SIG_KERNEL_ONLY_MASK (\
419 rt_sigmask(SIGKILL) | rt_sigmask(SIGSTOP))
420
421#define SIG_KERNEL_STOP_MASK (\
422 rt_sigmask(SIGSTOP) | rt_sigmask(SIGTSTP) | \
423 rt_sigmask(SIGTTIN) | rt_sigmask(SIGTTOU) )
424
425#define SIG_KERNEL_COREDUMP_MASK (\
426 rt_sigmask(SIGQUIT) | rt_sigmask(SIGILL) | \
427 rt_sigmask(SIGTRAP) | rt_sigmask(SIGABRT) | \
428 rt_sigmask(SIGFPE) | rt_sigmask(SIGSEGV) | \
429 rt_sigmask(SIGBUS) | rt_sigmask(SIGSYS) | \
430 rt_sigmask(SIGXCPU) | rt_sigmask(SIGXFSZ) | \
431 SIGEMT_MASK )
432
433#define SIG_KERNEL_IGNORE_MASK (\
434 rt_sigmask(SIGCONT) | rt_sigmask(SIGCHLD) | \
435 rt_sigmask(SIGWINCH) | rt_sigmask(SIGURG) )
436
437#define SIG_SPECIFIC_SICODES_MASK (\
438 rt_sigmask(SIGILL) | rt_sigmask(SIGFPE) | \
439 rt_sigmask(SIGSEGV) | rt_sigmask(SIGBUS) | \
440 rt_sigmask(SIGTRAP) | rt_sigmask(SIGCHLD) | \
441 rt_sigmask(SIGPOLL) | rt_sigmask(SIGSYS) | \
442 SIGEMT_MASK )
443
444#define sig_kernel_only(sig) siginmask(sig, SIG_KERNEL_ONLY_MASK)
445#define sig_kernel_coredump(sig) siginmask(sig, SIG_KERNEL_COREDUMP_MASK)
446#define sig_kernel_ignore(sig) siginmask(sig, SIG_KERNEL_IGNORE_MASK)
447#define sig_kernel_stop(sig) siginmask(sig, SIG_KERNEL_STOP_MASK)
448#define sig_specific_sicodes(sig) siginmask(sig, SIG_SPECIFIC_SICODES_MASK)
449
450#define sig_fatal(t, signr) \
451 (!siginmask(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
452 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
453
454void signals_init(void);
455
456int restore_altstack(const stack_t __user *);
457int __save_altstack(stack_t __user *, unsigned long);
458
459#define unsafe_save_altstack(uss, sp, label) do { \
460 stack_t __user *__uss = uss; \
461 struct task_struct *t = current; \
462 unsafe_put_user((void __user *)t->sas_ss_sp, &__uss->ss_sp, label); \
463 unsafe_put_user(t->sas_ss_flags, &__uss->ss_flags, label); \
464 unsafe_put_user(t->sas_ss_size, &__uss->ss_size, label); \
465} while (0);
466
467#ifdef CONFIG_PROC_FS
468struct seq_file;
469extern void render_sigset_t(struct seq_file *, const char *, sigset_t *);
470#endif
471
472#ifndef arch_untagged_si_addr
473
474
475
476
477
478static inline void __user *arch_untagged_si_addr(void __user *addr,
479 unsigned long sig,
480 unsigned long si_code)
481{
482 return addr;
483}
484#endif
485
486#endif
487