1#ifndef _LINUX_SIGNAL_H
2#define _LINUX_SIGNAL_H
3
4#include <linux/list.h>
5#include <linux/bug.h>
6#include <uapi/linux/signal.h>
7
8struct task_struct;
9
10
11extern int print_fatal_signals;
12
13
14
15
16struct sigqueue {
17 struct list_head list;
18 int flags;
19 siginfo_t info;
20 struct user_struct *user;
21};
22
23
24#define SIGQUEUE_PREALLOC 1
25
26struct sigpending {
27 struct list_head list;
28 sigset_t signal;
29};
30
31
32
33
34
35#ifndef __HAVE_ARCH_SIG_BITOPS
36#include <linux/bitops.h>
37
38
39
40static inline void sigaddset(sigset_t *set, int _sig)
41{
42 unsigned long sig = _sig - 1;
43 if (_NSIG_WORDS == 1)
44 set->sig[0] |= 1UL << sig;
45 else
46 set->sig[sig / _NSIG_BPW] |= 1UL << (sig % _NSIG_BPW);
47}
48
49static inline void sigdelset(sigset_t *set, int _sig)
50{
51 unsigned long sig = _sig - 1;
52 if (_NSIG_WORDS == 1)
53 set->sig[0] &= ~(1UL << sig);
54 else
55 set->sig[sig / _NSIG_BPW] &= ~(1UL << (sig % _NSIG_BPW));
56}
57
58static inline int sigismember(sigset_t *set, int _sig)
59{
60 unsigned long sig = _sig - 1;
61 if (_NSIG_WORDS == 1)
62 return 1 & (set->sig[0] >> sig);
63 else
64 return 1 & (set->sig[sig / _NSIG_BPW] >> (sig % _NSIG_BPW));
65}
66
67#endif
68
69static inline int sigisemptyset(sigset_t *set)
70{
71 switch (_NSIG_WORDS) {
72 case 4:
73 return (set->sig[3] | set->sig[2] |
74 set->sig[1] | set->sig[0]) == 0;
75 case 2:
76 return (set->sig[1] | set->sig[0]) == 0;
77 case 1:
78 return set->sig[0] == 0;
79 default:
80 BUILD_BUG();
81 return 0;
82 }
83}
84
85#define sigmask(sig) (1UL << ((sig) - 1))
86
87#ifndef __HAVE_ARCH_SIG_SETOPS
88#include <linux/string.h>
89
90#define _SIG_SET_BINOP(name, op) \
91static inline void name(sigset_t *r, const sigset_t *a, const sigset_t *b) \
92{ \
93 unsigned long a0, a1, a2, a3, b0, b1, b2, b3; \
94 \
95 switch (_NSIG_WORDS) { \
96 case 4: \
97 a3 = a->sig[3]; a2 = a->sig[2]; \
98 b3 = b->sig[3]; b2 = b->sig[2]; \
99 r->sig[3] = op(a3, b3); \
100 r->sig[2] = op(a2, b2); \
101 case 2: \
102 a1 = a->sig[1]; b1 = b->sig[1]; \
103 r->sig[1] = op(a1, b1); \
104 case 1: \
105 a0 = a->sig[0]; b0 = b->sig[0]; \
106 r->sig[0] = op(a0, b0); \
107 break; \
108 default: \
109 BUILD_BUG(); \
110 } \
111}
112
113#define _sig_or(x,y) ((x) | (y))
114_SIG_SET_BINOP(sigorsets, _sig_or)
115
116#define _sig_and(x,y) ((x) & (y))
117_SIG_SET_BINOP(sigandsets, _sig_and)
118
119#define _sig_andn(x,y) ((x) & ~(y))
120_SIG_SET_BINOP(sigandnsets, _sig_andn)
121
122#undef _SIG_SET_BINOP
123#undef _sig_or
124#undef _sig_and
125#undef _sig_andn
126
127#define _SIG_SET_OP(name, op) \
128static inline void name(sigset_t *set) \
129{ \
130 switch (_NSIG_WORDS) { \
131 case 4: set->sig[3] = op(set->sig[3]); \
132 set->sig[2] = op(set->sig[2]); \
133 case 2: set->sig[1] = op(set->sig[1]); \
134 case 1: set->sig[0] = op(set->sig[0]); \
135 break; \
136 default: \
137 BUILD_BUG(); \
138 } \
139}
140
141#define _sig_not(x) (~(x))
142_SIG_SET_OP(signotset, _sig_not)
143
144#undef _SIG_SET_OP
145#undef _sig_not
146
147static inline void sigemptyset(sigset_t *set)
148{
149 switch (_NSIG_WORDS) {
150 default:
151 memset(set, 0, sizeof(sigset_t));
152 break;
153 case 2: set->sig[1] = 0;
154 case 1: set->sig[0] = 0;
155 break;
156 }
157}
158
159static inline void sigfillset(sigset_t *set)
160{
161 switch (_NSIG_WORDS) {
162 default:
163 memset(set, -1, sizeof(sigset_t));
164 break;
165 case 2: set->sig[1] = -1;
166 case 1: set->sig[0] = -1;
167 break;
168 }
169}
170
171
172
173static inline void sigaddsetmask(sigset_t *set, unsigned long mask)
174{
175 set->sig[0] |= mask;
176}
177
178static inline void sigdelsetmask(sigset_t *set, unsigned long mask)
179{
180 set->sig[0] &= ~mask;
181}
182
183static inline int sigtestsetmask(sigset_t *set, unsigned long mask)
184{
185 return (set->sig[0] & mask) != 0;
186}
187
188static inline void siginitset(sigset_t *set, unsigned long mask)
189{
190 set->sig[0] = mask;
191 switch (_NSIG_WORDS) {
192 default:
193 memset(&set->sig[1], 0, sizeof(long)*(_NSIG_WORDS-1));
194 break;
195 case 2: set->sig[1] = 0;
196 case 1: ;
197 }
198}
199
200static inline void siginitsetinv(sigset_t *set, unsigned long mask)
201{
202 set->sig[0] = ~mask;
203 switch (_NSIG_WORDS) {
204 default:
205 memset(&set->sig[1], -1, sizeof(long)*(_NSIG_WORDS-1));
206 break;
207 case 2: set->sig[1] = -1;
208 case 1: ;
209 }
210}
211
212#endif
213
214static inline void init_sigpending(struct sigpending *sig)
215{
216 sigemptyset(&sig->signal);
217 INIT_LIST_HEAD(&sig->list);
218}
219
220extern void flush_sigqueue(struct sigpending *queue);
221
222
223static inline int valid_signal(unsigned long sig)
224{
225 return sig <= _NSIG ? 1 : 0;
226}
227
228struct timespec;
229struct pt_regs;
230
231extern int next_signal(struct sigpending *pending, sigset_t *mask);
232extern int do_send_sig_info(int sig, struct siginfo *info,
233 struct task_struct *p, bool group);
234extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
235extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
236extern int do_sigtimedwait(const sigset_t *, siginfo_t *,
237 const struct timespec *);
238extern int sigprocmask(int, sigset_t *, sigset_t *);
239extern void set_current_blocked(sigset_t *);
240extern void __set_current_blocked(const sigset_t *);
241extern int show_unhandled_signals;
242extern int sigsuspend(sigset_t *);
243
244struct sigaction {
245#ifndef __ARCH_HAS_IRIX_SIGACTION
246 __sighandler_t sa_handler;
247 unsigned long sa_flags;
248#else
249 unsigned int sa_flags;
250 __sighandler_t sa_handler;
251#endif
252#ifdef __ARCH_HAS_SA_RESTORER
253 __sigrestore_t sa_restorer;
254#endif
255 sigset_t sa_mask;
256};
257
258struct k_sigaction {
259 struct sigaction sa;
260#ifdef __ARCH_HAS_KA_RESTORER
261 __sigrestore_t ka_restorer;
262#endif
263};
264
265#ifdef CONFIG_OLD_SIGACTION
266struct old_sigaction {
267 __sighandler_t sa_handler;
268 old_sigset_t sa_mask;
269 unsigned long sa_flags;
270 __sigrestore_t sa_restorer;
271};
272#endif
273
274struct ksignal {
275 struct k_sigaction ka;
276 siginfo_t info;
277 int sig;
278};
279
280extern int get_signal(struct ksignal *ksig);
281extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
282extern void exit_signals(struct task_struct *tsk);
283extern void kernel_sigaction(int, __sighandler_t);
284
285static inline void allow_signal(int sig)
286{
287
288
289
290
291
292 kernel_sigaction(sig, (__force __sighandler_t)2);
293}
294
295static inline void disallow_signal(int sig)
296{
297 kernel_sigaction(sig, SIG_IGN);
298}
299
300extern struct kmem_cache *sighand_cachep;
301
302int unhandled_signal(struct task_struct *tsk, int sig);
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
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#ifdef SIGEMT
379#define SIGEMT_MASK rt_sigmask(SIGEMT)
380#else
381#define SIGEMT_MASK 0
382#endif
383
384#if SIGRTMIN > BITS_PER_LONG
385#define rt_sigmask(sig) (1ULL << ((sig)-1))
386#else
387#define rt_sigmask(sig) sigmask(sig)
388#endif
389#define siginmask(sig, mask) (rt_sigmask(sig) & (mask))
390
391#define SIG_KERNEL_ONLY_MASK (\
392 rt_sigmask(SIGKILL) | rt_sigmask(SIGSTOP))
393
394#define SIG_KERNEL_STOP_MASK (\
395 rt_sigmask(SIGSTOP) | rt_sigmask(SIGTSTP) | \
396 rt_sigmask(SIGTTIN) | rt_sigmask(SIGTTOU) )
397
398#define SIG_KERNEL_COREDUMP_MASK (\
399 rt_sigmask(SIGQUIT) | rt_sigmask(SIGILL) | \
400 rt_sigmask(SIGTRAP) | rt_sigmask(SIGABRT) | \
401 rt_sigmask(SIGFPE) | rt_sigmask(SIGSEGV) | \
402 rt_sigmask(SIGBUS) | rt_sigmask(SIGSYS) | \
403 rt_sigmask(SIGXCPU) | rt_sigmask(SIGXFSZ) | \
404 SIGEMT_MASK )
405
406#define SIG_KERNEL_IGNORE_MASK (\
407 rt_sigmask(SIGCONT) | rt_sigmask(SIGCHLD) | \
408 rt_sigmask(SIGWINCH) | rt_sigmask(SIGURG) )
409
410#define sig_kernel_only(sig) \
411 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_ONLY_MASK))
412#define sig_kernel_coredump(sig) \
413 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_COREDUMP_MASK))
414#define sig_kernel_ignore(sig) \
415 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_IGNORE_MASK))
416#define sig_kernel_stop(sig) \
417 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_STOP_MASK))
418
419#define sig_user_defined(t, signr) \
420 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
421 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
422
423#define sig_fatal(t, signr) \
424 (!siginmask(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
425 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
426
427void signals_init(void);
428
429int restore_altstack(const stack_t __user *);
430int __save_altstack(stack_t __user *, unsigned long);
431
432#define save_altstack_ex(uss, sp) do { \
433 stack_t __user *__uss = uss; \
434 struct task_struct *t = current; \
435 put_user_ex((void __user *)t->sas_ss_sp, &__uss->ss_sp); \
436 put_user_ex(sas_ss_flags(sp), &__uss->ss_flags); \
437 put_user_ex(t->sas_ss_size, &__uss->ss_size); \
438} while (0);
439
440#ifdef CONFIG_PROC_FS
441struct seq_file;
442extern void render_sigset_t(struct seq_file *, const char *, sigset_t *);
443#endif
444
445#endif
446