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;
242
243struct sigaction {
244#ifndef __ARCH_HAS_IRIX_SIGACTION
245 __sighandler_t sa_handler;
246 unsigned long sa_flags;
247#else
248 unsigned int sa_flags;
249 __sighandler_t sa_handler;
250#endif
251#ifdef __ARCH_HAS_SA_RESTORER
252 __sigrestore_t sa_restorer;
253#endif
254 sigset_t sa_mask;
255};
256
257struct k_sigaction {
258 struct sigaction sa;
259#ifdef __ARCH_HAS_KA_RESTORER
260 __sigrestore_t ka_restorer;
261#endif
262};
263
264#ifdef CONFIG_OLD_SIGACTION
265struct old_sigaction {
266 __sighandler_t sa_handler;
267 old_sigset_t sa_mask;
268 unsigned long sa_flags;
269 __sigrestore_t sa_restorer;
270};
271#endif
272
273struct ksignal {
274 struct k_sigaction ka;
275 siginfo_t info;
276 int sig;
277};
278
279extern int get_signal(struct ksignal *ksig);
280extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
281extern void exit_signals(struct task_struct *tsk);
282extern void kernel_sigaction(int, __sighandler_t);
283
284static inline void allow_signal(int sig)
285{
286
287
288
289
290
291 kernel_sigaction(sig, (__force __sighandler_t)2);
292}
293
294static inline void disallow_signal(int sig)
295{
296 kernel_sigaction(sig, SIG_IGN);
297}
298
299extern struct kmem_cache *sighand_cachep;
300
301int unhandled_signal(struct task_struct *tsk, int sig);
302
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#ifdef SIGEMT
378#define SIGEMT_MASK rt_sigmask(SIGEMT)
379#else
380#define SIGEMT_MASK 0
381#endif
382
383#if SIGRTMIN > BITS_PER_LONG
384#define rt_sigmask(sig) (1ULL << ((sig)-1))
385#else
386#define rt_sigmask(sig) sigmask(sig)
387#endif
388#define siginmask(sig, mask) (rt_sigmask(sig) & (mask))
389
390#define SIG_KERNEL_ONLY_MASK (\
391 rt_sigmask(SIGKILL) | rt_sigmask(SIGSTOP))
392
393#define SIG_KERNEL_STOP_MASK (\
394 rt_sigmask(SIGSTOP) | rt_sigmask(SIGTSTP) | \
395 rt_sigmask(SIGTTIN) | rt_sigmask(SIGTTOU) )
396
397#define SIG_KERNEL_COREDUMP_MASK (\
398 rt_sigmask(SIGQUIT) | rt_sigmask(SIGILL) | \
399 rt_sigmask(SIGTRAP) | rt_sigmask(SIGABRT) | \
400 rt_sigmask(SIGFPE) | rt_sigmask(SIGSEGV) | \
401 rt_sigmask(SIGBUS) | rt_sigmask(SIGSYS) | \
402 rt_sigmask(SIGXCPU) | rt_sigmask(SIGXFSZ) | \
403 SIGEMT_MASK )
404
405#define SIG_KERNEL_IGNORE_MASK (\
406 rt_sigmask(SIGCONT) | rt_sigmask(SIGCHLD) | \
407 rt_sigmask(SIGWINCH) | rt_sigmask(SIGURG) )
408
409#define sig_kernel_only(sig) \
410 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_ONLY_MASK))
411#define sig_kernel_coredump(sig) \
412 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_COREDUMP_MASK))
413#define sig_kernel_ignore(sig) \
414 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_IGNORE_MASK))
415#define sig_kernel_stop(sig) \
416 (((sig) < SIGRTMIN) && siginmask(sig, SIG_KERNEL_STOP_MASK))
417
418#define sig_user_defined(t, signr) \
419 (((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_DFL) && \
420 ((t)->sighand->action[(signr)-1].sa.sa_handler != SIG_IGN))
421
422#define sig_fatal(t, signr) \
423 (!siginmask(signr, SIG_KERNEL_IGNORE_MASK|SIG_KERNEL_STOP_MASK) && \
424 (t)->sighand->action[(signr)-1].sa.sa_handler == SIG_DFL)
425
426void signals_init(void);
427
428int restore_altstack(const stack_t __user *);
429int __save_altstack(stack_t __user *, unsigned long);
430
431#define save_altstack_ex(uss, sp) do { \
432 stack_t __user *__uss = uss; \
433 struct task_struct *t = current; \
434 put_user_ex((void __user *)t->sas_ss_sp, &__uss->ss_sp); \
435 put_user_ex(sas_ss_flags(sp), &__uss->ss_flags); \
436 put_user_ex(t->sas_ss_size, &__uss->ss_size); \
437} while (0);
438
439#ifdef CONFIG_PROC_FS
440struct seq_file;
441extern void render_sigset_t(struct seq_file *, const char *, sigset_t *);
442#endif
443
444#endif
445