?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d: Merge upstream dmd 3982604c5, druntime bc58b1e9, phobos 12329adb6.
[official-gcc.git] / libphobos / libdruntime / core / sys / posix / signal.d
blob32e51561562acd1108a6414dc5a80e7b07077c1f
1 /**
2 * D header file for POSIX.
3 *
4 * Copyright: Copyright Sean Kelly 2005 - 2009.
5 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
6 * Authors: Sean Kelly,
7 Alex Rønne Petersen
8 * Standards: The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition
9 * Source: $(DRUNTIMESRC core/sys/posix/_signal.d)
10 */
11
12 module core.sys.posix.signal;
13
14 import core.sys.posix.config;
15 public import core.stdc.signal;
16 public import core.sys.posix.sys.types; // for pid_t
17 //public import core.sys.posix.time; // for timespec, now defined here
18
19 version (OSX)
20 version = Darwin;
21 else version (iOS)
22 version = Darwin;
23 else version (TVOS)
24 version = Darwin;
25 else version (WatchOS)
26 version = Darwin;
27
28 version (ARM) version = ARM_Any;
29 version (AArch64) version = ARM_Any;
30 version (HPPA) version = HPPA_Any;
31 version (MIPS32) version = MIPS_Any;
32 version (MIPS64) version = MIPS_Any;
33 version (PPC) version = PPC_Any;
34 version (PPC64) version = PPC_Any;
35 version (RISCV32) version = RISCV_Any;
36 version (RISCV64) version = RISCV_Any;
37 version (S390) version = IBMZ_Any;
38 version (SPARC) version = SPARC_Any;
39 version (SPARC64) version = SPARC_Any;
40 version (SystemZ) version = IBMZ_Any;
41 version (X86) version = X86_Any;
42 version (X86_64) version = X86_Any;
43
44 version (Posix):
45 extern (C):
46 //nothrow: // this causes http://issues.dlang.org/show_bug.cgi?id=12738 (which has been fixed)
47 //@system:
48
49 //
50 // Required
51 //
52 /*
53 SIG_DFL (defined in core.stdc.signal)
54 SIG_ERR (defined in core.stdc.signal)
55 SIG_IGN (defined in core.stdc.signal)
56
57 sig_atomic_t (defined in core.stdc.signal)
58
59 SIGEV_NONE
60 SIGEV_SIGNAL
61 SIGEV_THREAD
62
63 union sigval
64 {
65 int sival_int;
66 void* sival_ptr;
67 }
68
69 SIGRTMIN
70 SIGRTMAX
71
72 SIGABRT (defined in core.stdc.signal)
73 SIGALRM
74 SIGBUS
75 SIGCHLD
76 SIGCONT
77 SIGFPE (defined in core.stdc.signal)
78 SIGHUP
79 SIGILL (defined in core.stdc.signal)
80 SIGINT (defined in core.stdc.signal)
81 SIGKILL
82 SIGPIPE
83 SIGQUIT
84 SIGSEGV (defined in core.stdc.signal)
85 SIGSTOP
86 SIGTERM (defined in core.stdc.signal)
87 SIGTSTP
88 SIGTTIN
89 SIGTTOU
90 SIGUSR1
91 SIGUSR2
92 SIGURG
93
94 struct sigaction_t
95 {
96 sigfn_t sa_handler;
97 sigset_t sa_mask;
98 sigactfn_t sa_sigaction;
99 }
100
101 sigfn_t signal(int sig, sigfn_t func); (defined in core.stdc.signal)
102 int raise(int sig); (defined in core.stdc.signal)
103 */
104
105 //SIG_DFL (defined in core.stdc.signal)
106 //SIG_ERR (defined in core.stdc.signal)
107 //SIG_IGN (defined in core.stdc.signal)
108
109 //sig_atomic_t (defined in core.stdc.signal)
110
111 private alias void function(int) sigfn_t;
112 private alias void function(int, siginfo_t*, void*) sigactfn_t;
113
114 // nothrow versions
115 nothrow @nogc
116 {
117 private alias void function(int) sigfn_t2;
118 private alias void function(int, siginfo_t*, void*) sigactfn_t2;
119 }
120
121 enum
122 {
123 SIGEV_SIGNAL,
124 SIGEV_NONE,
125 SIGEV_THREAD
126 }
127
128 union sigval
129 {
130 int sival_int;
131 void* sival_ptr;
132 }
133
134 version (Solaris)
135 {
136 import core.sys.posix.unistd;
137
138 @property int SIGRTMIN() nothrow @nogc {
139 __gshared static int sig = -1;
140 if (sig == -1) {
141 sig = cast(int)sysconf(_SC_SIGRT_MIN);
142 }
143 return sig;
144 }
145
146 @property int SIGRTMAX() nothrow @nogc {
147 __gshared static int sig = -1;
148 if (sig == -1) {
149 sig = cast(int)sysconf(_SC_SIGRT_MAX);
150 }
151 return sig;
152 }
153 }
154 else version (FreeBSD) {
155 // Note: it appears that FreeBSD (prior to 7) and OSX do not support realtime signals
156 // https://github.com/freebsd/freebsd/blob/e79c62ff68fc74d88cb6f479859f6fae9baa5101/sys/sys/signal.h#L117
157 enum SIGRTMIN = 65;
158 enum SIGRTMAX = 126;
159 }
160 else version (DragonFlyBSD) {
161 enum SIGRTMIN = 35;
162 enum SIGRTMAX = 126;
163 }
164 else version (NetBSD)
165 {
166 enum SIGRTMIN = 33;
167 enum SIGRTMAX = 63;
168 }
169 else version (linux)
170 {
171 // Note: CRuntime_Bionic switched to calling these functions
172 // since Lollipop, and Glibc, UClib and Musl all implement them
173 // the same way since it's part of LSB.
174 private extern (C) nothrow @nogc
175 {
176 int __libc_current_sigrtmin();
177 int __libc_current_sigrtmax();
178 }
179
180 @property int SIGRTMIN() nothrow @nogc {
181 __gshared static int sig = -1;
182 if (sig == -1) {
183 sig = __libc_current_sigrtmin();
184 }
185 return sig;
186 }
187
188 @property int SIGRTMAX() nothrow @nogc {
189 __gshared static int sig = -1;
190 if (sig == -1) {
191 sig = __libc_current_sigrtmax();
192 }
193 return sig;
194 }
195 }
196
197 version (linux)
198 {
199 version (X86_Any)
200 {
201 //SIGABRT (defined in core.stdc.signal)
202 enum SIGALRM = 14;
203 enum SIGBUS = 7;
204 enum SIGCHLD = 17;
205 enum SIGCONT = 18;
206 //SIGFPE (defined in core.stdc.signal)
207 enum SIGHUP = 1;
208 //SIGILL (defined in core.stdc.signal)
209 //SIGINT (defined in core.stdc.signal)
210 enum SIGKILL = 9;
211 enum SIGPIPE = 13;
212 enum SIGQUIT = 3;
213 //SIGSEGV (defined in core.stdc.signal)
214 enum SIGSTOP = 19;
215 //SIGTERM (defined in core.stdc.signal)
216 enum SIGTSTP = 20;
217 enum SIGTTIN = 21;
218 enum SIGTTOU = 22;
219 enum SIGUSR1 = 10;
220 enum SIGUSR2 = 12;
221 enum SIGURG = 23;
222 }
223 else version (HPPA_Any)
224 {
225 //SIGABRT (defined in core.stdc.signal)
226 enum SIGALRM = 14;
227 enum SIGBUS = 10;
228 enum SIGCHLD = 18;
229 enum SIGCONT = 26;
230 //SIGFPE (defined in core.stdc.signal)
231 enum SIGHUP = 1;
232 //SIGILL (defined in core.stdc.signal)
233 //SIGINT (defined in core.stdc.signal)
234 enum SIGKILL = 9;
235 enum SIGPIPE = 13;
236 enum SIGQUIT = 3;
237 //SIGSEGV (defined in core.stdc.signal)
238 enum SIGSTOP = 24;
239 //SIGTERM (defined in core.stdc.signal)
240 enum SIGTSTP = 25;
241 enum SIGTTIN = 27;
242 enum SIGTTOU = 28;
243 enum SIGUSR1 = 16;
244 enum SIGUSR2 = 17;
245 enum SIGURG = 29;
246 }
247 else version (MIPS_Any)
248 {
249 //SIGABRT (defined in core.stdc.signal)
250 enum SIGALRM = 14;
251 enum SIGBUS = 10;
252 enum SIGCHLD = 18;
253 enum SIGCONT = 25;
254 //SIGFPE (defined in core.stdc.signal)
255 enum SIGHUP = 1;
256 //SIGILL (defined in core.stdc.signal)
257 //SIGINT (defined in core.stdc.signal)
258 enum SIGKILL = 9;
259 enum SIGPIPE = 13;
260 enum SIGQUIT = 3;
261 //SIGSEGV (defined in core.stdc.signal)
262 enum SIGSTOP = 23;
263 //SIGTERM (defined in core.stdc.signal)
264 enum SIGTSTP = 24;
265 enum SIGTTIN = 26;
266 enum SIGTTOU = 27;
267 enum SIGUSR1 = 16;
268 enum SIGUSR2 = 17;
269 enum SIGURG = 21;
270 }
271 else version (PPC_Any)
272 {
273 //SIGABRT (defined in core.stdc.signal)
274 enum SIGALRM = 14;
275 enum SIGBUS = 7;
276 enum SIGCHLD = 17;
277 enum SIGCONT = 18;
278 //SIGFPE (defined in core.stdc.signal)
279 enum SIGHUP = 1;
280 //SIGILL (defined in core.stdc.signal)
281 //SIGINT (defined in core.stdc.signal)
282 enum SIGKILL = 9;
283 enum SIGPIPE = 13;
284 enum SIGQUIT = 3;
285 //SIGSEGV (defined in core.stdc.signal)
286 enum SIGSTOP = 19;
287 //SIGTERM (defined in core.stdc.signal)
288 enum SIGTSTP = 20;
289 enum SIGTTIN = 21;
290 enum SIGTTOU = 22;
291 enum SIGUSR1 = 10;
292 enum SIGUSR2 = 12;
293 enum SIGURG = 23;
294 }
295 else version (ARM_Any)
296 {
297 //SIGABRT (defined in core.stdc.signal)
298 enum SIGALRM = 14;
299 enum SIGBUS = 7;
300 enum SIGCHLD = 17;
301 enum SIGCONT = 18;
302 //SIGFPE (defined in core.stdc.signal)
303 enum SIGHUP = 1;
304 //SIGILL (defined in core.stdc.signal)
305 //SIGINT (defined in core.stdc.signal)
306 enum SIGKILL = 9;
307 enum SIGPIPE = 13;
308 enum SIGQUIT = 3;
309 //SIGSEGV (defined in core.stdc.signal)
310 enum SIGSTOP = 19;
311 //SIGTERM (defined in core.stdc.signal)
312 enum SIGTSTP = 20;
313 enum SIGTTIN = 21;
314 enum SIGTTOU = 22;
315 enum SIGUSR1 = 10;
316 enum SIGUSR2 = 12;
317 enum SIGURG = 23;
318 }
319 else version (RISCV_Any)
320 {
321 //SIGABRT (defined in core.stdc.signal)
322 enum SIGALRM = 14;
323 enum SIGBUS = 7;
324 enum SIGCHLD = 17;
325 enum SIGCONT = 18;
326 //SIGFPE (defined in core.stdc.signal)
327 enum SIGHUP = 1;
328 //SIGILL (defined in core.stdc.signal)
329 //SIGINT (defined in core.stdc.signal)
330 enum SIGKILL = 9;
331 enum SIGPIPE = 13;
332 enum SIGQUIT = 3;
333 //SIGSEGV (defined in core.stdc.signal)
334 enum SIGSTOP = 19;
335 //SIGTERM (defined in core.stdc.signal)
336 enum SIGTSTP = 20;
337 enum SIGTTIN = 21;
338 enum SIGTTOU = 22;
339 enum SIGUSR1 = 10;
340 enum SIGUSR2 = 12;
341 enum SIGURG = 23;
342 }
343 else version (SPARC_Any)
344 {
345 //SIGABRT (defined in core.stdc.signal)
346 enum SIGALRM = 14;
347 enum SIGBUS = 10;
348 enum SIGCHLD = 20;
349 enum SIGCONT = 19;
350 //SIGFPE (defined in core.stdc.signal)
351 enum SIGHUP = 1;
352 //SIGILL (defined in core.stdc.signal)
353 //SIGINT (defined in core.stdc.signal)
354 enum SIGKILL = 9;
355 enum SIGPIPE = 13;
356 enum SIGQUIT = 3;
357 //SIGSEGV (defined in core.stdc.signal)
358 enum SIGSTOP = 17;
359 //SIGTERM (defined in core.stdc.signal)
360 enum SIGTSTP = 18;
361 enum SIGTTIN = 21;
362 enum SIGTTOU = 22;
363 enum SIGUSR1 = 30;
364 enum SIGUSR2 = 31;
365 enum SIGURG = 16;
366 }
367 else version (IBMZ_Any)
368 {
369 //SIGABRT (defined in core.stdc.signal)
370 enum SIGALRM = 14;
371 enum SIGBUS = 7;
372 enum SIGCHLD = 17;
373 enum SIGCONT = 18;
374 //SIGFPE (defined in core.stdc.signal)
375 enum SIGHUP = 1;
376 //SIGILL (defined in core.stdc.signal)
377 //SIGINT (defined in core.stdc.signal)
378 enum SIGKILL = 9;
379 enum SIGPIPE = 13;
380 enum SIGQUIT = 3;
381 //SIGSEGV (defined in core.stdc.signal)
382 enum SIGSTOP = 19;
383 //SIGTERM (defined in core.stdc.signal)
384 enum SIGTSTP = 20;
385 enum SIGTTIN = 21;
386 enum SIGTTOU = 22;
387 enum SIGUSR1 = 10;
388 enum SIGUSR2 = 12;
389 enum SIGURG = 23;
390 }
391 else
392 static assert(0, "unimplemented");
393 }
394 else version (Darwin)
395 {
396 //SIGABRT (defined in core.stdc.signal)
397 enum SIGALRM = 14;
398 enum SIGBUS = 10;
399 enum SIGCHLD = 20;
400 enum SIGCONT = 19;
401 //SIGFPE (defined in core.stdc.signal)
402 enum SIGHUP = 1;
403 //SIGILL (defined in core.stdc.signal)
404 //SIGINT (defined in core.stdc.signal)
405 enum SIGKILL = 9;
406 enum SIGPIPE = 13;
407 enum SIGQUIT = 3;
408 //SIGSEGV (defined in core.stdc.signal)
409 enum SIGSTOP = 17;
410 //SIGTERM (defined in core.stdc.signal)
411 enum SIGTSTP = 18;
412 enum SIGTTIN = 21;
413 enum SIGTTOU = 22;
414 enum SIGUSR1 = 30;
415 enum SIGUSR2 = 31;
416 enum SIGURG = 16;
417 }
418 else version (FreeBSD)
419 {
420 //SIGABRT (defined in core.stdc.signal)
421 enum SIGALRM = 14;
422 enum SIGBUS = 10;
423 enum SIGCHLD = 20;
424 enum SIGCONT = 19;
425 //SIGFPE (defined in core.stdc.signal)
426 enum SIGHUP = 1;
427 //SIGILL (defined in core.stdc.signal)
428 //SIGINT (defined in core.stdc.signal)
429 enum SIGKILL = 9;
430 enum SIGPIPE = 13;
431 enum SIGQUIT = 3;
432 //SIGSEGV (defined in core.stdc.signal)
433 enum SIGSTOP = 17;
434 //SIGTERM (defined in core.stdc.signal)
435 enum SIGTSTP = 18;
436 enum SIGTTIN = 21;
437 enum SIGTTOU = 22;
438 enum SIGUSR1 = 30;
439 enum SIGUSR2 = 31;
440 enum SIGURG = 16;
441 }
442 else version (NetBSD)
443 {
444 //SIGABRT (defined in core.stdc.signal)
445 enum SIGALRM = 14;
446 enum SIGBUS = 10;
447 enum SIGCHLD = 20;
448 enum SIGCONT = 19;
449 //SIGFPE (defined in core.stdc.signal)
450 enum SIGHUP = 1;
451 //SIGILL (defined in core.stdc.signal)
452 //SIGINT (defined in core.stdc.signal)
453 enum SIGKILL = 9;
454 enum SIGPIPE = 13;
455 enum SIGQUIT = 3;
456 //SIGSEGV (defined in core.stdc.signal)
457 enum SIGSTOP = 17;
458 //SIGTERM (defined in core.stdc.signal)
459 enum SIGTSTP = 18;
460 enum SIGTTIN = 21;
461 enum SIGTTOU = 22;
462 enum SIGUSR1 = 30;
463 enum SIGUSR2 = 31;
464 enum SIGURG = 16;
465 }
466 else version (OpenBSD)
467 {
468 //SIGABRT (defined in core.stdc.signal)
469 enum SIGALRM = 14;
470 enum SIGBUS = 10;
471 enum SIGCHLD = 20;
472 enum SIGCONT = 19;
473 //SIGFPE (defined in core.stdc.signal)
474 enum SIGHUP = 1;
475 //SIGILL (defined in core.stdc.signal)
476 //SIGINT (defined in core.stdc.signal)
477 enum SIGKILL = 9;
478 enum SIGPIPE = 13;
479 enum SIGQUIT = 3;
480 //SIGSEGV (defined in core.stdc.signal)
481 enum SIGSTOP = 17;
482 //SIGTERM (defined in core.stdc.signal)
483 enum SIGTSTP = 18;
484 enum SIGTTIN = 21;
485 enum SIGTTOU = 22;
486 enum SIGUSR1 = 30;
487 enum SIGUSR2 = 31;
488 enum SIGURG = 16;
489 }
490 else version (DragonFlyBSD)
491 {
492 //SIGABRT (defined in core.stdc.signal)
493 enum SIGALRM = 14;
494 enum SIGBUS = 10;
495 enum SIGCHLD = 20;
496 enum SIGCONT = 19;
497 //SIGFPE (defined in core.stdc.signal)
498 enum SIGHUP = 1;
499 //SIGILL (defined in core.stdc.signal)
500 //SIGINT (defined in core.stdc.signal)
501 enum SIGKILL = 9;
502 enum SIGPIPE = 13;
503 enum SIGQUIT = 3;
504 //SIGSEGV (defined in core.stdc.signal)
505 enum SIGSTOP = 17;
506 //SIGTERM (defined in core.stdc.signal)
507 enum SIGTSTP = 18;
508 enum SIGTTIN = 21;
509 enum SIGTTOU = 22;
510 enum SIGUSR1 = 30;
511 enum SIGUSR2 = 31;
512 enum SIGURG = 16;
513 }
514 else version (Solaris)
515 {
516 //SIGABRT (defined in core.stdc.signal)
517 enum SIGALRM = 14;
518 enum SIGBUS = 10;
519 enum SIGCHLD = 18;
520 enum SIGCONT = 25;
521 //SIGFPE (defined in core.stdc.signal)
522 enum SIGHUP = 1;
523 //SIGILL (defined in core.stdc.signal)
524 //SIGINT (defined in core.stdc.signal)
525 enum SIGKILL = 9;
526 enum SIGPIPE = 13;
527 enum SIGQUIT = 3;
528 //SIGSEGV (defined in core.stdc.signal)
529 enum SIGSTOP = 23;
530 //SIGTERM (defined in core.stdc.signal)
531 enum SIGTSTP = 24;
532 enum SIGTTIN = 26;
533 enum SIGTTOU = 27;
534 enum SIGUSR1 = 16;
535 enum SIGUSR2 = 17;
536 enum SIGURG = 21;
537 }
538 else
539 {
540 static assert(false, "Unsupported platform");
541 }
542
543 version (CRuntime_Glibc)
544 {
545 version (SystemZ)
546 {
547 struct sigaction_t
548 {
549 static if ( true /* __USE_POSIX199309 */ )
550 {
551 union
552 {
553 sigfn_t sa_handler;
554 sigactfn_t sa_sigaction;
555 }
556 }
557 else
558 {
559 sigfn_t sa_handler;
560 }
561 int __glibc_reserved0;
562 int sa_flags;
563
564 void function() sa_restorer;
565
566 sigset_t sa_mask;
567 }
568 }
569 else
570 {
571 struct sigaction_t
572 {
573 static if ( true /* __USE_POSIX199309 */ )
574 {
575 union
576 {
577 sigfn_t sa_handler;
578 sigactfn_t sa_sigaction;
579 }
580 }
581 else
582 {
583 sigfn_t sa_handler;
584 }
585 sigset_t sa_mask;
586 int sa_flags;
587
588 void function() sa_restorer;
589 }
590 }
591 }
592 else version (CRuntime_Musl)
593 {
594 struct sigaction_t
595 {
596 static if ( true /* __USE_POSIX199309 */ )
597 {
598 union
599 {
600 sigfn_t sa_handler;
601 sigactfn_t sa_sigaction;
602 }
603 }
604 else
605 {
606 sigfn_t sa_handler;
607 }
608 sigset_t sa_mask;
609 int sa_flags;
610
611 void function() sa_restorer;
612 }
613 }
614 else version (FreeBSD)
615 {
616 struct sigaction_t
617 {
618 union
619 {
620 sigfn_t sa_handler;
621 sigactfn_t sa_sigaction;
622 }
623 int sa_flags;
624 sigset_t sa_mask;
625 }
626 }
627 else version (NetBSD)
628 {
629 struct sigaction_t
630 {
631 union
632 {
633 sigfn_t sa_handler;
634 sigactfn_t sa_sigaction;
635 }
636 sigset_t sa_mask;
637 int sa_flags;
638 }
639 }
640 else version (OpenBSD)
641 {
642 struct sigaction_t
643 {
644 union
645 {
646 sigfn_t __sa_handler;
647 alias sa_handler = __sa_handler;
648 sigactfn_t __sa_sigaction;
649 alias sa_sigaction = __sa_sigaction;
650 }
651 sigset_t sa_mask;
652 int sa_flags;
653 }
654 }
655 else version (DragonFlyBSD)
656 {
657 struct sigaction_t
658 {
659 union
660 {
661 sigfn_t sa_handler;
662 sigactfn_t sa_sigaction;
663 }
664 int sa_flags;
665 sigset_t sa_mask;
666 }
667 }
668 else version (Solaris)
669 {
670 struct sigaction_t
671 {
672 int sa_flags;
673
674 union
675 {
676 sigfn_t sa_handler;
677 sigactfn_t sa_sigaction;
678 }
679
680 sigset_t sa_mask;
681 version (D_LP64) {}
682 else
683 int[2] sa_resv;
684 }
685 }
686 else version (CRuntime_UClibc)
687 {
688 version (ARM) version = sigaction_common;
689 else version (X86_64) version = sigaction_common;
690
691 version (sigaction_common)
692 {
693 struct sigaction_t
694 {
695 static if ( true /* __USE_POSIX199309 */ )
696 {
697 union
698 {
699 sigfn_t sa_handler;
700 sigactfn_t sa_sigaction;
701 }
702 }
703 else
704 {
705 sigfn_t sa_handler;
706 }
707 c_ulong sa_flags;
708 void function() sa_restorer;
709 sigset_t sa_mask;
710 }
711 }
712 else version (MIPS32)
713 {
714 struct sigaction_t
715 {
716 uint sa_flags;
717 static if ( true /* __USE_POSIX199309 */ )
718 {
719 union
720 {
721 sigfn_t sa_handler;
722 sigactfn_t sa_sigaction;
723 }
724 }
725 else
726 {
727 sigfn_t sa_handler;
728 }
729 sigset_t sa_mask;
730 void function() sa_restorer;
731 }
732 }
733 else
734 {
735 static assert(false, "Architecture not supported.");
736 }
737 }
738 else version (CRuntime_Bionic)
739 {
740 version (D_LP64)
741 {
742 struct sigaction_t
743 {
744 int sa_flags;
745 union
746 {
747 sigfn_t sa_handler;
748 sigactfn_t sa_sigaction;
749 }
750
751 sigset_t sa_mask;
752 void function() sa_restorer;
753 }
754 }
755 else
756 {
757 struct sigaction_t
758 {
759 union
760 {
761 sigfn_t sa_handler;
762 sigactfn_t sa_sigaction;
763 }
764
765 sigset_t sa_mask;
766 int sa_flags;
767 void function() sa_restorer;
768 }
769 }
770 }
771 else version (Darwin)
772 {
773 struct sigaction_t
774 {
775 static if ( true /* __USE_POSIX199309 */ )
776 {
777 union
778 {
779 sigfn_t sa_handler;
780 sigactfn_t sa_sigaction;
781 }
782 }
783 else
784 {
785 sigfn_t sa_handler;
786 }
787 sigset_t sa_mask;
788 int sa_flags;
789 }
790 }
791 else
792 {
793 static assert(false, "Unsupported platform");
794 }
795
796 //
797 // C Extension (CX)
798 //
799 /*
800 SIG_HOLD
801
802 sigset_t
803 pid_t (defined in core.sys.types)
804
805 SIGABRT (defined in core.stdc.signal)
806 SIGFPE (defined in core.stdc.signal)
807 SIGILL (defined in core.stdc.signal)
808 SIGINT (defined in core.stdc.signal)
809 SIGSEGV (defined in core.stdc.signal)
810 SIGTERM (defined in core.stdc.signal)
811
812 SA_NOCLDSTOP (CX|XSI)
813 SIG_BLOCK
814 SIG_UNBLOCK
815 SIG_SETMASK
816
817 struct siginfo_t
818 {
819 int si_signo;
820 int si_code;
821
822 version (XSI)
823 {
824 int si_errno;
825 pid_t si_pid;
826 uid_t si_uid;
827 void* si_addr;
828 int si_status;
829 c_long si_band;
830 }
831 version (RTS)
832 {
833 sigval si_value;
834 }
835 }
836
837 SI_USER
838 SI_QUEUE
839 SI_TIMER
840 SI_ASYNCIO
841 SI_MESGQ
842
843 int kill(pid_t, int);
844 int sigaction(int, const scope sigaction_t*, sigaction_t*);
845 int sigaddset(sigset_t*, int);
846 int sigdelset(sigset_t*, int);
847 int sigemptyset(sigset_t*);
848 int sigfillset(sigset_t*);
849 int sigismember(const scope sigset_t*, int);
850 int sigpending(sigset_t*);
851 int sigprocmask(int, const scope sigset_t*, sigset_t*);
852 int sigsuspend(const scope sigset_t*);
853 int sigwait(const scope sigset_t*, int*);
854 */
855
856 nothrow @nogc
857 {
858
859 version (CRuntime_Glibc)
860 {
861 enum SIG_HOLD = cast(sigfn_t2) 1;
862
863 private enum _SIGSET_NWORDS = 1024 / (8 * c_ulong.sizeof);
864
865 struct sigset_t
866 {
867 c_ulong[_SIGSET_NWORDS] __val;
868 }
869
870 // pid_t (defined in core.sys.types)
871
872 //SIGABRT (defined in core.stdc.signal)
873 //SIGFPE (defined in core.stdc.signal)
874 //SIGILL (defined in core.stdc.signal)
875 //SIGINT (defined in core.stdc.signal)
876 //SIGSEGV (defined in core.stdc.signal)
877 //SIGTERM (defined in core.stdc.signal)
878
879 enum SA_NOCLDSTOP = 1; // (CX|XSI)
880
881 enum SIG_BLOCK = 0;
882 enum SIG_UNBLOCK = 1;
883 enum SIG_SETMASK = 2;
884
885 private enum __SI_MAX_SIZE = 128;
886
887 static if ( __WORDSIZE == 64 )
888 {
889 private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4);
890 }
891 else
892 {
893 private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 3);
894 }
895
896 struct siginfo_t
897 {
898 int si_signo; // Signal number
899 int si_errno; // If non-zero, an errno value associated with
900 // this signal, as defined in <errno.h>
901 int si_code; // Signal code
902
903 union _sifields_t
904 {
905 int[__SI_PAD_SIZE] _pad;
906
907 // kill()
908 struct _kill_t
909 {
910 pid_t si_pid; // Sending process ID
911 uid_t si_uid; // Real user ID of sending process
912 } _kill_t _kill;
913
914 // POSIX.1b timers.
915 struct _timer_t
916 {
917 int si_tid; // Timer ID
918 int si_overrun; // Overrun count
919 sigval si_sigval; // Signal value
920 } _timer_t _timer;
921
922 // POSIX.1b signals
923 struct _rt_t
924 {
925 pid_t si_pid; // Sending process ID
926 uid_t si_uid; // Real user ID of sending process
927 sigval si_sigval; // Signal value
928 } _rt_t _rt;
929
930 // SIGCHLD
931 struct _sigchild_t
932 {
933 pid_t si_pid; // Which child
934 uid_t si_uid; // Real user ID of sending process
935 int si_status; // Exit value or signal
936 clock_t si_utime;
937 clock_t si_stime;
938 } _sigchild_t _sigchld;
939
940 // SIGILL, SIGFPE, SIGSEGV, SIGBUS
941 struct _sigfault_t
942 {
943 void* si_addr; // Faulting insn/memory ref
944 } _sigfault_t _sigfault;
945
946 // SIGPOLL
947 struct _sigpoll_t
948 {
949 c_long si_band; // Band event for SIGPOLL
950 int si_fd;
951 } _sigpoll_t _sigpoll;
952 } _sifields_t _sifields;
953
954 nothrow @nogc:
955 @property ref pid_t si_pid() return { return _sifields._kill.si_pid; }
956 @property ref uid_t si_uid() return { return _sifields._kill.si_uid; }
957 @property ref void* si_addr() return { return _sifields._sigfault.si_addr; }
958 @property ref int si_status() return { return _sifields._sigchld.si_status; }
959 @property ref c_long si_band() return { return _sifields._sigpoll.si_band; }
960 @property ref sigval si_value() return { return _sifields._rt.si_sigval; }
961 }
962
963 enum
964 {
965 SI_ASYNCNL = -60,
966 SI_TKILL = -6,
967 SI_SIGIO,
968 SI_ASYNCIO,
969 SI_MESGQ,
970 SI_TIMER,
971 SI_QUEUE,
972 SI_USER,
973 SI_KERNEL = 0x80
974 }
975
976 int kill(pid_t, int);
977 int sigaction(int, const scope sigaction_t*, sigaction_t*);
978 int sigaddset(sigset_t*, int);
979 int sigdelset(sigset_t*, int);
980 int sigemptyset(sigset_t*);
981 int sigfillset(sigset_t*);
982 int sigismember(const scope sigset_t*, int);
983 int sigpending(sigset_t*);
984 int sigprocmask(int, const scope sigset_t*, sigset_t*);
985 int sigsuspend(const scope sigset_t*);
986 int sigwait(const scope sigset_t*, int*);
987 }
988 else version (Darwin)
989 {
990 enum SIG_HOLD = cast(sigfn_t2) 5;
991
992 alias uint sigset_t;
993 // pid_t (defined in core.sys.types)
994
995 //SIGABRT (defined in core.stdc.signal)
996 //SIGFPE (defined in core.stdc.signal)
997 //SIGILL (defined in core.stdc.signal)
998 //SIGINT (defined in core.stdc.signal)
999 //SIGSEGV (defined in core.stdc.signal)
1000 //SIGTERM (defined in core.stdc.signal)
1001
1002 enum SA_NOCLDSTOP = 8; // (CX|XSI)
1003
1004 enum SIG_BLOCK = 1;
1005 enum SIG_UNBLOCK = 2;
1006 enum SIG_SETMASK = 3;
1007
1008 struct siginfo_t
1009 {
1010 int si_signo;
1011 int si_errno;
1012 int si_code;
1013 pid_t si_pid;
1014 uid_t si_uid;
1015 int si_status;
1016 void* si_addr;
1017 sigval si_value;
1018 int si_band;
1019 uint[7] pad;
1020 }
1021
1022 enum SI_USER = 0x10001;
1023 enum SI_QUEUE = 0x10002;
1024 enum SI_TIMER = 0x10003;
1025 enum SI_ASYNCIO = 0x10004;
1026 enum SI_MESGQ = 0x10005;
1027
1028 int kill(pid_t, int);
1029 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1030 int sigaddset(sigset_t*, int);
1031 int sigdelset(sigset_t*, int);
1032 int sigemptyset(sigset_t*);
1033 int sigfillset(sigset_t*);
1034 int sigismember(const scope sigset_t*, int);
1035 int sigpending(sigset_t*);
1036 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1037 int sigsuspend(const scope sigset_t*);
1038 int sigwait(const scope sigset_t*, int*);
1039 }
1040 else version (FreeBSD)
1041 {
1042 enum SIG_HOLD = cast(sigfn_t2) 3;
1043
1044 struct sigset_t
1045 {
1046 uint[4] __bits;
1047 }
1048
1049 enum SA_NOCLDSTOP = 8;
1050
1051 enum SIG_BLOCK = 1;
1052 enum SIG_UNBLOCK = 2;
1053 enum SIG_SETMASK = 3;
1054
1055 struct siginfo_t
1056 {
1057 int si_signo;
1058 int si_errno;
1059 int si_code;
1060 pid_t si_pid;
1061 uid_t si_uid;
1062 int si_status;
1063 void* si_addr;
1064 sigval si_value;
1065 union __reason
1066 {
1067 struct __fault
1068 {
1069 int _trapno;
1070 }
1071 __fault _fault;
1072 struct __timer
1073 {
1074 int _timerid;
1075 int _overrun;
1076 }
1077 __timer _timer;
1078 struct __mesgq
1079 {
1080 int _mqd;
1081 }
1082 __mesgq _mesgq;
1083 struct __poll
1084 {
1085 c_long _band;
1086 }
1087 __poll _poll;
1088 struct ___spare___
1089 {
1090 c_long __spare1__;
1091 int[7] __spare2__;
1092 }
1093 ___spare___ __spare__;
1094 }
1095 __reason _reason;
1096
1097 @property ref c_long si_band() return { return _reason._poll._band; }
1098 }
1099
1100 enum SI_USER = 0x10001;
1101 enum SI_QUEUE = 0x10002;
1102 enum SI_TIMER = 0x10003;
1103 enum SI_ASYNCIO = 0x10004;
1104 enum SI_MESGQ = 0x10005;
1105
1106 int kill(pid_t, int);
1107 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1108 int sigaddset(sigset_t*, int);
1109 int sigdelset(sigset_t*, int);
1110 int sigemptyset(sigset_t *);
1111 int sigfillset(sigset_t *);
1112 int sigismember(const scope sigset_t*, int);
1113 int sigpending(sigset_t *);
1114 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1115 int sigsuspend(const scope sigset_t*);
1116 int sigwait(const scope sigset_t*, int*);
1117 }
1118 else version (NetBSD)
1119 {
1120 enum SIG_HOLD = cast(sigfn_t2) 3;
1121
1122 struct sigset_t
1123 {
1124 uint[4] __bits;
1125 }
1126
1127 enum SA_NOCLDSTOP = 8;
1128
1129 enum SIG_BLOCK = 1;
1130 enum SIG_UNBLOCK = 2;
1131 enum SIG_SETMASK = 3;
1132
1133 union sigval_t
1134 {
1135 int sival_int;
1136 void* sival_ptr;
1137 }
1138
1139 struct _ksiginfo
1140 {
1141 int _signo;
1142 int _code;
1143 int _errno;
1144 version (D_LP64)
1145 int _pad;
1146
1147 union reason_t
1148 {
1149 struct rt_t
1150 {
1151 pid_t _pid;
1152 uid_t _uid;
1153 sigval_t _value;
1154 } rt_t _rt;
1155 struct child_t
1156 {
1157 pid_t _pid;
1158 uid_t _uid;
1159 int _status;
1160 clock_t _utime;
1161 clock_t _stime;
1162 } child_t _child;
1163 struct fault_t
1164 {
1165 void* _addr;
1166 int _trap;
1167 int _trap2;
1168 int _trap3;
1169 } fault_t fault;
1170 struct poll_t
1171 {
1172 c_long _band;
1173 int _fd;
1174 } poll_t _poll;
1175 }
1176 reason_t _reason;
1177 }
1178
1179 union siginfo_t
1180 {
1181 ubyte[128] si_pad;
1182 _ksiginfo _info;
1183 @property ref c_long si_band() return { return _info._reason._poll._band; }
1184 }
1185
1186 enum SI_USER = 0;
1187 enum SI_QUEUE = -1;
1188 enum SI_TIMER = -2;
1189 enum SI_ASYNCIO = -3;
1190 enum SI_MESGQ = -4;
1191
1192 int kill(pid_t, int);
1193 int __sigaction14(int, const scope sigaction_t*, sigaction_t*);
1194 int __sigaddset14(sigset_t*, int);
1195 int __sigdelset14(sigset_t*, int);
1196 int __sigemptyset14(sigset_t *);
1197 int __sigfillset14(sigset_t *);
1198 int __sigismember14(const scope sigset_t*, int);
1199 int __sigpending14(sigset_t *);
1200 int __sigprocmask14(int, const scope sigset_t*, sigset_t*);
1201 int __sigsuspend14(const scope sigset_t*);
1202 int sigwait(const scope sigset_t*, int*);
1203
1204 alias __sigaction14 sigaction;
1205 alias __sigaddset14 sigaddset;
1206 alias __sigdelset14 sigdelset;
1207 alias __sigemptyset14 sigemptyset;
1208 alias __sigfillset14 sigfillset;
1209 alias __sigismember14 sigismember;
1210 alias __sigpending14 sigpending;
1211 alias __sigprocmask14 sigprocmask;
1212 alias __sigsuspend14 sigsuspend;
1213 }
1214 else version (OpenBSD)
1215 {
1216 enum SIG_CATCH = cast(sigfn_t2) 2;
1217 enum SIG_HOLD = cast(sigfn_t2) 3;
1218
1219 alias sigset_t = uint;
1220
1221 enum SA_NOCLDSTOP = 0x0008;
1222
1223 enum SIG_BLOCK = 1;
1224 enum SIG_UNBLOCK = 2;
1225 enum SIG_SETMASK = 3;
1226
1227 private enum SI_MAXSZ = 128;
1228 private enum SI_PAD = (SI_MAXSZ / int.sizeof) - 3;
1229
1230 struct siginfo_t
1231 {
1232 int si_signo;
1233 int si_errno;
1234 int si_code;
1235 union _data
1236 {
1237 int[SI_PAD] _pad;
1238 struct _proc
1239 {
1240 pid_t _pid;
1241 union _pdata
1242 {
1243 struct _kill
1244 {
1245 uid_t _uid;
1246 sigval _value;
1247 }
1248 struct _cld
1249 {
1250 clock_t _utime;
1251 clock_t _stime;
1252 int _status;
1253 }
1254 }
1255 }
1256 struct _fault
1257 {
1258 caddr_t _addr;
1259 int _trapno;
1260 }
1261 }
1262 alias si_pid = _data._proc._pid;
1263 alias si_status = _data._proc._pdata._cld._status;
1264 alias si_stime = _data._proc._pdata._cld._stime;
1265 alias si_utime = _data._proc._pdata._cld._utime;
1266 alias si_uid = _data._proc._pdata._kill._uid;
1267 alias si_value = _data._proc._pdata._kill._value;
1268 alias si_addr = _data._fault._addr;
1269 alias si_trapno = _data._fault._trapno;
1270 }
1271
1272 enum SI_NOINFO = 32767;
1273 enum SI_USER = 0;
1274 enum SI_LWP = -1;
1275 enum SI_QUEUE = -2;
1276 enum SI_TIMER = -3;
1277
1278 int kill(pid_t, int);
1279 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1280 int sigaddset(sigset_t*, int);
1281 int sigdelset(sigset_t*, int);
1282 int sigemptyset(sigset_t *);
1283 int sigfillset(sigset_t *);
1284 int sigismember(const scope sigset_t*, int);
1285 int sigpending(sigset_t *);
1286 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1287 int sigsuspend(const scope sigset_t*);
1288 int sigwait(const scope sigset_t*, int*);
1289 }
1290 else version (DragonFlyBSD)
1291 {
1292 enum SIG_CATCH = cast(sigfn_t2) 2;
1293 enum SIG_HOLD = cast(sigfn_t2) 3;
1294
1295 struct sigset_t
1296 {
1297 uint[4] __bits;
1298 }
1299
1300 enum SA_NOCLDSTOP = 8;
1301
1302 enum SIG_BLOCK = 1;
1303 enum SIG_UNBLOCK = 2;
1304 enum SIG_SETMASK = 3;
1305
1306 struct siginfo_t
1307 {
1308 int si_signo;
1309 int si_errno;
1310 int si_code;
1311 int si_pid;
1312 uint si_uid;
1313 int si_status;
1314 void* si_addr;
1315 sigval si_value;
1316 c_long si_band;
1317 int[7] __spare;
1318 }
1319
1320 enum SI_UNDEFINED = 0x00000;
1321 enum SI_USER = 0;
1322 enum SI_QUEUE = -1;
1323 enum SI_TIMER = -2;
1324 enum SI_ASYNCIO = -3;
1325 enum SI_MESGQ = -4;
1326
1327 int kill(pid_t, int);
1328 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1329 int sigaddset(sigset_t*, int);
1330 int sigdelset(sigset_t*, int);
1331 int sigemptyset(sigset_t *);
1332 int sigfillset(sigset_t *);
1333 int sigismember(const scope sigset_t*, int);
1334 int sigpending(sigset_t *);
1335 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1336 int sigsuspend(const scope sigset_t*);
1337 int sigwait(const scope sigset_t*, int*);
1338 }
1339 else version (Solaris)
1340 {
1341 enum SIG_HOLD = cast(sigfn_t2)2;
1342
1343 struct sigset_t
1344 {
1345 uint[4] __bits;
1346 }
1347
1348 enum SIG_BLOCK = 1;
1349 enum SIG_UNBLOCK = 2;
1350 enum SIG_SETMASK = 3;
1351
1352 struct siginfo_t
1353 {
1354 int si_signo;
1355 int si_code;
1356 int si_errno;
1357
1358 version (D_LP64)
1359 int si_pad;
1360
1361 union ___data
1362 {
1363 version (D_LP64)
1364 int[(256 / int.sizeof) - 4] si_pad;
1365 else
1366 int[(128 / int.sizeof) - 3] si_pad;
1367
1368 struct ___proc
1369 {
1370 pid_t __pid;
1371
1372 union ___pdata
1373 {
1374 struct ___kill
1375 {
1376 uid_t __uid;
1377 sigval __value;
1378 }
1379
1380 ___kill __kill;
1381
1382 struct ___cld
1383 {
1384 clock_t __utime;
1385 int __status;
1386 clock_t __stime;
1387 }
1388
1389 ___cld __cld;
1390 }
1391
1392 ___pdata __pdata;
1393 ctid_t __ctid;
1394 zoneid_t __zoneid;
1395 }
1396
1397 ___proc __proc;
1398
1399 struct ___fault
1400 {
1401 void* __addr;
1402 int __trapno;
1403 caddr_t __pc;
1404 }
1405
1406 ___fault __fault;
1407
1408 struct ___file
1409 {
1410 int __fd;
1411 c_long __band;
1412 }
1413
1414 ___file __file;
1415
1416 struct ___prof
1417 {
1418 caddr_t __faddr;
1419 timestruc_t __tstamp;
1420 short __syscall;
1421 char __nsysarg = 0;
1422 char __fault = 0;
1423 c_long[8] __sysarg;
1424 int[10] __mstate;
1425 }
1426
1427 ___prof __prof;
1428
1429 struct ___rctl
1430 {
1431 int __entity;
1432 }
1433
1434 ___rctl __rctl;
1435 }
1436
1437 ___data __data;
1438 }
1439
1440 enum SI_NOINFO = 32767;
1441 enum SI_DTRACE = 2050;
1442 enum SI_RCTL = 2049;
1443 enum SI_USER = 0;
1444 enum SI_LWP = -1;
1445 enum SI_QUEUE = -2;
1446 enum SI_TIMER = -3;
1447 enum SI_ASYNCIO = -4;
1448 enum SI_MESGQ = -5;
1449
1450 enum SIGIO = SIGPOLL;
1451
1452 int kill(pid_t, int);
1453 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1454 int sigaddset(sigset_t*, int);
1455 int sigdelset(sigset_t*, int);
1456 int sigemptyset(sigset_t*);
1457 int sigfillset(sigset_t*);
1458 int sigismember(const scope sigset_t*, int);
1459 int sigpending(sigset_t*);
1460 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1461 int sigsuspend(const scope sigset_t*);
1462 int sigwait(const scope sigset_t*, int*);
1463 }
1464 else version (CRuntime_Bionic)
1465 {
1466 public import core.sys.posix.time: timer_t;
1467 import core.stdc.string : memset;
1468
1469 version (X86)
1470 {
1471 alias uint sigset_t;
1472 enum int LONG_BIT = 32;
1473 }
1474 else version (ARM)
1475 {
1476 alias uint sigset_t;
1477 enum int LONG_BIT = 32;
1478 }
1479 else version (AArch64)
1480 {
1481 struct sigset_t { ulong[1] sig; }
1482 enum int LONG_BIT = 64;
1483 }
1484 else version (X86_64)
1485 {
1486 alias ulong sigset_t;
1487 enum int LONG_BIT = 64;
1488 }
1489 else
1490 {
1491 static assert(false, "Architecture not supported.");
1492 }
1493
1494 enum SIG_BLOCK = 0;
1495 enum SIG_UNBLOCK = 1;
1496 enum SIG_SETMASK = 2;
1497
1498 private enum SI_MAX_SIZE = 128;
1499 private enum SI_PAD_SIZE = ((SI_MAX_SIZE / int.sizeof) - 3);
1500
1501 struct siginfo_t
1502 {
1503 int si_signo;
1504 int si_errno;
1505 int si_code;
1506
1507 union _sifields_t
1508 {
1509 int[SI_PAD_SIZE] _pad;
1510
1511 struct _kill_t
1512 {
1513 pid_t _pid;
1514 uid_t _uid;
1515 } _kill_t _kill;
1516
1517 struct _timer_t
1518 {
1519 timer_t _tid;
1520 int _overrun;
1521 sigval _sigval;
1522 int _sys_private;
1523 } _timer_t _timer;
1524
1525 struct _rt_t
1526 {
1527 pid_t _pid;
1528 uid_t _uid;
1529 sigval _sigval;
1530 } _rt_t _rt;
1531
1532 struct _sigchild_t
1533 {
1534 pid_t _pid;
1535 uid_t _uid;
1536 int _status;
1537 clock_t _utime;
1538 clock_t _stime;
1539 } _sigchild_t _sigchld;
1540
1541 struct _sigfault_t
1542 {
1543 void* _addr;
1544 } _sigfault_t _sigfault;
1545
1546 struct _sigpoll_t
1547 {
1548 c_long _band;
1549 int _fd;
1550 } _sigpoll_t _sigpoll;
1551 } _sifields_t _sifields;
1552 }
1553
1554 enum
1555 {
1556 SI_TKILL = -6,
1557 SI_SIGIO,
1558 SI_ASYNCIO,
1559 SI_MESGQ,
1560 SI_TIMER,
1561 SI_QUEUE,
1562 SI_USER,
1563 SI_KERNEL = 0x80
1564 }
1565
1566 int kill(pid_t, int);
1567 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1568
1569 // These functions are defined inline in bionic.
1570 int sigaddset(sigset_t* set, int signum)
1571 {
1572 c_ulong* local_set = cast(c_ulong*) set;
1573 signum--;
1574 local_set[signum/LONG_BIT] |= 1UL << (signum%LONG_BIT);
1575 return 0;
1576 }
1577
1578 int sigdelset(sigset_t* set, int signum)
1579 {
1580 c_ulong* local_set = cast(c_ulong*) set;
1581 signum--;
1582 local_set[signum/LONG_BIT] &= ~(1UL << (signum%LONG_BIT));
1583 return 0;
1584 }
1585
1586 int sigemptyset(sigset_t* set) { memset(set, 0, (*set).sizeof); return 0; }
1587
1588 int sigfillset(sigset_t* set) { memset(set, ~0, (*set).sizeof); return 0; }
1589
1590 int sigismember(sigset_t* set, int signum)
1591 {
1592 c_ulong* local_set = cast(c_ulong*) set;
1593 signum--;
1594 return cast(int) ((local_set[signum/LONG_BIT] >> (signum%LONG_BIT)) & 1);
1595 }
1596
1597 int sigpending(sigset_t*);
1598 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1599 int sigsuspend(const scope sigset_t*);
1600 int sigwait(const scope sigset_t*, int*);
1601 }
1602 else version (CRuntime_Musl)
1603 {
1604 struct sigset_t
1605 {
1606 c_ulong[128/c_long.sizeof] __bits;
1607 }
1608
1609 version (MIPS_Any)
1610 {
1611 enum SIG_BLOCK = 1;
1612 enum SIG_UNBLOCK = 2;
1613 enum SIG_SETMASK = 3;
1614 }
1615 else
1616 {
1617 enum SIG_BLOCK = 0;
1618 enum SIG_UNBLOCK = 1;
1619 enum SIG_SETMASK = 2;
1620 }
1621
1622 struct siginfo_t
1623 {
1624 int si_signo;
1625 version (MIPS_Any) // __SI_SWAP_ERRNO_CODE
1626 {
1627 int si_code;
1628 int si_errno;
1629 }
1630 else
1631 {
1632 int si_errno;
1633 int si_code;
1634 }
1635 union __si_fields_t
1636 {
1637 char[128 - 2*int.sizeof - c_long.sizeof] __pad = 0;
1638 struct __si_common_t
1639 {
1640 union __first_t
1641 {
1642 struct __piduid_t
1643 {
1644 pid_t si_pid;
1645 uid_t si_uid;
1646 }
1647 __piduid_t __piduid;
1648
1649 struct __timer_t
1650 {
1651 int si_timerid;
1652 int si_overrun;
1653 }
1654 __timer_t __timer;
1655 }
1656 __first_t __first;
1657
1658 union __second_t
1659 {
1660 sigval si_value;
1661 struct __sigchld_t
1662 {
1663 int si_status;
1664 clock_t si_utime;
1665 clock_t si_stime;
1666 }
1667 __sigchld_t __sigchld;
1668 }
1669 __second_t __second;
1670 }
1671 __si_common_t __si_common;
1672
1673 struct __sigfault_t
1674 {
1675 void *si_addr;
1676 short si_addr_lsb;
1677 union __first_t
1678 {
1679 struct __addr_bnd_t
1680 {
1681 void *si_lower;
1682 void *si_upper;
1683 }
1684 __addr_bnd_t __addr_bnd;
1685 uint si_pkey;
1686 }
1687 __first_t __first;
1688 }
1689 __sigfault_t __sigfault;
1690
1691 struct __sigpoll_t
1692 {
1693 c_long si_band;
1694 int si_fd;
1695 }
1696 __sigpoll_t __sigpoll;
1697
1698 struct __sigsys_t
1699 {
1700 void *si_call_addr;
1701 int si_syscall;
1702 uint si_arch;
1703 }
1704 __sigsys_t __sigsys;
1705 }
1706 __si_fields_t __si_fields;
1707 }
1708
1709 int kill(pid_t, int);
1710 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1711 int sigaddset(sigset_t*, int);
1712 int sigdelset(sigset_t*, int);
1713 int sigemptyset(sigset_t*);
1714 int sigfillset(sigset_t*);
1715 int sigismember(const scope sigset_t*, int);
1716 int sigpending(sigset_t*);
1717 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1718 int sigsuspend(const scope sigset_t*);
1719 int sigwait(const scope sigset_t*, int*);
1720 }
1721 else version (CRuntime_UClibc)
1722 {
1723 enum SIG_HOLD = cast(sigfn_t2) 2;
1724
1725 version (MIPS32)
1726 private enum _SIGSET_NWORDS = 128 / (8 * c_ulong.sizeof);
1727 else
1728 private enum _SIGSET_NWORDS = 64 / (8 * c_ulong.sizeof);
1729
1730 struct sigset_t
1731 {
1732 c_ulong[_SIGSET_NWORDS] __val;
1733 }
1734
1735 enum SA_NOCLDSTOP = 1;
1736
1737 enum SIG_BLOCK = 0;
1738 enum SIG_UNBLOCK = 1;
1739 enum SIG_SETMASK = 2;
1740
1741 private enum __SI_MAX_SIZE = 128;
1742
1743 static if ( __WORDSIZE == 64 )
1744 {
1745 private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4);
1746 }
1747 else
1748 {
1749 private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 3);
1750 }
1751
1752 version (ARM) version = siginfo_common;
1753 else version (X86_64) version = siginfo_common;
1754
1755 version (siginfo_common)
1756 {
1757 struct siginfo_t
1758 {
1759 int si_signo; // Signal number
1760 int si_errno; // If non-zero, an errno value associated with
1761 // this signal, as defined in <errno.h>
1762 int si_code; // Signal code
1763
1764 union _sifields_t
1765 {
1766 int[__SI_PAD_SIZE] _pad;
1767
1768 // kill()
1769 struct _kill_t
1770 {
1771 pid_t si_pid; // Sending process ID
1772 uid_t si_uid; // Real user ID of sending process
1773 } _kill_t _kill;
1774
1775 // POSIX.1b timers.
1776 struct _timer_t
1777 {
1778 int si_tid; // Timer ID
1779 int si_overrun; // Overrun count
1780 sigval si_sigval; // Signal value
1781 } _timer_t _timer;
1782
1783 // POSIX.1b signals
1784 struct _rt_t
1785 {
1786 pid_t si_pid; // Sending process ID
1787 uid_t si_uid; // Real user ID of sending process
1788 sigval si_sigval; // Signal value
1789 } _rt_t _rt;
1790
1791 // SIGCHLD
1792 struct _sigchild_t
1793 {
1794 pid_t si_pid; // Which child
1795 uid_t si_uid; // Real user ID of sending process
1796 int si_status; // Exit value or signal
1797 clock_t si_utime;
1798 clock_t si_stime;
1799 } _sigchild_t _sigchld;
1800
1801 // SIGILL, SIGFPE, SIGSEGV, SIGBUS
1802 struct _sigfault_t
1803 {
1804 void* si_addr; // Faulting insn/memory ref
1805 } _sigfault_t _sigfault;
1806
1807 // SIGPOLL
1808 struct _sigpoll_t
1809 {
1810 c_long si_band; // Band event for SIGPOLL;
1811 int si_fd;
1812 } _sigpoll_t _sigpoll;
1813
1814 // SIGSYS
1815 struct _sigsys_t
1816 {
1817 void* _call_addr; // Calling user insn.
1818 int _syscall; // Triggering system call number.
1819 uint _arch; // AUDIT_ARCH_* of syscall.
1820 } _sigsys_t _sigsys;
1821
1822 } _sifields_t _sifields;
1823
1824 nothrow @nogc:
1825 @property ref pid_t si_pid()() { return _sifields._kill.si_pid; }
1826 @property ref uid_t si_uid()() { return _sifields._kill.si_uid; }
1827 @property ref int si_timerid()() { return _sifields._timer.si_tid;}
1828 @property ref int si_overrun()() { return _sifields._timer.si_overrun; }
1829 @property ref int si_status()() { return _sifields._sigchld.si_status; }
1830 @property ref clock_t si_utime()() { return _sifields._sigchld.si_utime; }
1831 @property ref clock_t si_stime()() { return _sifields._sigchld.si_stime; }
1832 @property ref sigval si_value()() { return _sifields._rt.si_sigval; }
1833 @property ref int si_int()() { return _sifields._rt.si_sigval.sival_int; }
1834 @property ref void* si_ptr()() { return _sifields._rt.si_sigval.sival_ptr; }
1835 @property ref void* si_addr()() { return _sifields._sigfault.si_addr; }
1836 @property ref c_long si_band()() { return _sifields._sigpoll.si_band; }
1837 @property ref int si_fd()() { return _sifields._sigpoll.si_fd; }
1838 @property ref void* si_call_addr()() { return _sifields._sigsys._call_addr; }
1839 @property ref int si_syscall()() { return _sifields._sigsys._syscall; }
1840 @property ref uint si_arch()() { return _sifields._sigsys._arch; }
1841 }
1842 }
1843 else version (MIPS32)
1844 {
1845 struct siginfo_t
1846 {
1847 int si_signo; // Signal number
1848 int si_errno; // If non-zero, an errno value associated with
1849 // this signal, as defined in <errno.h>
1850 int si_code; // Signal code
1851
1852 int[__SI_MAX_SIZE / int.sizeof - __SI_PAD_SIZE - 3] __pad0;
1853
1854 union _sifields_t
1855 {
1856 int[__SI_PAD_SIZE] _pad;
1857
1858 // kill()
1859 struct _kill_t
1860 {
1861 pid_t si_pid; // Sending process ID
1862 uid_t si_uid; // Real user ID of sending process
1863 } _kill_t _kill;
1864
1865 // POSIX.1b timers.
1866 struct _timer_t
1867 {
1868 int si_tid; // Timer ID
1869 int si_overrun; // Overrun count
1870 sigval si_sigval; // Signal value
1871 } _timer_t _timer;
1872
1873 // POSIX.1b signals
1874 struct _rt_t
1875 {
1876 pid_t si_pid; // Sending process ID
1877 uid_t si_uid; // Real user ID of sending process
1878 sigval si_sigval; // Signal value
1879 } _rt_t _rt;
1880
1881 // SIGCHLD
1882 struct _sigchild_t
1883 {
1884 pid_t si_pid; // Which child
1885 uid_t si_uid; // Real user ID of sending process
1886 int si_status; // Exit value or signal
1887 clock_t si_utime;
1888 clock_t si_stime;
1889 } _sigchild_t _sigchld;
1890
1891 // SIGILL, SIGFPE, SIGSEGV, SIGBUS
1892 struct _sigfault_t
1893 {
1894 void* si_addr; // Faulting insn/memory ref
1895 short si_addr_lsb;
1896 } _sigfault_t _sigfault;
1897
1898 // SIGPOLL
1899 struct _sigpoll_t
1900 {
1901 c_long si_band; // Band event for SIGPOLL;
1902 int si_fd;
1903 } _sigpoll_t _sigpoll;
1904
1905 // SIGSYS
1906 struct _sigsys_t
1907 {
1908 void* _call_addr; // Calling user insn.
1909 int _syscall; // Triggering system call number.
1910 uint _arch; // AUDIT_ARCH_* of syscall.
1911 } _sigsys_t _sigsys;
1912
1913 } _sifields_t _sifields;
1914
1915 nothrow @nogc:
1916 @property ref pid_t si_pid()() { return _sifields._kill.si_pid; }
1917 @property ref uid_t si_uid()() { return _sifields._kill.si_uid; }
1918 @property ref int si_timerid()() { return _sifields._timer.si_tid;}
1919 @property ref int si_overrun()() { return _sifields._timer.si_overrun; }
1920 @property ref int si_status()() { return _sifields._sigchld.si_status; }
1921 @property ref clock_t si_utime()() { return _sifields._sigchld.si_utime; }
1922 @property ref clock_t si_stime()() { return _sifields._sigchld.si_stime; }
1923 @property ref sigval si_value()() { return _sifields._rt.si_sigval; }
1924 @property ref int si_int()() { return _sifields._rt.si_sigval.sival_int; }
1925 @property ref void* si_ptr()() { return _sifields._rt.si_sigval.sival_ptr; }
1926 @property ref void* si_addr()() { return _sifields._sigfault.si_addr; }
1927 @property ref c_long si_band()() { return _sifields._sigpoll.si_band; }
1928 @property ref int si_fd()() { return _sifields._sigpoll.si_fd; }
1929 @property ref void* si_call_addr()() { return _sifields._sigsys._call_addr; }
1930 @property ref int si_syscall()() { return _sifields._sigsys._syscall; }
1931 @property ref uint si_arch()() { return _sifields._sigsys._arch; }
1932 }
1933 }
1934 else
1935 {
1936 static assert(false, "Architecture not supported.");
1937 }
1938
1939 enum
1940 {
1941 SI_ASYNCNL = -60,
1942 SI_TKILL = -6,
1943 SI_SIGIO,
1944 SI_ASYNCIO,
1945 SI_MESGQ,
1946 SI_TIMER,
1947 SI_QUEUE,
1948 SI_USER,
1949 SI_KERNEL = 0x80
1950 }
1951
1952 int kill(pid_t, int);
1953 int sigaction(int, const scope sigaction_t*, sigaction_t*);
1954 int sigaddset(sigset_t*, int);
1955 int sigdelset(sigset_t*, int);
1956 int sigemptyset(sigset_t*);
1957 int sigfillset(sigset_t*);
1958 int sigismember(const scope sigset_t*, int);
1959 int sigpending(sigset_t*);
1960 int sigprocmask(int, const scope sigset_t*, sigset_t*);
1961 int sigsuspend(const scope sigset_t*);
1962 int sigwait(const scope sigset_t*, int*);
1963 }
1964 else
1965 {
1966 static assert(false, "Unsupported platform");
1967 }
1968 }
1969
1970 //
1971 // XOpen (XSI)
1972 //
1973 /*
1974 SIGPOLL
1975 SIGPROF
1976 SIGSYS
1977 SIGTRAP
1978 SIGVTALRM
1979 SIGXCPU
1980 SIGXFSZ
1981
1982 SA_ONSTACK
1983 SA_RESETHAND
1984 SA_RESTART
1985 SA_SIGINFO
1986 SA_NOCLDWAIT
1987 SA_NODEFER
1988 SS_ONSTACK
1989 SS_DISABLE
1990 MINSIGSTKSZ
1991 SIGSTKSZ
1992
1993 ucontext_t // from ucontext
1994 mcontext_t // from ucontext
1995
1996 struct stack_t
1997 {
1998 void* ss_sp;
1999 size_t ss_size;
2000 int ss_flags;
2001 }
2002
2003 struct sigstack
2004 {
2005 int ss_onstack;
2006 void* ss_sp;
2007 }
2008
2009 ILL_ILLOPC
2010 ILL_ILLOPN
2011 ILL_ILLADR
2012 ILL_ILLTRP
2013 ILL_PRVOPC
2014 ILL_PRVREG
2015 ILL_COPROC
2016 ILL_BADSTK
2017
2018 FPE_INTDIV
2019 FPE_INTOVF
2020 FPE_FLTDIV
2021 FPE_FLTOVF
2022 FPE_FLTUND
2023 FPE_FLTRES
2024 FPE_FLTINV
2025 FPE_FLTSUB
2026
2027 SEGV_MAPERR
2028 SEGV_ACCERR
2029
2030 BUS_ADRALN
2031 BUS_ADRERR
2032 BUS_OBJERR
2033
2034 TRAP_BRKPT
2035 TRAP_TRACE
2036
2037 CLD_EXITED
2038 CLD_KILLED
2039 CLD_DUMPED
2040 CLD_TRAPPED
2041 CLD_STOPPED
2042 CLD_CONTINUED
2043
2044 POLL_IN
2045 POLL_OUT
2046 POLL_MSG
2047 POLL_ERR
2048 POLL_PRI
2049 POLL_HUP
2050
2051 sigfn_t bsd_signal(int sig, sigfn_t func);
2052 sigfn_t sigset(int sig, sigfn_t func);
2053
2054 int killpg(pid_t, int);
2055 int sigaltstack(const scope stack_t*, stack_t*);
2056 int sighold(int);
2057 int sigignore(int);
2058 int siginterrupt(int, int);
2059 int sigpause(int);
2060 int sigrelse(int);
2061 */
2062
2063 version (CRuntime_Glibc)
2064 {
2065 version (X86_Any)
2066 {
2067 enum SIGPOLL = 29;
2068 enum SIGPROF = 27;
2069 enum SIGSYS = 31;
2070 enum SIGTRAP = 5;
2071 enum SIGVTALRM = 26;
2072 enum SIGXCPU = 24;
2073 enum SIGXFSZ = 25;
2074 }
2075 else version (HPPA_Any)
2076 {
2077 enum SIGPOLL = 22;
2078 enum SIGPROF = 21;
2079 enum SIGSYS = 31;
2080 enum SIGTRAP = 5;
2081 enum SIGVTALRM = 20;
2082 enum SIGXCPU = 12;
2083 enum SIGXFSZ = 30;
2084 }
2085 else version (MIPS_Any)
2086 {
2087 enum SIGPOLL = 22;
2088 enum SIGPROF = 29;
2089 enum SIGSYS = 12;
2090 enum SIGTRAP = 5;
2091 enum SIGVTALRM = 28;
2092 enum SIGXCPU = 30;
2093 enum SIGXFSZ = 31;
2094 }
2095 else version (PPC_Any)
2096 {
2097 enum SIGPOLL = 29;
2098 enum SIGPROF = 27;
2099 enum SIGSYS = 31;
2100 enum SIGTRAP = 5;
2101 enum SIGVTALRM = 26;
2102 enum SIGXCPU = 24;
2103 enum SIGXFSZ = 25;
2104 }
2105 else version (ARM_Any)
2106 {
2107 enum SIGPOLL = 29;
2108 enum SIGPROF = 27;
2109 enum SIGSYS = 31;
2110 enum SIGTRAP = 5;
2111 enum SIGVTALRM = 26;
2112 enum SIGXCPU = 24;
2113 enum SIGXFSZ = 25;
2114 }
2115 else version (RISCV_Any)
2116 {
2117 enum SIGPOLL = 29;
2118 enum SIGPROF = 27;
2119 enum SIGSYS = 31;
2120 enum SIGTRAP = 5;
2121 enum SIGVTALRM = 26;
2122 enum SIGXCPU = 24;
2123 enum SIGXFSZ = 25;
2124 }
2125 else version (SPARC_Any)
2126 {
2127 enum SIGPOLL = 23;
2128 enum SIGPROF = 27;
2129 enum SIGSYS = 12;
2130 enum SIGTRAP = 5;
2131 enum SIGVTALRM = 26;
2132 enum SIGXCPU = 24;
2133 enum SIGXFSZ = 25;
2134 }
2135 else version (IBMZ_Any)
2136 {
2137 enum SIGPOLL = 29;
2138 enum SIGPROF = 27;
2139 enum SIGSYS = 31;
2140 enum SIGTRAP = 5;
2141 enum SIGVTALRM = 26;
2142 enum SIGXCPU = 24;
2143 enum SIGXFSZ = 25;
2144 }
2145 else
2146 static assert(0, "unimplemented");
2147
2148 enum SA_ONSTACK = 0x08000000;
2149 enum SA_RESETHAND = 0x80000000;
2150 enum SA_RESTART = 0x10000000;
2151 enum SA_SIGINFO = 4;
2152 enum SA_NOCLDWAIT = 2;
2153 enum SA_NODEFER = 0x40000000;
2154 enum SS_ONSTACK = 1;
2155 enum SS_DISABLE = 2;
2156 enum MINSIGSTKSZ = 2048;
2157 enum SIGSTKSZ = 8192;
2158
2159 //ucontext_t (defined in core.sys.posix.ucontext)
2160 //mcontext_t (defined in core.sys.posix.ucontext)
2161
2162 struct stack_t
2163 {
2164 void* ss_sp;
2165 int ss_flags;
2166 size_t ss_size;
2167 }
2168
2169 struct sigstack
2170 {
2171 void* ss_sp;
2172 int ss_onstack;
2173 }
2174
2175 enum
2176 {
2177 ILL_ILLOPC = 1,
2178 ILL_ILLOPN,
2179 ILL_ILLADR,
2180 ILL_ILLTRP,
2181 ILL_PRVOPC,
2182 ILL_PRVREG,
2183 ILL_COPROC,
2184 ILL_BADSTK
2185 }
2186
2187 enum
2188 {
2189 FPE_INTDIV = 1,
2190 FPE_INTOVF,
2191 FPE_FLTDIV,
2192 FPE_FLTOVF,
2193 FPE_FLTUND,
2194 FPE_FLTRES,
2195 FPE_FLTINV,
2196 FPE_FLTSUB
2197 }
2198
2199 enum
2200 {
2201 SEGV_MAPERR = 1,
2202 SEGV_ACCERR
2203 }
2204
2205 enum
2206 {
2207 BUS_ADRALN = 1,
2208 BUS_ADRERR,
2209 BUS_OBJERR
2210 }
2211
2212 enum
2213 {
2214 TRAP_BRKPT = 1,
2215 TRAP_TRACE
2216 }
2217
2218 enum
2219 {
2220 CLD_EXITED = 1,
2221 CLD_KILLED,
2222 CLD_DUMPED,
2223 CLD_TRAPPED,
2224 CLD_STOPPED,
2225 CLD_CONTINUED
2226 }
2227
2228 enum
2229 {
2230 POLL_IN = 1,
2231 POLL_OUT,
2232 POLL_MSG,
2233 POLL_ERR,
2234 POLL_PRI,
2235 POLL_HUP
2236 }
2237
2238 sigfn_t bsd_signal(int sig, sigfn_t func);
2239 sigfn_t sigset(int sig, sigfn_t func);
2240
2241 nothrow:
2242 @nogc:
2243 sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2244 sigfn_t2 sigset(int sig, sigfn_t2 func);
2245
2246 int killpg(pid_t, int);
2247 int sigaltstack(const scope stack_t*, stack_t*);
2248 int sighold(int);
2249 int sigignore(int);
2250 int siginterrupt(int, int);
2251 int sigpause(int);
2252 int sigrelse(int);
2253 }
2254 else version (Darwin)
2255 {
2256 enum SIGPOLL = 7;
2257 enum SIGPROF = 27;
2258 enum SIGSYS = 12;
2259 enum SIGTRAP = 5;
2260 enum SIGVTALRM = 26;
2261 enum SIGXCPU = 24;
2262 enum SIGXFSZ = 25;
2263
2264 enum SA_ONSTACK = 0x0001;
2265 enum SA_RESETHAND = 0x0004;
2266 enum SA_RESTART = 0x0002;
2267 enum SA_SIGINFO = 0x0040;
2268 enum SA_NOCLDWAIT = 0x0020;
2269 enum SA_NODEFER = 0x0010;
2270 enum SS_ONSTACK = 0x0001;
2271 enum SS_DISABLE = 0x0004;
2272 enum MINSIGSTKSZ = 32768;
2273 enum SIGSTKSZ = 131072;
2274
2275 //ucontext_t (defined in core.sys.posix.ucontext)
2276 //mcontext_t (defined in core.sys.posix.ucontext)
2277
2278 struct stack_t
2279 {
2280 void* ss_sp;
2281 size_t ss_size;
2282 int ss_flags;
2283 }
2284
2285 struct sigstack
2286 {
2287 void* ss_sp;
2288 int ss_onstack;
2289 }
2290
2291 enum ILL_ILLOPC = 1;
2292 enum ILL_ILLOPN = 4;
2293 enum ILL_ILLADR = 5;
2294 enum ILL_ILLTRP = 2;
2295 enum ILL_PRVOPC = 3;
2296 enum ILL_PRVREG = 6;
2297 enum ILL_COPROC = 7;
2298 enum ILL_BADSTK = 8;
2299
2300 enum FPE_INTDIV = 7;
2301 enum FPE_INTOVF = 8;
2302 enum FPE_FLTDIV = 1;
2303 enum FPE_FLTOVF = 2;
2304 enum FPE_FLTUND = 3;
2305 enum FPE_FLTRES = 4;
2306 enum FPE_FLTINV = 5;
2307 enum FPE_FLTSUB = 6;
2308
2309 enum
2310 {
2311 SEGV_MAPERR = 1,
2312 SEGV_ACCERR
2313 }
2314
2315 enum
2316 {
2317 BUS_ADRALN = 1,
2318 BUS_ADRERR,
2319 BUS_OBJERR
2320 }
2321
2322 enum
2323 {
2324 TRAP_BRKPT = 1,
2325 TRAP_TRACE
2326 }
2327
2328 enum
2329 {
2330 CLD_EXITED = 1,
2331 CLD_KILLED,
2332 CLD_DUMPED,
2333 CLD_TRAPPED,
2334 CLD_STOPPED,
2335 CLD_CONTINUED
2336 }
2337
2338 enum
2339 {
2340 POLL_IN = 1,
2341 POLL_OUT,
2342 POLL_MSG,
2343 POLL_ERR,
2344 POLL_PRI,
2345 POLL_HUP
2346 }
2347
2348 sigfn_t bsd_signal(int sig, sigfn_t func);
2349 sigfn_t sigset(int sig, sigfn_t func);
2350
2351 nothrow:
2352 @nogc:
2353 sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2354 sigfn_t2 sigset(int sig, sigfn_t2 func);
2355
2356 int killpg(pid_t, int);
2357 int sigaltstack(const scope stack_t*, stack_t*);
2358 int sighold(int);
2359 int sigignore(int);
2360 int siginterrupt(int, int);
2361 int sigpause(int);
2362 int sigrelse(int);
2363 }
2364 else version (FreeBSD)
2365 {
2366 // No SIGPOLL on *BSD
2367 enum SIGPROF = 27;
2368 enum SIGSYS = 12;
2369 enum SIGTRAP = 5;
2370 enum SIGVTALRM = 26;
2371 enum SIGXCPU = 24;
2372 enum SIGXFSZ = 25;
2373
2374 enum
2375 {
2376 SA_ONSTACK = 0x0001,
2377 SA_RESTART = 0x0002,
2378 SA_RESETHAND = 0x0004,
2379 SA_NODEFER = 0x0010,
2380 SA_NOCLDWAIT = 0x0020,
2381 SA_SIGINFO = 0x0040,
2382 }
2383
2384 enum
2385 {
2386 SS_ONSTACK = 0x0001,
2387 SS_DISABLE = 0x0004,
2388 }
2389
2390 enum MINSIGSTKSZ = 512 * 4;
2391 enum SIGSTKSZ = (MINSIGSTKSZ + 32768);
2392
2393 //ucontext_t (defined in core.sys.posix.ucontext)
2394 //mcontext_t (defined in core.sys.posix.ucontext)
2395
2396 struct stack_t
2397 {
2398 void* ss_sp;
2399 size_t ss_size;
2400 int ss_flags;
2401 }
2402
2403 struct sigstack
2404 {
2405 void* ss_sp;
2406 int ss_onstack;
2407 }
2408
2409 enum
2410 {
2411 ILL_ILLOPC = 1,
2412 ILL_ILLOPN,
2413 ILL_ILLADR,
2414 ILL_ILLTRP,
2415 ILL_PRVOPC,
2416 ILL_PRVREG,
2417 ILL_COPROC,
2418 ILL_BADSTK,
2419 }
2420
2421 enum
2422 {
2423 BUS_ADRALN = 1,
2424 BUS_ADRERR,
2425 BUS_OBJERR,
2426 }
2427
2428 enum
2429 {
2430 SEGV_MAPERR = 1,
2431 SEGV_ACCERR,
2432 }
2433
2434 enum
2435 {
2436 FPE_INTOVF = 1,
2437 FPE_INTDIV,
2438 FPE_FLTDIV,
2439 FPE_FLTOVF,
2440 FPE_FLTUND,
2441 FPE_FLTRES,
2442 FPE_FLTINV,
2443 FPE_FLTSUB,
2444 }
2445
2446 enum
2447 {
2448 TRAP_BRKPT = 1,
2449 TRAP_TRACE,
2450 }
2451
2452 enum
2453 {
2454 CLD_EXITED = 1,
2455 CLD_KILLED,
2456 CLD_DUMPED,
2457 CLD_TRAPPED,
2458 CLD_STOPPED,
2459 CLD_CONTINUED,
2460 }
2461
2462 enum
2463 {
2464 POLL_IN = 1,
2465 POLL_OUT,
2466 POLL_MSG,
2467 POLL_ERR,
2468 POLL_PRI,
2469 POLL_HUP,
2470 }
2471
2472 //sigfn_t bsd_signal(int sig, sigfn_t func);
2473 sigfn_t sigset(int sig, sigfn_t func);
2474
2475 nothrow:
2476 @nogc:
2477 //sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2478 sigfn_t2 sigset(int sig, sigfn_t2 func);
2479
2480 int killpg(pid_t, int);
2481 int sigaltstack(const scope stack_t*, stack_t*);
2482 int sighold(int);
2483 int sigignore(int);
2484 int siginterrupt(int, int);
2485 int sigpause(int);
2486 int sigrelse(int);
2487 }
2488 else version (NetBSD)
2489 {
2490 // No SIGPOLL on *BSD
2491 enum SIGPROF = 27;
2492 enum SIGSYS = 12;
2493 enum SIGTRAP = 5;
2494 enum SIGVTALRM = 26;
2495 enum SIGXCPU = 24;
2496 enum SIGXFSZ = 25;
2497
2498 enum
2499 {
2500 SA_ONSTACK = 0x0001,
2501 SA_RESTART = 0x0002,
2502 SA_RESETHAND = 0x0004,
2503 SA_NODEFER = 0x0010,
2504 SA_NOCLDWAIT = 0x0020,
2505 SA_SIGINFO = 0x0040,
2506 }
2507
2508 enum
2509 {
2510 SS_ONSTACK = 0x0001,
2511 SS_DISABLE = 0x0004,
2512 }
2513
2514 enum MINSIGSTKSZ = 8192;
2515 enum SIGSTKSZ = (MINSIGSTKSZ + 32768);
2516
2517 //ucontext_t (defined in core.sys.posix.ucontext)
2518 //mcontext_t (defined in core.sys.posix.ucontext)
2519
2520 struct stack_t
2521 {
2522 void* ss_sp;
2523 size_t ss_size;
2524 int ss_flags;
2525 }
2526
2527 struct sigstack
2528 {
2529 void* ss_sp;
2530 int ss_onstack;
2531 }
2532
2533 enum
2534 {
2535 ILL_ILLOPC = 1,
2536 ILL_ILLOPN,
2537 ILL_ILLADR,
2538 ILL_ILLTRP,
2539 ILL_PRVOPC,
2540 ILL_PRVREG,
2541 ILL_COPROC,
2542 ILL_BADSTK,
2543 }
2544
2545 enum
2546 {
2547 BUS_ADRALN = 1,
2548 BUS_ADRERR,
2549 BUS_OBJERR,
2550 }
2551
2552 enum
2553 {
2554 SEGV_MAPERR = 1,
2555 SEGV_ACCERR,
2556 }
2557
2558 enum
2559 {
2560 FPE_INTOVF = 1,
2561 FPE_INTDIV,
2562 FPE_FLTDIV,
2563 FPE_FLTOVF,
2564 FPE_FLTUND,
2565 FPE_FLTRES,
2566 FPE_FLTINV,
2567 FPE_FLTSUB,
2568 }
2569
2570 enum
2571 {
2572 TRAP_BRKPT = 1,
2573 TRAP_TRACE,
2574 }
2575
2576 enum
2577 {
2578 CLD_EXITED = 1,
2579 CLD_KILLED,
2580 CLD_DUMPED,
2581 CLD_TRAPPED,
2582 CLD_STOPPED,
2583 CLD_CONTINUED,
2584 }
2585
2586 enum
2587 {
2588 POLL_IN = 1,
2589 POLL_OUT,
2590 POLL_MSG,
2591 POLL_ERR,
2592 POLL_PRI,
2593 POLL_HUP,
2594 }
2595
2596 //sigfn_t bsd_signal(int sig, sigfn_t func);
2597 sigfn_t sigset(int sig, sigfn_t func);
2598
2599 nothrow:
2600 @nogc:
2601 //sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2602 sigfn_t2 sigset(int sig, sigfn_t2 func);
2603
2604 int killpg(pid_t, int);
2605 int sigaltstack(const scope stack_t*, stack_t*);
2606 int sighold(int);
2607 int sigignore(int);
2608 int siginterrupt(int, int);
2609 int sigpause(int);
2610 int sigrelse(int);
2611 }
2612 else version (OpenBSD)
2613 {
2614 // No SIGPOLL on *BSD
2615 enum SIGPROF = 27;
2616 enum SIGSYS = 12;
2617 enum SIGTRAP = 5;
2618 enum SIGVTALRM = 26;
2619 enum SIGXCPU = 24;
2620 enum SIGXFSZ = 25;
2621
2622 enum
2623 {
2624 SA_ONSTACK = 0x0001,
2625 SA_RESTART = 0x0002,
2626 SA_RESETHAND = 0x0004,
2627 SA_NODEFER = 0x0010,
2628 SA_NOCLDWAIT = 0x0020,
2629 SA_SIGINFO = 0x0040,
2630 }
2631
2632 enum
2633 {
2634 SS_ONSTACK = 0x0001,
2635 SS_DISABLE = 0x0004,
2636 }
2637
2638 enum MINSIGSTKSZ = 8192;
2639 enum SIGSTKSZ = (MINSIGSTKSZ + 32768);
2640
2641 //ucontext_t (defined in core.sys.posix.ucontext)
2642 //mcontext_t (defined in core.sys.posix.ucontext)
2643
2644 struct stack_t
2645 {
2646 void* ss_sp;
2647 size_t ss_size;
2648 int ss_flags;
2649 }
2650
2651 enum
2652 {
2653 ILL_ILLOPC = 1,
2654 ILL_ILLOPN,
2655 ILL_ILLADR,
2656 ILL_ILLTRP,
2657 ILL_PRVOPC,
2658 ILL_PRVREG,
2659 ILL_COPROC,
2660 ILL_BADSTK,
2661 NSIGILL = ILL_BADSTK,
2662 }
2663
2664 enum
2665 {
2666 BUS_ADRALN = 1,
2667 BUS_ADRERR,
2668 BUS_OBJERR,
2669 NSIGBUS = BUS_OBJERR,
2670 }
2671
2672 enum
2673 {
2674 SEGV_MAPERR = 1,
2675 SEGV_ACCERR,
2676 NSIGSEGV = SEGV_ACCERR,
2677 }
2678
2679 enum
2680 {
2681 FPE_INTDIV = 1,
2682 FPE_INTOVF,
2683 FPE_FLTDIV,
2684 FPE_FLTOVF,
2685 FPE_FLTUND,
2686 FPE_FLTRES,
2687 FPE_FLTINV,
2688 FPE_FLTSUB,
2689 NSIGFPE = FPE_FLTSUB,
2690 }
2691
2692 enum
2693 {
2694 TRAP_BRKPT = 1,
2695 TRAP_TRACE,
2696 NSIGTRAP = TRAP_TRACE,
2697 }
2698
2699 enum
2700 {
2701 CLD_EXITED = 1,
2702 CLD_KILLED,
2703 CLD_DUMPED,
2704 CLD_TRAPPED,
2705 CLD_STOPPED,
2706 CLD_CONTINUED,
2707 NSIGCLD = CLD_CONTINUED,
2708 }
2709
2710 enum
2711 {
2712 POLL_IN = 1,
2713 POLL_OUT,
2714 POLL_MSG,
2715 POLL_ERR,
2716 POLL_PRI,
2717 POLL_HUP,
2718 NSIGPOLL = POLL_HUP,
2719 }
2720
2721 nothrow:
2722 @nogc:
2723 int killpg(pid_t, int);
2724 int sigaltstack(const scope stack_t*, stack_t*);
2725 int siginterrupt(int, int);
2726 int sigpause(int);
2727 }
2728 else version (DragonFlyBSD)
2729 {
2730 // No SIGPOLL on *BSD
2731 enum SIGPROF = 27;
2732 enum SIGSYS = 12;
2733 enum SIGTRAP = 5;
2734 enum SIGVTALRM = 26;
2735 enum SIGXCPU = 24;
2736 enum SIGXFSZ = 25;
2737
2738 enum
2739 {
2740 SA_ONSTACK = 0x0001,
2741 SA_RESTART = 0x0002,
2742 SA_RESETHAND = 0x0004,
2743 SA_NODEFER = 0x0010,
2744 SA_NOCLDWAIT = 0x0020,
2745 SA_SIGINFO = 0x0040,
2746 }
2747
2748 enum
2749 {
2750 SS_ONSTACK = 0x0001,
2751 SS_DISABLE = 0x0004,
2752 }
2753
2754 enum MINSIGSTKSZ = 8192;
2755 enum SIGSTKSZ = (MINSIGSTKSZ + 32768);
2756
2757 //ucontext_t (defined in core.sys.posix.ucontext)
2758 //mcontext_t (defined in core.sys.posix.ucontext)
2759
2760 struct stack_t
2761 {
2762 void* ss_sp;
2763 size_t ss_size;
2764 int ss_flags;
2765 }
2766
2767 struct sigstack
2768 {
2769 void* ss_sp;
2770 int ss_onstack;
2771 }
2772
2773 enum
2774 {
2775 ILL_ILLOPC = 1,
2776 ILL_ILLOPN,
2777 ILL_ILLADR,
2778 ILL_ILLTRP,
2779 ILL_PRVOPC,
2780 ILL_PRVREG,
2781 ILL_COPROC,
2782 ILL_BADSTK,
2783 }
2784
2785 enum
2786 {
2787 BUS_ADRALN = 1,
2788 BUS_ADRERR,
2789 BUS_OBJERR,
2790 }
2791
2792 enum
2793 {
2794 SEGV_MAPERR = 1,
2795 SEGV_ACCERR,
2796 }
2797
2798 enum
2799 {
2800 FPE_INTOVF = 1,
2801 FPE_INTDIV,
2802 FPE_FLTDIV,
2803 FPE_FLTOVF,
2804 FPE_FLTUND,
2805 FPE_FLTRES,
2806 FPE_FLTINV,
2807 FPE_FLTSUB,
2808 }
2809
2810 enum
2811 {
2812 TRAP_BRKPT = 1,
2813 TRAP_TRACE,
2814 }
2815
2816 enum
2817 {
2818 CLD_EXITED = 1,
2819 CLD_KILLED,
2820 CLD_DUMPED,
2821 CLD_TRAPPED,
2822 CLD_STOPPED,
2823 CLD_CONTINUED,
2824 }
2825
2826 enum
2827 {
2828 POLL_IN = 1,
2829 POLL_OUT,
2830 POLL_MSG,
2831 POLL_ERR,
2832 POLL_PRI,
2833 POLL_HUP,
2834 }
2835
2836 //sigfn_t bsd_signal(int sig, sigfn_t func);
2837 sigfn_t sigset(int sig, sigfn_t func);
2838
2839 nothrow:
2840 @nogc:
2841 //sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
2842 sigfn_t2 sigset(int sig, sigfn_t2 func);
2843
2844 int killpg(pid_t, int);
2845 int sigaltstack(const scope stack_t*, stack_t*);
2846 int sighold(int);
2847 int sigignore(int);
2848 int siginterrupt(int, int);
2849 int sigpause(int);
2850 int sigrelse(int);
2851 }
2852 else version (Solaris)
2853 {
2854 enum SIGPOLL = 22;
2855 enum SIGPROF = 29;
2856 enum SIGSYS = 12;
2857 enum SIGTRAP = 5;
2858 enum SIGVTALRM = 28;
2859 enum SIGXCPU = 30;
2860 enum SIGXFSZ = 31;
2861
2862 enum
2863 {
2864 SA_ONSTACK = 0x00001,
2865 SA_RESTART = 0x00004,
2866 SA_RESETHAND = 0x00002,
2867 SA_NODEFER = 0x00010,
2868 SA_NOCLDWAIT = 0x10000,
2869 SA_SIGINFO = 0x00008,
2870 }
2871
2872 enum
2873 {
2874 SS_ONSTACK = 0x0001,
2875 SS_DISABLE = 0x0002,
2876 }
2877
2878 enum MINSIGSTKSZ = 2048;
2879 enum SIGSTKSZ = 8192;
2880
2881 struct stack_t
2882 {
2883 void* ss_sp;
2884 size_t ss_size;
2885 int ss_flags;
2886 }
2887
2888 struct sigstack
2889 {
2890 void* ss_sp;
2891 int ss_onstack;
2892 }
2893
2894 enum
2895 {
2896 ILL_ILLOPC = 1,
2897 ILL_ILLOPN,
2898 ILL_ILLADR,
2899 ILL_ILLTRP,
2900 ILL_PRVOPC,
2901 ILL_PRVREG,
2902 ILL_COPROC,
2903 ILL_BADSTK,
2904 }
2905
2906 enum
2907 {
2908 BUS_ADRALN = 1,
2909 BUS_ADRERR,
2910 BUS_OBJERR,
2911 }
2912
2913 enum
2914 {
2915 SEGV_MAPERR = 1,
2916 SEGV_ACCERR,
2917 }
2918
2919 enum
2920 {
2921 FPE_INTDIV = 1,
2922 FPE_INTOVF,
2923 FPE_FLTDIV,
2924 FPE_FLTOVF,
2925 FPE_FLTUND,
2926 FPE_FLTRES,
2927 FPE_FLTINV,
2928 FPE_FLTSUB,
2929 FPE_FLTDEN,
2930 }
2931
2932 enum
2933 {
2934 TRAP_BRKPT = 1,
2935 TRAP_TRACE,
2936 TRAP_RWATCH,
2937 TRAP_WWATCH,
2938 TRAP_XWATCH,
2939 TRAP_DTRACE,
2940 }
2941
2942 enum
2943 {
2944 CLD_EXITED = 1,
2945 CLD_KILLED,
2946 CLD_DUMPED,
2947 CLD_TRAPPED,
2948 CLD_STOPPED,
2949 CLD_CONTINUED,
2950 }
2951
2952 enum
2953 {
2954 POLL_IN = 1,
2955 POLL_OUT,
2956 POLL_MSG,
2957 POLL_ERR,
2958 POLL_PRI,
2959 POLL_HUP,
2960 }
2961
2962 sigfn_t sigset(int sig, sigfn_t func);
2963
2964 nothrow:
2965 @nogc:
2966 sigfn_t2 sigset(int sig, sigfn_t2 func);
2967
2968 int killpg(pid_t, int);
2969 int sigaltstack(const scope stack_t*, stack_t*);
2970 int sighold(int);
2971 int sigignore(int);
2972 int siginterrupt(int, int);
2973 int sigpause(int);
2974 int sigrelse(int);
2975 }
2976 else version (CRuntime_Bionic)
2977 {
2978 enum SIGPOLL = 29;
2979 enum SIGPROF = 27;
2980 enum SIGSYS = 31;
2981 enum SIGTRAP = 5;
2982 enum SIGVTALRM = 26;
2983 enum SIGXCPU = 24;
2984 enum SIGXFSZ = 25;
2985
2986 enum SA_ONSTACK = 0x08000000;
2987 enum SA_RESETHAND = 0x80000000;
2988 enum SA_RESTART = 0x10000000;
2989 enum SA_SIGINFO = 4;
2990 enum SA_NOCLDWAIT = 2;
2991 enum SA_NODEFER = 0x40000000;
2992 enum SS_ONSTACK = 1;
2993 enum SS_DISABLE = 2;
2994 enum MINSIGSTKSZ = 2048;
2995 enum SIGSTKSZ = 8192;
2996
2997 struct stack_t
2998 {
2999 void* ss_sp;
3000 int ss_flags;
3001 size_t ss_size;
3002 }
3003
3004 enum
3005 {
3006 ILL_ILLOPC = 1,
3007 ILL_ILLOPN,
3008 ILL_ILLADR,
3009 ILL_ILLTRP,
3010 ILL_PRVOPC,
3011 ILL_PRVREG,
3012 ILL_COPROC,
3013 ILL_BADSTK
3014 }
3015
3016 enum
3017 {
3018 FPE_INTDIV = 1,
3019 FPE_INTOVF,
3020 FPE_FLTDIV,
3021 FPE_FLTOVF,
3022 FPE_FLTUND,
3023 FPE_FLTRES,
3024 FPE_FLTINV,
3025 FPE_FLTSUB
3026 }
3027
3028 enum
3029 {
3030 SEGV_MAPERR = 1,
3031 SEGV_ACCERR
3032 }
3033
3034 enum
3035 {
3036 BUS_ADRALN = 1,
3037 BUS_ADRERR,
3038 BUS_OBJERR
3039 }
3040
3041 enum
3042 {
3043 TRAP_BRKPT = 1,
3044 TRAP_TRACE
3045 }
3046
3047 enum
3048 {
3049 CLD_EXITED = 1,
3050 CLD_KILLED,
3051 CLD_DUMPED,
3052 CLD_TRAPPED,
3053 CLD_STOPPED,
3054 CLD_CONTINUED
3055 }
3056
3057 enum
3058 {
3059 POLL_IN = 1,
3060 POLL_OUT,
3061 POLL_MSG,
3062 POLL_ERR,
3063 POLL_PRI,
3064 POLL_HUP
3065 }
3066
3067 sigfn_t bsd_signal(int, sigfn_t);
3068
3069 nothrow:
3070 @nogc:
3071 sigfn_t2 bsd_signal(int, sigfn_t2);
3072
3073 int killpg(int, int);
3074 int sigaltstack(const scope stack_t*, stack_t*);
3075 int siginterrupt(int, int);
3076 }
3077 else version (CRuntime_Musl)
3078 {
3079 version (MIPS_Any)
3080 {
3081 enum SIGPOLL = 22;
3082 enum SIGPROF = 29;
3083 enum SIGSYS = 12;
3084 enum SIGTRAP = 5;
3085 enum SIGVTALRM = 28;
3086 enum SIGXCPU = 30;
3087 enum SIGXFSZ = 31;
3088
3089 enum SA_ONSTACK = 0x08000000;
3090 enum SA_RESETHAND = 0x80000000;
3091 enum SA_RESTART = 0x10000000;
3092 enum SA_SIGINFO = 8;
3093 enum SA_NOCLDWAIT = 0x10000;
3094 enum SA_NODEFER = 0x40000000;
3095 }
3096 else
3097 {
3098 enum SIGPOLL = 29;
3099 enum SIGPROF = 27;
3100 enum SIGSYS = 31;
3101 enum SIGTRAP = 5;
3102 enum SIGVTALRM = 26;
3103 enum SIGXCPU = 24;
3104 enum SIGXFSZ = 25;
3105
3106 enum SA_ONSTACK = 0x08000000;
3107 enum SA_RESETHAND = 0x80000000;
3108 enum SA_RESTART = 0x10000000;
3109 enum SA_SIGINFO = 4;
3110 enum SA_NOCLDWAIT = 2;
3111 enum SA_NODEFER = 0x40000000;
3112 }
3113
3114 enum SS_ONSTACK = 1;
3115 enum SS_DISABLE = 2;
3116
3117 version (ARM)
3118 {
3119 enum MINSIGSTKSZ = 2048;
3120 enum SIGSTKSZ = 8192;
3121 }
3122 else version (AArch64)
3123 {
3124 enum MINSIGSTKSZ = 6144;
3125 enum SIGSTKSZ = 12288;
3126 }
3127 else version (IBMZ_Any)
3128 {
3129 enum MINSIGSTKSZ = 4096;
3130 enum SIGSTKSZ = 10240;
3131 }
3132 else version (MIPS_Any)
3133 {
3134 enum MINSIGSTKSZ = 2048;
3135 enum SIGSTKSZ = 8192;
3136 }
3137 else version (PPC_Any)
3138 {
3139 enum MINSIGSTKSZ = 4096;
3140 enum SIGSTKSZ = 10240;
3141 }
3142 else version (X86_Any)
3143 {
3144 enum MINSIGSTKSZ = 2048;
3145 enum SIGSTKSZ = 8192;
3146 }
3147 else
3148 static assert(0, "unimplemented");
3149
3150 //ucontext_t (defined in core.sys.posix.ucontext)
3151 //mcontext_t (defined in core.sys.posix.ucontext)
3152
3153 version (MIPS_Any)
3154 {
3155 struct stack_t
3156 {
3157 void* ss_sp;
3158 size_t ss_size;
3159 int ss_flags;
3160 }
3161 }
3162 else
3163 {
3164 struct stack_t
3165 {
3166 void* ss_sp;
3167 int ss_flags;
3168 size_t ss_size;
3169 }
3170 }
3171
3172 enum
3173 {
3174 ILL_ILLOPC = 1,
3175 ILL_ILLOPN,
3176 ILL_ILLADR,
3177 ILL_ILLTRP,
3178 ILL_PRVOPC,
3179 ILL_PRVREG,
3180 ILL_COPROC,
3181 ILL_BADSTK
3182 }
3183
3184 enum
3185 {
3186 FPE_INTDIV = 1,
3187 FPE_INTOVF,
3188 FPE_FLTDIV,
3189 FPE_FLTOVF,
3190 FPE_FLTUND,
3191 FPE_FLTRES,
3192 FPE_FLTINV,
3193 FPE_FLTSUB
3194 }
3195
3196 enum
3197 {
3198 SEGV_MAPERR = 1,
3199 SEGV_ACCERR
3200 }
3201
3202 enum
3203 {
3204 BUS_ADRALN = 1,
3205 BUS_ADRERR,
3206 BUS_OBJERR
3207 }
3208
3209 enum
3210 {
3211 TRAP_BRKPT = 1,
3212 TRAP_TRACE
3213 }
3214
3215 enum
3216 {
3217 CLD_EXITED = 1,
3218 CLD_KILLED,
3219 CLD_DUMPED,
3220 CLD_TRAPPED,
3221 CLD_STOPPED,
3222 CLD_CONTINUED
3223 }
3224
3225 enum
3226 {
3227 POLL_IN = 1,
3228 POLL_OUT,
3229 POLL_MSG,
3230 POLL_ERR,
3231 POLL_PRI,
3232 POLL_HUP
3233 }
3234
3235 sigfn_t bsd_signal(int sig, sigfn_t func);
3236 sigfn_t sigset(int sig, sigfn_t func);
3237
3238 nothrow:
3239 @nogc:
3240 sigfn_t2 bsd_signal(int sig, sigfn_t2 func);
3241 sigfn_t2 sigset(int sig, sigfn_t2 func);
3242
3243 int killpg(pid_t, int);
3244 int sigaltstack(const scope stack_t*, stack_t*);
3245 int sighold(int);
3246 int sigignore(int);
3247 int siginterrupt(int, int);
3248 int sigpause(int);
3249 int sigrelse(int);
3250 }
3251 else version (CRuntime_UClibc)
3252 {
3253 version (X86_64)
3254 {
3255 enum SIGTRAP = 5;
3256 enum SIGIOT = 6;
3257 enum SIGSTKFLT = 16;
3258 enum SIGCLD = SIGCHLD;
3259 enum SIGXCPU = 24;
3260 enum SIGXFSZ = 25;
3261 enum SIGVTALRM = 26;
3262 enum SIGPROF = 27;
3263 enum SIGWINCH = 28;
3264 enum SIGPOLL = SIGIO;
3265 enum SIGIO = 29;
3266 enum SIGPWR = 30;
3267 enum SIGSYS = 31;
3268 enum SIGUNUSED = 31;
3269 }
3270 else version (MIPS32)
3271 {
3272 enum SIGTRAP = 5;
3273 enum SIGIOT = 6;
3274 enum SIGEMT = 7;
3275 enum SIGFPE = 8;
3276 enum SIGSYS = 12;
3277 enum SIGCLD = SIGCHLD;
3278 enum SIGPWR = 19;
3279 enum SIGWINCH = 20;
3280 enum SIGIO = 22;
3281 enum SIGPOLL = SIGIO;
3282 enum SIGVTALRM = 28;
3283 enum SIGPROF = 29;
3284 enum SIGXCPU = 30;
3285 enum SIGXFSZ = 31;
3286 }
3287 else version (ARM)
3288 {
3289 enum SIGTRAP = 5;
3290 enum SIGIOT = 6;
3291 enum SIGSTKFLT = 16;
3292 enum SIGCLD = SIGCHLD;
3293 enum SIGXCPU = 24;
3294 enum SIGXFSZ = 25;
3295 enum SIGVTALRM = 26;
3296 enum SIGPROF = 27;
3297 enum SIGWINCH = 28;
3298 enum SIGPOLL = SIGIO;
3299 enum SIGIO = 29;
3300 enum SIGPWR = 30;
3301 enum SIGSYS = 31;
3302 enum SIGUNUSED = 31;
3303 }
3304 else
3305 static assert(0, "unimplemented");
3306
3307 enum SA_ONSTACK = 0x08000000;
3308 enum SA_RESETHAND = 0x80000000;
3309 enum SA_RESTART = 0x10000000;
3310 enum SA_SIGINFO = 4;
3311 enum SA_NOCLDWAIT = 2;
3312 enum SA_NODEFER = 0x40000000;
3313 enum SS_ONSTACK = 1;
3314 enum SS_DISABLE = 2;
3315 enum MINSIGSTKSZ = 2048;
3316 enum SIGSTKSZ = 8192;
3317
3318 enum SA_INTERRUPT = 0x20000000;
3319
3320 enum SA_NOMASK = SA_NODEFER;
3321 enum SA_ONESHOT = SA_RESETHAND;
3322 enum SA_STACK = SA_ONSTACK;
3323
3324 version (MIPS32)
3325 {
3326 struct stack_t
3327 {
3328 void *ss_sp;
3329 size_t ss_size;
3330 int ss_flags;
3331 }
3332 }
3333 else
3334 {
3335 struct stack_t
3336 {
3337 void* ss_sp;
3338 int ss_flags;
3339 size_t ss_size;
3340 }
3341 }
3342
3343 struct sigstack
3344 {
3345 void* ss_sp;
3346 int ss_onstack;
3347 }
3348
3349 // `si_code' values for SIGILL signal.
3350 enum
3351 {
3352 ILL_ILLOPC = 1, // Illegal opcode.
3353 ILL_ILLOPN, // Illegal operand.
3354 ILL_ILLADR, // Illegal addressing mode.
3355 ILL_ILLTRP, // Illegal trap.
3356 ILL_PRVOPC, // Privileged opcode.
3357 ILL_PRVREG, // Privileged register.
3358 ILL_COPROC, // Coprocessor error.
3359 ILL_BADSTK // Internal stack error.
3360 }
3361
3362 // `si_code' values for SIGFPE signal.
3363 enum
3364 {
3365 FPE_INTDIV = 1, // Integer divide by zero.
3366 FPE_INTOVF, // Integer overflow.
3367 FPE_FLTDIV, // Floating point divide by zero.
3368 FPE_FLTOVF, // Floating point overflow.
3369 FPE_FLTUND, // Floating point underflow.
3370 FPE_FLTRES, // Floating point inexact result.
3371 FPE_FLTINV, // Floating point invalid operation.
3372 FPE_FLTSUB // Subscript out of range.
3373 }
3374
3375 // `si_code' values for SIGSEGV signal.
3376 enum
3377 {
3378 SEGV_MAPERR = 1, // Address not mapped to object.
3379 SEGV_ACCERR // Invalid permissions for mapped object.
3380 }
3381
3382 // `si_code' values for SIGBUS signal.
3383 enum
3384 {
3385 BUS_ADRALN = 1, // Invalid address alignment.
3386 BUS_ADRERR, // Non-existant physical address.
3387 BUS_OBJERR // Object specific hardware error.
3388 }
3389
3390 // `si_code' values for SIGTRAP signal.
3391 enum
3392 {
3393 TRAP_BRKPT = 1, // Process breakpoint.
3394 TRAP_TRACE // Process trace trap.
3395 }
3396
3397 // `si_code' values for SIGCHLD signal.
3398 enum
3399 {
3400 CLD_EXITED = 1, // Child has exited.
3401 CLD_KILLED, // Child was killed.
3402 CLD_DUMPED, // Child terminated abnormally.
3403 CLD_TRAPPED, // Traced child has trapped.
3404 CLD_STOPPED, // Child has stopped.
3405 CLD_CONTINUED // Stopped child has continued.
3406 }
3407
3408 // `si_code' values for SIGPOLL signal.
3409 enum
3410 {
3411 POLL_IN = 1, // Data input available.
3412 POLL_OUT, // Output buffers available.
3413 POLL_MSG, // Input message available.
3414 POLL_ERR, // I/O error.
3415 POLL_PRI, // High priority input available.
3416 POLL_HUP // Device disconnected.
3417 }
3418
3419 sigfn_t sigset(int sig, sigfn_t func);
3420
3421 nothrow:
3422 @nogc:
3423 sigfn_t2 sigset(int sig, sigfn_t2 func);
3424
3425 int killpg(pid_t, int);
3426 int sigaltstack(const scope stack_t*, stack_t*);
3427 int sighold(int);
3428 int sigignore(int);
3429 int siginterrupt(int, int);
3430 int sigpause(int);
3431 int sigrelse(int);
3432 }
3433 else
3434 {
3435 static assert(false, "Unsupported platform");
3436 }
3437
3438 //
3439 // Timer (TMR)
3440 //
3441 /*
3442 NOTE: This should actually be defined in core.sys.posix.time.
3443 It is defined here instead to break a circular import.
3444
3445 struct timespec
3446 {
3447 time_t tv_sec;
3448 int tv_nsec;
3449 }
3450 */
3451
3452 version (linux)
3453 {
3454 struct timespec
3455 {
3456 time_t tv_sec;
3457 c_long tv_nsec;
3458 }
3459 }
3460 else version (Darwin)
3461 {
3462 struct timespec
3463 {
3464 time_t tv_sec;
3465 c_long tv_nsec;
3466 }
3467 }
3468 else version (FreeBSD)
3469 {
3470 struct timespec
3471 {
3472 time_t tv_sec;
3473 c_long tv_nsec;
3474 }
3475 }
3476 else version (NetBSD)
3477 {
3478 struct timespec
3479 {
3480 time_t tv_sec;
3481 c_long tv_nsec;
3482 }
3483 }
3484 else version (OpenBSD)
3485 {
3486 struct timespec
3487 {
3488 time_t tv_sec;
3489 c_long tv_nsec;
3490 }
3491 }
3492 else version (DragonFlyBSD)
3493 {
3494 struct timespec
3495 {
3496 time_t tv_sec;
3497 c_long tv_nsec;
3498 }
3499 }
3500 else version (Solaris)
3501 {
3502 struct timespec
3503 {
3504 time_t tv_sec;
3505 c_long tv_nsec;
3506 }
3507
3508 alias timespec timestruc_t;
3509 }
3510 else
3511 {
3512 static assert(false, "Unsupported platform");
3513 }
3514
3515 //
3516 // Realtime Signals (RTS)
3517 //
3518 /*
3519 struct sigevent
3520 {
3521 int sigev_notify;
3522 int sigev_signo;
3523 sigval sigev_value;
3524 void(*)(sigval) sigev_notify_function;
3525 pthread_attr_t* sigev_notify_attributes;
3526 }
3527
3528 int sigqueue(pid_t, int, const sigval);
3529 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3530 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3531 */
3532
3533 nothrow:
3534 @nogc:
3535
3536 version (CRuntime_Glibc)
3537 {
3538 private enum __SIGEV_MAX_SIZE = 64;
3539
3540 static if ( __WORDSIZE == 64 )
3541 {
3542 private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4);
3543 }
3544 else
3545 {
3546 private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 3);
3547 }
3548
3549 struct sigevent
3550 {
3551 sigval sigev_value;
3552 int sigev_signo;
3553 int sigev_notify;
3554
3555 union _sigev_un_t
3556 {
3557 int[__SIGEV_PAD_SIZE] _pad;
3558 pid_t _tid;
3559
3560 struct _sigev_thread_t
3561 {
3562 void function(sigval) _function;
3563 void* _attribute;
3564 } _sigev_thread_t _sigev_thread;
3565 } _sigev_un_t _sigev_un;
3566 }
3567
3568 int sigqueue(pid_t, int, const sigval);
3569 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3570 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3571 }
3572 else version (FreeBSD)
3573 {
3574 struct sigevent
3575 {
3576 int sigev_notify;
3577 int sigev_signo;
3578 sigval sigev_value;
3579 union _sigev_un
3580 {
3581 lwpid_t _threadid;
3582 struct _sigev_thread
3583 {
3584 void function(sigval) _function;
3585 void* _attribute;
3586 }
3587 c_long[8] __spare__;
3588 }
3589 }
3590
3591 int sigqueue(pid_t, int, const sigval);
3592 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3593 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3594 }
3595 else version (NetBSD)
3596 {
3597 struct sigevent
3598 {
3599 int sigev_notify;
3600 int sigev_signo;
3601 sigval sigev_value;
3602 void function(sigval) sigev_notify_function;
3603 void /* pthread_attr_t */*sigev_notify_attributes;
3604 }
3605
3606 int sigqueue(pid_t, int, const sigval);
3607 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3608 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3609 }
3610 else version (OpenBSD)
3611 {
3612 // OpenBSD does not implement sigevent.
3613 alias sigevent = void;
3614 }
3615 else version (DragonFlyBSD)
3616 {
3617 union _sigev_un_t
3618 {
3619 int sigev_signo;
3620 int sigev_notify_kqueue;
3621 void /*pthread_attr_t*/ * sigev_notify_attributes;
3622 }
3623 union _sigval_t
3624 {
3625 int sival_int;
3626 void * sival_ptr;
3627 int sigval_int;
3628 void * sigval_ptr;
3629 }
3630 struct sigevent
3631 {
3632 int sigev_notify;
3633 _sigev_un_t sigev_un;
3634 _sigval_t sigev_value;
3635 void function(_sigval_t) sigev_notify_function;
3636 }
3637
3638 int sigqueue(pid_t, int, const sigval);
3639 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3640 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3641 }
3642 else version (Darwin)
3643 {
3644 struct sigevent
3645 {
3646 int sigev_notify;
3647 int sigev_signo;
3648 sigval sigev_value;
3649 void function(sigval) sigev_notify_function;
3650 pthread_attr_t* sigev_notify_attributes;
3651 }
3652 }
3653 else version (Solaris)
3654 {
3655 struct sigevent
3656 {
3657 int sigev_notify;
3658 int sigev_signo;
3659 sigval sigev_value;
3660 void function(sigval) sigev_notify_function;
3661 pthread_attr_t* sigev_notify_attributes;
3662 int __sigev_pad2;
3663 }
3664
3665 int sigqueue(pid_t, int, const sigval);
3666 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3667 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3668 }
3669 else version (CRuntime_Bionic)
3670 {
3671 private enum __ARCH_SIGEV_PREAMBLE_SIZE = (int.sizeof * 2) + sigval.sizeof;
3672 private enum SIGEV_MAX_SIZE = 64;
3673 private enum SIGEV_PAD_SIZE = (SIGEV_MAX_SIZE - __ARCH_SIGEV_PREAMBLE_SIZE)
3674 / int.sizeof;
3675
3676 struct sigevent
3677 {
3678 sigval sigev_value;
3679 int sigev_signo;
3680 int sigev_notify;
3681
3682 union _sigev_un_t
3683 {
3684 int[SIGEV_PAD_SIZE] _pad;
3685 int _tid;
3686
3687 struct _sigev_thread_t
3688 {
3689 void function(sigval) _function;
3690 void* _attribute;
3691 } _sigev_thread_t _sigev_thread;
3692 } _sigev_un_t _sigev_un;
3693 }
3694 }
3695 else version (CRuntime_Musl)
3696 {
3697 struct sigevent
3698 {
3699 sigval sigev_value;
3700 int sigev_signo;
3701 int sigev_notify;
3702 void function(sigval) sigev_notify_function;
3703 pthread_attr_t *sigev_notify_attributes;
3704 char[56 - 3 * c_long.sizeof] __pad = void;
3705 }
3706 }
3707 else version (CRuntime_UClibc)
3708 {
3709 private enum __SIGEV_MAX_SIZE = 64;
3710
3711 static if ( __WORDSIZE == 64 )
3712 {
3713 private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4);
3714 }
3715 else
3716 {
3717 private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 3);
3718 }
3719
3720 struct sigevent
3721 {
3722 sigval sigev_value;
3723 int sigev_signo;
3724 int sigev_notify;
3725
3726 union _sigev_un_t
3727 {
3728 int[__SIGEV_PAD_SIZE] _pad;
3729 pid_t _tid;
3730
3731 struct _sigev_thread_t
3732 {
3733 void function(sigval) _function;
3734 void* _attribute;
3735 } _sigev_thread_t _sigev_thread;
3736 } _sigev_un_t _sigev_un;
3737 }
3738
3739 @property void function(sigval) sigev_notify_function(ref sigevent _sigevent) { return _sigevent._sigev_un._sigev_thread._function; }
3740 @property void* sigev_notify_attributes(ref sigevent _sigevent) { return _sigevent._sigev_un._sigev_thread._attribute; }
3741
3742 int sigqueue(pid_t, int, const sigval);
3743 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*);
3744 int sigwaitinfo(const scope sigset_t*, siginfo_t*);
3745 }
3746 else
3747 {
3748 static assert(false, "Unsupported platform");
3749 }
3750
3751 //
3752 // Threads (THR)
3753 //
3754 /*
3755 int pthread_kill(pthread_t, int);
3756 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3757 */
3758
3759 version (CRuntime_Glibc)
3760 {
3761 int pthread_kill(pthread_t, int);
3762 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3763 }
3764 else version (Darwin)
3765 {
3766 int pthread_kill(pthread_t, int);
3767 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3768 }
3769 else version (FreeBSD)
3770 {
3771 int pthread_kill(pthread_t, int);
3772 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3773 }
3774 else version (NetBSD)
3775 {
3776 int pthread_kill(pthread_t, int);
3777 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3778 }
3779 else version (OpenBSD)
3780 {
3781 int pthread_kill(pthread_t, int);
3782 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3783 }
3784 else version (DragonFlyBSD)
3785 {
3786 int pthread_kill(pthread_t, int);
3787 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3788 }
3789 else version (Solaris)
3790 {
3791 int pthread_kill(pthread_t, int);
3792 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3793 }
3794 else version (CRuntime_Bionic)
3795 {
3796 int pthread_kill(pthread_t, int);
3797 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3798 }
3799 else version (CRuntime_Musl)
3800 {
3801 int pthread_kill(pthread_t, int);
3802 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3803 }
3804 else version (CRuntime_UClibc)
3805 {
3806 int pthread_kill(pthread_t, int);
3807 int pthread_sigmask(int, const scope sigset_t*, sigset_t*);
3808 int pthread_sigqueue(pthread_t, int, sigval);
3809 }
3810 else
3811 {
3812 static assert(false, "Unsupported platform");
3813 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org