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