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