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 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 { 156 // Note: it appears that FreeBSD (prior to 7) and OSX do not support realtime signals 157 // https://github.com/freebsd/freebsd/blob/e79c62ff68fc74d88cb6f479859f6fae9baa5101/sys/sys/signal.h#L117 158 enum SIGRTMIN = 65; 159 enum SIGRTMAX = 126; 160 } 161 else version (DragonFlyBSD) 162 { 163 enum SIGRTMIN = 35; 164 enum SIGRTMAX = 126; 165 } 166 else version (NetBSD) 167 { 168 enum SIGRTMIN = 33; 169 enum SIGRTMAX = 63; 170 } 171 else version (linux) 172 { 173 // Note: CRuntime_Bionic switched to calling these functions 174 // since Lollipop, and Glibc, UClib and Musl all implement them 175 // the same way since it's part of LSB. 176 private extern (C) nothrow @nogc 177 { 178 int __libc_current_sigrtmin(); 179 int __libc_current_sigrtmax(); 180 } 181 182 @property int SIGRTMIN() nothrow @nogc { 183 __gshared static int sig = -1; 184 if (sig == -1) { 185 sig = __libc_current_sigrtmin(); 186 } 187 return sig; 188 } 189 190 @property int SIGRTMAX() nothrow @nogc { 191 __gshared static int sig = -1; 192 if (sig == -1) { 193 sig = __libc_current_sigrtmax(); 194 } 195 return sig; 196 } 197 } 198 199 version (linux) 200 { 201 version (X86_Any) 202 { 203 //SIGABRT (defined in core.stdc.signal) 204 enum SIGALRM = 14; 205 enum SIGBUS = 7; 206 enum SIGCHLD = 17; 207 enum SIGCONT = 18; 208 //SIGFPE (defined in core.stdc.signal) 209 enum SIGHUP = 1; 210 //SIGILL (defined in core.stdc.signal) 211 //SIGINT (defined in core.stdc.signal) 212 enum SIGKILL = 9; 213 enum SIGPIPE = 13; 214 enum SIGQUIT = 3; 215 //SIGSEGV (defined in core.stdc.signal) 216 enum SIGSTOP = 19; 217 //SIGTERM (defined in core.stdc.signal) 218 enum SIGTSTP = 20; 219 enum SIGTTIN = 21; 220 enum SIGTTOU = 22; 221 enum SIGUSR1 = 10; 222 enum SIGUSR2 = 12; 223 enum SIGURG = 23; 224 } 225 else version (HPPA_Any) 226 { 227 //SIGABRT (defined in core.stdc.signal) 228 enum SIGALRM = 14; 229 enum SIGBUS = 10; 230 enum SIGCHLD = 18; 231 enum SIGCONT = 26; 232 //SIGFPE (defined in core.stdc.signal) 233 enum SIGHUP = 1; 234 //SIGILL (defined in core.stdc.signal) 235 //SIGINT (defined in core.stdc.signal) 236 enum SIGKILL = 9; 237 enum SIGPIPE = 13; 238 enum SIGQUIT = 3; 239 //SIGSEGV (defined in core.stdc.signal) 240 enum SIGSTOP = 24; 241 //SIGTERM (defined in core.stdc.signal) 242 enum SIGTSTP = 25; 243 enum SIGTTIN = 27; 244 enum SIGTTOU = 28; 245 enum SIGUSR1 = 16; 246 enum SIGUSR2 = 17; 247 enum SIGURG = 29; 248 } 249 else version (MIPS_Any) 250 { 251 //SIGABRT (defined in core.stdc.signal) 252 enum SIGALRM = 14; 253 enum SIGBUS = 10; 254 enum SIGCHLD = 18; 255 enum SIGCONT = 25; 256 //SIGFPE (defined in core.stdc.signal) 257 enum SIGHUP = 1; 258 //SIGILL (defined in core.stdc.signal) 259 //SIGINT (defined in core.stdc.signal) 260 enum SIGKILL = 9; 261 enum SIGPIPE = 13; 262 enum SIGQUIT = 3; 263 //SIGSEGV (defined in core.stdc.signal) 264 enum SIGSTOP = 23; 265 //SIGTERM (defined in core.stdc.signal) 266 enum SIGTSTP = 24; 267 enum SIGTTIN = 26; 268 enum SIGTTOU = 27; 269 enum SIGUSR1 = 16; 270 enum SIGUSR2 = 17; 271 enum SIGURG = 21; 272 } 273 else version (PPC_Any) 274 { 275 //SIGABRT (defined in core.stdc.signal) 276 enum SIGALRM = 14; 277 enum SIGBUS = 7; 278 enum SIGCHLD = 17; 279 enum SIGCONT = 18; 280 //SIGFPE (defined in core.stdc.signal) 281 enum SIGHUP = 1; 282 //SIGILL (defined in core.stdc.signal) 283 //SIGINT (defined in core.stdc.signal) 284 enum SIGKILL = 9; 285 enum SIGPIPE = 13; 286 enum SIGQUIT = 3; 287 //SIGSEGV (defined in core.stdc.signal) 288 enum SIGSTOP = 19; 289 //SIGTERM (defined in core.stdc.signal) 290 enum SIGTSTP = 20; 291 enum SIGTTIN = 21; 292 enum SIGTTOU = 22; 293 enum SIGUSR1 = 10; 294 enum SIGUSR2 = 12; 295 enum SIGURG = 23; 296 } 297 else version (ARM_Any) 298 { 299 //SIGABRT (defined in core.stdc.signal) 300 enum SIGALRM = 14; 301 enum SIGBUS = 7; 302 enum SIGCHLD = 17; 303 enum SIGCONT = 18; 304 //SIGFPE (defined in core.stdc.signal) 305 enum SIGHUP = 1; 306 //SIGILL (defined in core.stdc.signal) 307 //SIGINT (defined in core.stdc.signal) 308 enum SIGKILL = 9; 309 enum SIGPIPE = 13; 310 enum SIGQUIT = 3; 311 //SIGSEGV (defined in core.stdc.signal) 312 enum SIGSTOP = 19; 313 //SIGTERM (defined in core.stdc.signal) 314 enum SIGTSTP = 20; 315 enum SIGTTIN = 21; 316 enum SIGTTOU = 22; 317 enum SIGUSR1 = 10; 318 enum SIGUSR2 = 12; 319 enum SIGURG = 23; 320 } 321 else version (RISCV_Any) 322 { 323 //SIGABRT (defined in core.stdc.signal) 324 enum SIGALRM = 14; 325 enum SIGBUS = 7; 326 enum SIGCHLD = 17; 327 enum SIGCONT = 18; 328 //SIGFPE (defined in core.stdc.signal) 329 enum SIGHUP = 1; 330 //SIGILL (defined in core.stdc.signal) 331 //SIGINT (defined in core.stdc.signal) 332 enum SIGKILL = 9; 333 enum SIGPIPE = 13; 334 enum SIGQUIT = 3; 335 //SIGSEGV (defined in core.stdc.signal) 336 enum SIGSTOP = 19; 337 //SIGTERM (defined in core.stdc.signal) 338 enum SIGTSTP = 20; 339 enum SIGTTIN = 21; 340 enum SIGTTOU = 22; 341 enum SIGUSR1 = 10; 342 enum SIGUSR2 = 12; 343 enum SIGURG = 23; 344 } 345 else version (SPARC_Any) 346 { 347 //SIGABRT (defined in core.stdc.signal) 348 enum SIGALRM = 14; 349 enum SIGBUS = 10; 350 enum SIGCHLD = 20; 351 enum SIGCONT = 19; 352 //SIGFPE (defined in core.stdc.signal) 353 enum SIGHUP = 1; 354 //SIGILL (defined in core.stdc.signal) 355 //SIGINT (defined in core.stdc.signal) 356 enum SIGKILL = 9; 357 enum SIGPIPE = 13; 358 enum SIGQUIT = 3; 359 //SIGSEGV (defined in core.stdc.signal) 360 enum SIGSTOP = 17; 361 //SIGTERM (defined in core.stdc.signal) 362 enum SIGTSTP = 18; 363 enum SIGTTIN = 21; 364 enum SIGTTOU = 22; 365 enum SIGUSR1 = 30; 366 enum SIGUSR2 = 31; 367 enum SIGURG = 16; 368 } 369 else version (IBMZ_Any) 370 { 371 //SIGABRT (defined in core.stdc.signal) 372 enum SIGALRM = 14; 373 enum SIGBUS = 7; 374 enum SIGCHLD = 17; 375 enum SIGCONT = 18; 376 //SIGFPE (defined in core.stdc.signal) 377 enum SIGHUP = 1; 378 //SIGILL (defined in core.stdc.signal) 379 //SIGINT (defined in core.stdc.signal) 380 enum SIGKILL = 9; 381 enum SIGPIPE = 13; 382 enum SIGQUIT = 3; 383 //SIGSEGV (defined in core.stdc.signal) 384 enum SIGSTOP = 19; 385 //SIGTERM (defined in core.stdc.signal) 386 enum SIGTSTP = 20; 387 enum SIGTTIN = 21; 388 enum SIGTTOU = 22; 389 enum SIGUSR1 = 10; 390 enum SIGUSR2 = 12; 391 enum SIGURG = 23; 392 } 393 else 394 static assert(0, "unimplemented"); 395 } 396 else version (Darwin) 397 { 398 //SIGABRT (defined in core.stdc.signal) 399 enum SIGALRM = 14; 400 enum SIGBUS = 10; 401 enum SIGCHLD = 20; 402 enum SIGCONT = 19; 403 //SIGFPE (defined in core.stdc.signal) 404 enum SIGHUP = 1; 405 //SIGILL (defined in core.stdc.signal) 406 //SIGINT (defined in core.stdc.signal) 407 enum SIGKILL = 9; 408 enum SIGPIPE = 13; 409 enum SIGQUIT = 3; 410 //SIGSEGV (defined in core.stdc.signal) 411 enum SIGSTOP = 17; 412 //SIGTERM (defined in core.stdc.signal) 413 enum SIGTSTP = 18; 414 enum SIGTTIN = 21; 415 enum SIGTTOU = 22; 416 enum SIGUSR1 = 30; 417 enum SIGUSR2 = 31; 418 enum SIGURG = 16; 419 } 420 else version (FreeBSD) 421 { 422 //SIGABRT (defined in core.stdc.signal) 423 enum SIGALRM = 14; 424 enum SIGBUS = 10; 425 enum SIGCHLD = 20; 426 enum SIGCONT = 19; 427 //SIGFPE (defined in core.stdc.signal) 428 enum SIGHUP = 1; 429 //SIGILL (defined in core.stdc.signal) 430 //SIGINT (defined in core.stdc.signal) 431 enum SIGKILL = 9; 432 enum SIGPIPE = 13; 433 enum SIGQUIT = 3; 434 //SIGSEGV (defined in core.stdc.signal) 435 enum SIGSTOP = 17; 436 //SIGTERM (defined in core.stdc.signal) 437 enum SIGTSTP = 18; 438 enum SIGTTIN = 21; 439 enum SIGTTOU = 22; 440 enum SIGUSR1 = 30; 441 enum SIGUSR2 = 31; 442 enum SIGURG = 16; 443 } 444 else version (NetBSD) 445 { 446 //SIGABRT (defined in core.stdc.signal) 447 enum SIGALRM = 14; 448 enum SIGBUS = 10; 449 enum SIGCHLD = 20; 450 enum SIGCONT = 19; 451 //SIGFPE (defined in core.stdc.signal) 452 enum SIGHUP = 1; 453 //SIGILL (defined in core.stdc.signal) 454 //SIGINT (defined in core.stdc.signal) 455 enum SIGKILL = 9; 456 enum SIGPIPE = 13; 457 enum SIGQUIT = 3; 458 //SIGSEGV (defined in core.stdc.signal) 459 enum SIGSTOP = 17; 460 //SIGTERM (defined in core.stdc.signal) 461 enum SIGTSTP = 18; 462 enum SIGTTIN = 21; 463 enum SIGTTOU = 22; 464 enum SIGUSR1 = 30; 465 enum SIGUSR2 = 31; 466 enum SIGURG = 16; 467 } 468 else version (OpenBSD) 469 { 470 //SIGABRT (defined in core.stdc.signal) 471 enum SIGALRM = 14; 472 enum SIGBUS = 10; 473 enum SIGCHLD = 20; 474 enum SIGCONT = 19; 475 //SIGFPE (defined in core.stdc.signal) 476 enum SIGHUP = 1; 477 //SIGILL (defined in core.stdc.signal) 478 //SIGINT (defined in core.stdc.signal) 479 enum SIGKILL = 9; 480 enum SIGPIPE = 13; 481 enum SIGQUIT = 3; 482 //SIGSEGV (defined in core.stdc.signal) 483 enum SIGSTOP = 17; 484 //SIGTERM (defined in core.stdc.signal) 485 enum SIGTSTP = 18; 486 enum SIGTTIN = 21; 487 enum SIGTTOU = 22; 488 enum SIGUSR1 = 30; 489 enum SIGUSR2 = 31; 490 enum SIGURG = 16; 491 } 492 else version (DragonFlyBSD) 493 { 494 //SIGABRT (defined in core.stdc.signal) 495 enum SIGALRM = 14; 496 enum SIGBUS = 10; 497 enum SIGCHLD = 20; 498 enum SIGCONT = 19; 499 //SIGFPE (defined in core.stdc.signal) 500 enum SIGHUP = 1; 501 //SIGILL (defined in core.stdc.signal) 502 //SIGINT (defined in core.stdc.signal) 503 enum SIGKILL = 9; 504 enum SIGPIPE = 13; 505 enum SIGQUIT = 3; 506 //SIGSEGV (defined in core.stdc.signal) 507 enum SIGSTOP = 17; 508 //SIGTERM (defined in core.stdc.signal) 509 enum SIGTSTP = 18; 510 enum SIGTTIN = 21; 511 enum SIGTTOU = 22; 512 enum SIGUSR1 = 30; 513 enum SIGUSR2 = 31; 514 enum SIGURG = 16; 515 } 516 else version (Solaris) 517 { 518 //SIGABRT (defined in core.stdc.signal) 519 enum SIGALRM = 14; 520 enum SIGBUS = 10; 521 enum SIGCHLD = 18; 522 enum SIGCONT = 25; 523 //SIGFPE (defined in core.stdc.signal) 524 enum SIGHUP = 1; 525 //SIGILL (defined in core.stdc.signal) 526 //SIGINT (defined in core.stdc.signal) 527 enum SIGKILL = 9; 528 enum SIGPIPE = 13; 529 enum SIGQUIT = 3; 530 //SIGSEGV (defined in core.stdc.signal) 531 enum SIGSTOP = 23; 532 //SIGTERM (defined in core.stdc.signal) 533 enum SIGTSTP = 24; 534 enum SIGTTIN = 26; 535 enum SIGTTOU = 27; 536 enum SIGUSR1 = 16; 537 enum SIGUSR2 = 17; 538 enum SIGURG = 21; 539 } 540 else 541 { 542 static assert(false, "Unsupported platform"); 543 } 544 545 version (linux) 546 { 547 version (CRuntime_Musl) 548 { 549 struct sigaction_t 550 { 551 union 552 { 553 sigfn_t sa_handler; 554 sigactfn_t sa_sigaction; 555 } 556 sigset_t sa_mask; 557 int sa_flags; 558 void function() sa_restorer; 559 } 560 } 561 else version (CRuntime_Bionic) 562 { 563 version (D_LP64) 564 { 565 struct sigaction_t 566 { 567 int sa_flags; 568 union 569 { 570 sigfn_t sa_handler; 571 sigactfn_t sa_sigaction; 572 } 573 sigset_t sa_mask; 574 void function() sa_restorer; 575 } 576 } 577 else 578 { 579 struct sigaction_t 580 { 581 union 582 { 583 sigfn_t sa_handler; 584 sigactfn_t sa_sigaction; 585 } 586 sigset_t sa_mask; 587 int sa_flags; 588 void function() sa_restorer; 589 } 590 } 591 } 592 else version (SystemZ) 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 version (CRuntime_Glibc) 609 { 610 int __glibc_reserved0; 611 int sa_flags; 612 } 613 else 614 { 615 c_ulong sa_flags; 616 } 617 618 void function() sa_restorer; 619 620 sigset_t sa_mask; 621 } 622 } 623 else version (HPPA_Any) 624 { 625 struct sigaction_t 626 { 627 static if ( true /* __USE_POSIX199309 */ ) 628 { 629 union 630 { 631 sigfn_t sa_handler; 632 sigactfn_t sa_sigaction; 633 } 634 } 635 else 636 { 637 sigfn_t sa_handler; 638 } 639 version (CRuntime_Glibc) 640 { 641 version (D_LP64) 642 int __glibc_reserved0; 643 int sa_flags; 644 } 645 else 646 { 647 c_ulong sa_flags; 648 } 649 sigset_t sa_mask; 650 } 651 } 652 else version (MIPS_Any) 653 { 654 struct sigaction_t 655 { 656 int sa_flags; 657 658 static if ( true /* __USE_POSIX199309 */ ) 659 { 660 union 661 { 662 sigfn_t sa_handler; 663 sigactfn_t sa_sigaction; 664 } 665 } 666 else 667 { 668 sigfn_t sa_handler; 669 } 670 sigset_t sa_mask; 671 void function() sa_restorer; 672 673 version (CRuntime_Glibc) 674 { 675 static if ((void*).sizeof < 8) 676 int[1] sa_resv; 677 } 678 } 679 } 680 else version (SPARC_Any) 681 { 682 struct sigaction_t 683 { 684 static if ( true /* __USE_POSIX199309 */ ) 685 { 686 union 687 { 688 sigfn_t sa_handler; 689 sigactfn_t sa_sigaction; 690 } 691 } 692 else 693 { 694 sigfn_t sa_handler; 695 } 696 version (CRuntime_Glibc) 697 { 698 sigset_t sa_mask; 699 version (D_LP64) 700 int __glibc_reserved0; 701 int sa_flags; 702 void function() sa_restorer; 703 } 704 else 705 { 706 c_ulong sa_flags; 707 void function() sa_restorer; 708 sigset_t sa_mask; 709 } 710 } 711 } 712 else 713 { 714 struct sigaction_t 715 { 716 static if ( true /* __USE_POSIX199309 */ ) 717 { 718 union 719 { 720 sigfn_t sa_handler; 721 sigactfn_t sa_sigaction; 722 } 723 } 724 else 725 { 726 sigfn_t sa_handler; 727 } 728 sigset_t sa_mask; 729 int sa_flags; 730 731 void function() sa_restorer; 732 } 733 } 734 } 735 else version (FreeBSD) 736 { 737 struct sigaction_t 738 { 739 union 740 { 741 sigfn_t sa_handler; 742 sigactfn_t sa_sigaction; 743 } 744 int sa_flags; 745 sigset_t sa_mask; 746 } 747 } 748 else version (NetBSD) 749 { 750 struct sigaction_t 751 { 752 union 753 { 754 sigfn_t sa_handler; 755 sigactfn_t sa_sigaction; 756 } 757 sigset_t sa_mask; 758 int sa_flags; 759 } 760 } 761 else version (OpenBSD) 762 { 763 struct sigaction_t 764 { 765 union 766 { 767 sigfn_t __sa_handler; 768 alias sa_handler = __sa_handler; 769 sigactfn_t __sa_sigaction; 770 alias sa_sigaction = __sa_sigaction; 771 } 772 sigset_t sa_mask; 773 int sa_flags; 774 } 775 } 776 else version (DragonFlyBSD) 777 { 778 struct sigaction_t 779 { 780 union 781 { 782 sigfn_t sa_handler; 783 sigactfn_t sa_sigaction; 784 } 785 int sa_flags; 786 sigset_t sa_mask; 787 } 788 } 789 else version (Solaris) 790 { 791 struct sigaction_t 792 { 793 int sa_flags; 794 795 union 796 { 797 sigfn_t sa_handler; 798 sigactfn_t sa_sigaction; 799 } 800 801 sigset_t sa_mask; 802 version (D_LP64) {} 803 else 804 int[2] sa_resv; 805 } 806 } 807 else version (Darwin) 808 { 809 struct sigaction_t 810 { 811 static if ( true /* __USE_POSIX199309 */ ) 812 { 813 union 814 { 815 sigfn_t sa_handler; 816 sigactfn_t sa_sigaction; 817 } 818 } 819 else 820 { 821 sigfn_t sa_handler; 822 } 823 sigset_t sa_mask; 824 int sa_flags; 825 } 826 } 827 else 828 { 829 static assert(false, "Unsupported platform"); 830 } 831 832 // 833 // C Extension (CX) 834 // 835 /* 836 SIG_HOLD 837 838 sigset_t 839 pid_t (defined in core.sys.types) 840 841 SIGABRT (defined in core.stdc.signal) 842 SIGFPE (defined in core.stdc.signal) 843 SIGILL (defined in core.stdc.signal) 844 SIGINT (defined in core.stdc.signal) 845 SIGSEGV (defined in core.stdc.signal) 846 SIGTERM (defined in core.stdc.signal) 847 848 SA_NOCLDSTOP (CX|XSI) 849 SIG_BLOCK 850 SIG_UNBLOCK 851 SIG_SETMASK 852 853 struct siginfo_t 854 { 855 int si_signo; 856 int si_code; 857 858 version (XSI) 859 { 860 int si_errno; 861 pid_t si_pid; 862 uid_t si_uid; 863 void* si_addr; 864 int si_status; 865 c_long si_band; 866 } 867 version (RTS) 868 { 869 sigval si_value; 870 } 871 } 872 873 SI_USER 874 SI_QUEUE 875 SI_TIMER 876 SI_ASYNCIO 877 SI_MESGQ 878 */ 879 880 nothrow @nogc 881 { 882 883 version (linux) 884 { 885 enum SIG_HOLD = cast(sigfn_t2) 2; 886 887 private enum _SIGSET_NWORDS = 1024 / (8 * c_ulong.sizeof); 888 889 struct sigset_t 890 { 891 c_ulong[_SIGSET_NWORDS] __val; 892 } 893 894 enum SA_NOCLDSTOP = 1; // (CX|XSI) 895 896 version (MIPS_Any) 897 { 898 enum SIG_BLOCK = 1; 899 enum SIG_UNBLOCK = 2; 900 enum SIG_SETMASK = 3; 901 } 902 else version (SPARC_Any) 903 { 904 enum SIG_BLOCK = 1; 905 enum SIG_UNBLOCK = 2; 906 enum SIG_SETMASK = 4; 907 } 908 else 909 { 910 enum SIG_BLOCK = 0; 911 enum SIG_UNBLOCK = 1; 912 enum SIG_SETMASK = 2; 913 } 914 915 private enum __SI_MAX_SIZE = 128; 916 917 static if ( __WORDSIZE == 64 ) 918 { 919 private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 4); 920 } 921 else 922 { 923 private enum __SI_PAD_SIZE = ((__SI_MAX_SIZE / int.sizeof) - 3); 924 } 925 926 struct siginfo_t 927 { 928 int si_signo; 929 version (MIPS_Any) // __SI_SWAP_ERRNO_CODE 930 { 931 int si_code; 932 int si_errno; 933 } 934 else 935 { 936 int si_errno; 937 int si_code; 938 } 939 940 union _sifields_t 941 { 942 int[__SI_PAD_SIZE] _pad; 943 944 // kill() 945 struct _kill_t 946 { 947 pid_t si_pid; 948 uid_t si_uid; 949 } _kill_t _kill; 950 // POSIX.1b timers. 951 struct _timer_t 952 { 953 int si_tid; 954 int si_overrun; 955 sigval si_sigval; 956 } _timer_t _timer; 957 958 // POSIX.1b signals 959 struct _rt_t 960 { 961 pid_t si_pid; 962 uid_t si_uid; 963 sigval si_sigval; 964 } _rt_t _rt; 965 966 // SIGCHLD 967 struct _sigchild_t 968 { 969 pid_t si_pid; 970 uid_t si_uid; 971 int si_status; 972 clock_t si_utime; 973 clock_t si_stime; 974 } _sigchild_t _sigchld; 975 976 // SIGILL, SIGFPE, SIGSEGV, SIGBUS 977 struct _sigfault_t 978 { 979 void* si_addr; 980 } _sigfault_t _sigfault; 981 982 // SIGPOLL 983 struct _sigpoll_t 984 { 985 c_long si_band; 986 int si_fd; 987 } _sigpoll_t _sigpoll; 988 } _sifields_t _sifields; 989 990 nothrow @nogc: 991 @property ref pid_t si_pid() return { return _sifields._kill.si_pid; } 992 @property ref uid_t si_uid() return { return _sifields._kill.si_uid; } 993 @property ref void* si_addr() return { return _sifields._sigfault.si_addr; } 994 @property ref int si_status() return { return _sifields._sigchld.si_status; } 995 @property ref c_long si_band() return { return _sifields._sigpoll.si_band; } 996 @property ref sigval si_value() return { return _sifields._rt.si_sigval; } 997 } 998 999 enum 1000 { 1001 SI_ASYNCNL = -60, 1002 SI_TKILL = -6, 1003 SI_SIGIO, 1004 SI_ASYNCIO, 1005 SI_MESGQ, 1006 SI_TIMER, 1007 SI_QUEUE, 1008 SI_USER, 1009 SI_KERNEL = 0x80 1010 } 1011 } 1012 else version (Darwin) 1013 { 1014 enum SIG_HOLD = cast(sigfn_t2) 5; 1015 1016 alias uint sigset_t; 1017 1018 enum SA_NOCLDSTOP = 8; // (CX|XSI) 1019 1020 enum SIG_BLOCK = 1; 1021 enum SIG_UNBLOCK = 2; 1022 enum SIG_SETMASK = 3; 1023 1024 struct siginfo_t 1025 { 1026 int si_signo; 1027 int si_errno; 1028 int si_code; 1029 pid_t si_pid; 1030 uid_t si_uid; 1031 int si_status; 1032 void* si_addr; 1033 sigval si_value; 1034 int si_band; 1035 uint[7] pad; 1036 } 1037 1038 enum SI_USER = 0x10001; 1039 enum SI_QUEUE = 0x10002; 1040 enum SI_TIMER = 0x10003; 1041 enum SI_ASYNCIO = 0x10004; 1042 enum SI_MESGQ = 0x10005; 1043 } 1044 else version (FreeBSD) 1045 { 1046 enum SIG_HOLD = cast(sigfn_t2) 3; 1047 1048 struct sigset_t 1049 { 1050 uint[4] __bits; 1051 } 1052 1053 enum SA_NOCLDSTOP = 8; 1054 1055 enum SIG_BLOCK = 1; 1056 enum SIG_UNBLOCK = 2; 1057 enum SIG_SETMASK = 3; 1058 1059 struct siginfo_t 1060 { 1061 int si_signo; 1062 int si_errno; 1063 int si_code; 1064 pid_t si_pid; 1065 uid_t si_uid; 1066 int si_status; 1067 void* si_addr; 1068 sigval si_value; 1069 union __reason 1070 { 1071 struct __fault 1072 { 1073 int _trapno; 1074 } 1075 __fault _fault; 1076 struct __timer 1077 { 1078 int _timerid; 1079 int _overrun; 1080 } 1081 __timer _timer; 1082 struct __mesgq 1083 { 1084 int _mqd; 1085 } 1086 __mesgq _mesgq; 1087 struct __poll 1088 { 1089 c_long _band; 1090 } 1091 __poll _poll; 1092 struct ___spare___ 1093 { 1094 c_long __spare1__; 1095 int[7] __spare2__; 1096 } 1097 ___spare___ __spare__; 1098 } 1099 __reason _reason; 1100 1101 @property ref c_long si_band() return { return _reason._poll._band; } 1102 } 1103 1104 enum SI_USER = 0x10001; 1105 enum SI_QUEUE = 0x10002; 1106 enum SI_TIMER = 0x10003; 1107 enum SI_ASYNCIO = 0x10004; 1108 enum SI_MESGQ = 0x10005; 1109 } 1110 else version (NetBSD) 1111 { 1112 enum SIG_HOLD = cast(sigfn_t2) 3; 1113 1114 struct sigset_t 1115 { 1116 uint[4] __bits; 1117 } 1118 1119 enum SA_NOCLDSTOP = 8; 1120 1121 enum SIG_BLOCK = 1; 1122 enum SIG_UNBLOCK = 2; 1123 enum SIG_SETMASK = 3; 1124 1125 union sigval_t 1126 { 1127 int sival_int; 1128 void* sival_ptr; 1129 } 1130 1131 struct _ksiginfo 1132 { 1133 int _signo; 1134 int _code; 1135 int _errno; 1136 version (D_LP64) 1137 int _pad; 1138 1139 union reason_t 1140 { 1141 struct rt_t 1142 { 1143 pid_t _pid; 1144 uid_t _uid; 1145 sigval_t _value; 1146 } rt_t _rt; 1147 struct child_t 1148 { 1149 pid_t _pid; 1150 uid_t _uid; 1151 int _status; 1152 clock_t _utime; 1153 clock_t _stime; 1154 } child_t _child; 1155 struct fault_t 1156 { 1157 void* _addr; 1158 int _trap; 1159 int _trap2; 1160 int _trap3; 1161 } fault_t fault; 1162 struct poll_t 1163 { 1164 c_long _band; 1165 int _fd; 1166 } poll_t _poll; 1167 } 1168 reason_t _reason; 1169 } 1170 1171 union siginfo_t 1172 { 1173 ubyte[128] si_pad; 1174 _ksiginfo _info; 1175 @property ref c_long si_band() return { return _info._reason._poll._band; } 1176 } 1177 1178 enum SI_USER = 0; 1179 enum SI_QUEUE = -1; 1180 enum SI_TIMER = -2; 1181 enum SI_ASYNCIO = -3; 1182 enum SI_MESGQ = -4; 1183 } 1184 else version (OpenBSD) 1185 { 1186 enum SIG_CATCH = cast(sigfn_t2) 2; 1187 enum SIG_HOLD = cast(sigfn_t2) 3; 1188 1189 alias sigset_t = uint; 1190 1191 enum SA_NOCLDSTOP = 0x0008; 1192 1193 enum SIG_BLOCK = 1; 1194 enum SIG_UNBLOCK = 2; 1195 enum SIG_SETMASK = 3; 1196 1197 private enum SI_MAXSZ = 128; 1198 private enum SI_PAD = (SI_MAXSZ / int.sizeof) - 3; 1199 1200 struct siginfo_t 1201 { 1202 int si_signo; 1203 int si_errno; 1204 int si_code; 1205 union _data 1206 { 1207 int[SI_PAD] _pad; 1208 struct _proc 1209 { 1210 pid_t _pid; 1211 union _pdata 1212 { 1213 struct _kill 1214 { 1215 uid_t _uid; 1216 sigval _value; 1217 } 1218 struct _cld 1219 { 1220 clock_t _utime; 1221 clock_t _stime; 1222 int _status; 1223 } 1224 } 1225 } 1226 struct _fault 1227 { 1228 caddr_t _addr; 1229 int _trapno; 1230 } 1231 } 1232 alias si_pid = _data._proc._pid; 1233 alias si_status = _data._proc._pdata._cld._status; 1234 alias si_stime = _data._proc._pdata._cld._stime; 1235 alias si_utime = _data._proc._pdata._cld._utime; 1236 alias si_uid = _data._proc._pdata._kill._uid; 1237 alias si_value = _data._proc._pdata._kill._value; 1238 alias si_addr = _data._fault._addr; 1239 alias si_trapno = _data._fault._trapno; 1240 } 1241 1242 enum SI_NOINFO = 32767; 1243 enum SI_USER = 0; 1244 enum SI_LWP = -1; 1245 enum SI_QUEUE = -2; 1246 enum SI_TIMER = -3; 1247 } 1248 else version (DragonFlyBSD) 1249 { 1250 enum SIG_CATCH = cast(sigfn_t2) 2; 1251 enum SIG_HOLD = cast(sigfn_t2) 3; 1252 1253 struct sigset_t 1254 { 1255 uint[4] __bits; 1256 } 1257 1258 enum SA_NOCLDSTOP = 8; 1259 1260 enum SIG_BLOCK = 1; 1261 enum SIG_UNBLOCK = 2; 1262 enum SIG_SETMASK = 3; 1263 1264 struct siginfo_t 1265 { 1266 int si_signo; 1267 int si_errno; 1268 int si_code; 1269 int si_pid; 1270 uint si_uid; 1271 int si_status; 1272 void* si_addr; 1273 sigval si_value; 1274 c_long si_band; 1275 int[7] __spare; 1276 } 1277 1278 enum SI_UNDEFINED = 0x00000; 1279 enum SI_USER = 0; 1280 enum SI_QUEUE = -1; 1281 enum SI_TIMER = -2; 1282 enum SI_ASYNCIO = -3; 1283 enum SI_MESGQ = -4; 1284 } 1285 else version (Solaris) 1286 { 1287 enum SIG_HOLD = cast(sigfn_t2)2; 1288 1289 struct sigset_t 1290 { 1291 uint[4] __bits; 1292 } 1293 1294 enum SIG_BLOCK = 1; 1295 enum SIG_UNBLOCK = 2; 1296 enum SIG_SETMASK = 3; 1297 1298 struct siginfo_t 1299 { 1300 int si_signo; 1301 int si_code; 1302 int si_errno; 1303 1304 version (D_LP64) 1305 int si_pad; 1306 1307 union ___data 1308 { 1309 version (D_LP64) 1310 int[(256 / int.sizeof) - 4] si_pad; 1311 else 1312 int[(128 / int.sizeof) - 3] si_pad; 1313 1314 struct ___proc 1315 { 1316 pid_t __pid; 1317 1318 union ___pdata 1319 { 1320 struct ___kill 1321 { 1322 uid_t __uid; 1323 sigval __value; 1324 } 1325 1326 ___kill __kill; 1327 1328 struct ___cld 1329 { 1330 clock_t __utime; 1331 int __status; 1332 clock_t __stime; 1333 } 1334 1335 ___cld __cld; 1336 } 1337 1338 ___pdata __pdata; 1339 ctid_t __ctid; 1340 zoneid_t __zoneid; 1341 } 1342 1343 ___proc __proc; 1344 1345 struct ___fault 1346 { 1347 void* __addr; 1348 int __trapno; 1349 caddr_t __pc; 1350 } 1351 1352 ___fault __fault; 1353 1354 struct ___file 1355 { 1356 int __fd; 1357 c_long __band; 1358 } 1359 1360 ___file __file; 1361 1362 struct ___prof 1363 { 1364 caddr_t __faddr; 1365 timestruc_t __tstamp; 1366 short __syscall; 1367 char __nsysarg = 0; 1368 char __fault = 0; 1369 c_long[8] __sysarg; 1370 int[10] __mstate; 1371 } 1372 1373 ___prof __prof; 1374 1375 struct ___rctl 1376 { 1377 int __entity; 1378 } 1379 1380 ___rctl __rctl; 1381 } 1382 1383 ___data __data; 1384 } 1385 1386 enum SI_NOINFO = 32767; 1387 enum SI_DTRACE = 2050; 1388 enum SI_RCTL = 2049; 1389 enum SI_USER = 0; 1390 enum SI_LWP = -1; 1391 enum SI_QUEUE = -2; 1392 enum SI_TIMER = -3; 1393 enum SI_ASYNCIO = -4; 1394 enum SI_MESGQ = -5; 1395 } 1396 else 1397 { 1398 static assert(false, "Unsupported platform"); 1399 } 1400 1401 /* 1402 int kill(pid_t, int); 1403 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1404 int sigaddset(sigset_t*, int); 1405 int sigdelset(sigset_t*, int); 1406 int sigemptyset(sigset_t*); 1407 int sigfillset(sigset_t*); 1408 int sigismember(const scope sigset_t*, int); 1409 int sigpending(sigset_t*); 1410 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1411 int sigsuspend(const scope sigset_t*); 1412 int sigwait(const scope sigset_t*, int*); 1413 */ 1414 1415 version (CRuntime_Glibc) 1416 { 1417 int kill(pid_t, int); 1418 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1419 int sigaddset(sigset_t*, int); 1420 int sigdelset(sigset_t*, int); 1421 int sigemptyset(sigset_t*); 1422 int sigfillset(sigset_t*); 1423 int sigismember(const scope sigset_t*, int); 1424 int sigpending(sigset_t*); 1425 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1426 int sigsuspend(const scope sigset_t*); 1427 int sigwait(const scope sigset_t*, int*); 1428 } 1429 else version (Darwin) 1430 { 1431 int kill(pid_t, int); 1432 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1433 int sigaddset(sigset_t*, int); 1434 int sigdelset(sigset_t*, int); 1435 int sigemptyset(sigset_t*); 1436 int sigfillset(sigset_t*); 1437 int sigismember(const scope sigset_t*, int); 1438 int sigpending(sigset_t*); 1439 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1440 int sigsuspend(const scope sigset_t*); 1441 int sigwait(const scope sigset_t*, int*); 1442 } 1443 else version (FreeBSD) 1444 { 1445 int kill(pid_t, int); 1446 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1447 int sigaddset(sigset_t*, int); 1448 int sigdelset(sigset_t*, int); 1449 int sigemptyset(sigset_t *); 1450 int sigfillset(sigset_t *); 1451 int sigismember(const scope sigset_t*, int); 1452 int sigpending(sigset_t *); 1453 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1454 int sigsuspend(const scope sigset_t*); 1455 int sigwait(const scope sigset_t*, int*); 1456 } 1457 else version (NetBSD) 1458 { 1459 int kill(pid_t, int); 1460 int __sigaction14(int, const scope sigaction_t*, sigaction_t*); 1461 int __sigaddset14(sigset_t*, int); 1462 int __sigdelset14(sigset_t*, int); 1463 int __sigemptyset14(sigset_t *); 1464 int __sigfillset14(sigset_t *); 1465 int __sigismember14(const scope sigset_t*, int); 1466 int __sigpending14(sigset_t *); 1467 int __sigprocmask14(int, const scope sigset_t*, sigset_t*); 1468 int __sigsuspend14(const scope sigset_t*); 1469 int sigwait(const scope sigset_t*, int*); 1470 1471 alias __sigaction14 sigaction; 1472 alias __sigaddset14 sigaddset; 1473 alias __sigdelset14 sigdelset; 1474 alias __sigemptyset14 sigemptyset; 1475 alias __sigfillset14 sigfillset; 1476 alias __sigismember14 sigismember; 1477 alias __sigpending14 sigpending; 1478 alias __sigprocmask14 sigprocmask; 1479 alias __sigsuspend14 sigsuspend; 1480 } 1481 else version (OpenBSD) 1482 { 1483 int kill(pid_t, int); 1484 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1485 int sigaddset(sigset_t*, int); 1486 int sigdelset(sigset_t*, int); 1487 int sigemptyset(sigset_t *); 1488 int sigfillset(sigset_t *); 1489 int sigismember(const scope sigset_t*, int); 1490 int sigpending(sigset_t *); 1491 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1492 int sigsuspend(const scope sigset_t*); 1493 int sigwait(const scope sigset_t*, int*); 1494 } 1495 else version (DragonFlyBSD) 1496 { 1497 int kill(pid_t, int); 1498 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1499 int sigaddset(sigset_t*, int); 1500 int sigdelset(sigset_t*, int); 1501 int sigemptyset(sigset_t *); 1502 int sigfillset(sigset_t *); 1503 int sigismember(const scope sigset_t*, int); 1504 int sigpending(sigset_t *); 1505 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1506 int sigsuspend(const scope sigset_t*); 1507 int sigwait(const scope sigset_t*, int*); 1508 } 1509 else version (Solaris) 1510 { 1511 int kill(pid_t, int); 1512 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1513 int sigaddset(sigset_t*, int); 1514 int sigdelset(sigset_t*, int); 1515 int sigemptyset(sigset_t*); 1516 int sigfillset(sigset_t*); 1517 int sigismember(const scope sigset_t*, int); 1518 int sigpending(sigset_t*); 1519 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1520 int sigsuspend(const scope sigset_t*); 1521 int sigwait(const scope sigset_t*, int*); 1522 } 1523 else version (CRuntime_Bionic) 1524 { 1525 public import core.sys.posix.time: timer_t; 1526 import core.stdc.string : memset; 1527 1528 version (X86) 1529 enum int LONG_BIT = 32; 1530 else version (ARM) 1531 enum int LONG_BIT = 32; 1532 else version (AArch64) 1533 enum int LONG_BIT = 64; 1534 else version (X86_64) 1535 enum int LONG_BIT = 64; 1536 else 1537 static assert(false, "Architecture not supported."); 1538 1539 int kill(pid_t, int); 1540 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1541 1542 // These functions are defined inline in bionic. 1543 int sigaddset(sigset_t* set, int signum) 1544 { 1545 c_ulong* local_set = cast(c_ulong*) set; 1546 signum--; 1547 local_set[signum/LONG_BIT] |= 1UL << (signum%LONG_BIT); 1548 return 0; 1549 } 1550 1551 int sigdelset(sigset_t* set, int signum) 1552 { 1553 c_ulong* local_set = cast(c_ulong*) set; 1554 signum--; 1555 local_set[signum/LONG_BIT] &= ~(1UL << (signum%LONG_BIT)); 1556 return 0; 1557 } 1558 1559 int sigemptyset(sigset_t* set) { memset(set, 0, (*set).sizeof); return 0; } 1560 1561 int sigfillset(sigset_t* set) { memset(set, ~0, (*set).sizeof); return 0; } 1562 1563 int sigismember(sigset_t* set, int signum) 1564 { 1565 c_ulong* local_set = cast(c_ulong*) set; 1566 signum--; 1567 return cast(int) ((local_set[signum/LONG_BIT] >> (signum%LONG_BIT)) & 1); 1568 } 1569 1570 int sigpending(sigset_t*); 1571 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1572 int sigsuspend(const scope sigset_t*); 1573 int sigwait(const scope sigset_t*, int*); 1574 } 1575 else version (CRuntime_Musl) 1576 { 1577 int kill(pid_t, int); 1578 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1579 int sigaddset(sigset_t*, int); 1580 int sigdelset(sigset_t*, int); 1581 int sigemptyset(sigset_t*); 1582 int sigfillset(sigset_t*); 1583 int sigismember(const scope sigset_t*, int); 1584 int sigpending(sigset_t*); 1585 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1586 int sigsuspend(const scope sigset_t*); 1587 int sigwait(const scope sigset_t*, int*); 1588 } 1589 else version (CRuntime_UClibc) 1590 { 1591 int kill(pid_t, int); 1592 int sigaction(int, const scope sigaction_t*, sigaction_t*); 1593 int sigaddset(sigset_t*, int); 1594 int sigdelset(sigset_t*, int); 1595 int sigemptyset(sigset_t*); 1596 int sigfillset(sigset_t*); 1597 int sigismember(const scope sigset_t*, int); 1598 int sigpending(sigset_t*); 1599 int sigprocmask(int, const scope sigset_t*, sigset_t*); 1600 int sigsuspend(const scope sigset_t*); 1601 int sigwait(const scope sigset_t*, int*); 1602 } 1603 else 1604 { 1605 static assert(false, "Unsupported platform"); 1606 } 1607 } 1608 1609 // 1610 // XOpen (XSI) 1611 // 1612 /* 1613 SIGPOLL 1614 SIGPROF 1615 SIGSYS 1616 SIGTRAP 1617 SIGVTALRM 1618 SIGXCPU 1619 SIGXFSZ 1620 1621 SA_ONSTACK 1622 SA_RESETHAND 1623 SA_RESTART 1624 SA_SIGINFO 1625 SA_NOCLDWAIT 1626 SA_NODEFER 1627 1628 ILL_ILLOPC 1629 ILL_ILLOPN 1630 ILL_ILLADR 1631 ILL_ILLTRP 1632 ILL_PRVOPC 1633 ILL_PRVREG 1634 ILL_COPROC 1635 ILL_BADSTK 1636 1637 FPE_INTDIV 1638 FPE_INTOVF 1639 FPE_FLTDIV 1640 FPE_FLTOVF 1641 FPE_FLTUND 1642 FPE_FLTRES 1643 FPE_FLTINV 1644 FPE_FLTSUB 1645 1646 SEGV_MAPERR 1647 SEGV_ACCERR 1648 1649 BUS_ADRALN 1650 BUS_ADRERR 1651 BUS_OBJERR 1652 1653 TRAP_BRKPT 1654 TRAP_TRACE 1655 1656 CLD_EXITED 1657 CLD_KILLED 1658 CLD_DUMPED 1659 CLD_TRAPPED 1660 CLD_STOPPED 1661 CLD_CONTINUED 1662 1663 POLL_IN 1664 POLL_OUT 1665 POLL_MSG 1666 POLL_ERR 1667 POLL_PRI 1668 POLL_HUP 1669 */ 1670 1671 version (linux) 1672 { 1673 version (X86_Any) 1674 { 1675 enum SIGPOLL = 29; 1676 enum SIGPROF = 27; 1677 enum SIGSYS = 31; 1678 enum SIGTRAP = 5; 1679 enum SIGVTALRM = 26; 1680 enum SIGXCPU = 24; 1681 enum SIGXFSZ = 25; 1682 } 1683 else version (HPPA_Any) 1684 { 1685 enum SIGPOLL = 22; 1686 enum SIGPROF = 21; 1687 enum SIGSYS = 31; 1688 enum SIGTRAP = 5; 1689 enum SIGVTALRM = 20; 1690 enum SIGXCPU = 12; 1691 enum SIGXFSZ = 30; 1692 } 1693 else version (MIPS_Any) 1694 { 1695 enum SIGPOLL = 22; 1696 enum SIGPROF = 29; 1697 enum SIGSYS = 12; 1698 enum SIGTRAP = 5; 1699 enum SIGVTALRM = 28; 1700 enum SIGXCPU = 30; 1701 enum SIGXFSZ = 31; 1702 } 1703 else version (PPC_Any) 1704 { 1705 enum SIGPOLL = 29; 1706 enum SIGPROF = 27; 1707 enum SIGSYS = 31; 1708 enum SIGTRAP = 5; 1709 enum SIGVTALRM = 26; 1710 enum SIGXCPU = 24; 1711 enum SIGXFSZ = 25; 1712 } 1713 else version (ARM_Any) 1714 { 1715 enum SIGPOLL = 29; 1716 enum SIGPROF = 27; 1717 enum SIGSYS = 31; 1718 enum SIGTRAP = 5; 1719 enum SIGVTALRM = 26; 1720 enum SIGXCPU = 24; 1721 enum SIGXFSZ = 25; 1722 } 1723 else version (RISCV_Any) 1724 { 1725 enum SIGPOLL = 29; 1726 enum SIGPROF = 27; 1727 enum SIGSYS = 31; 1728 enum SIGTRAP = 5; 1729 enum SIGVTALRM = 26; 1730 enum SIGXCPU = 24; 1731 enum SIGXFSZ = 25; 1732 } 1733 else version (SPARC_Any) 1734 { 1735 enum SIGPOLL = 23; 1736 enum SIGPROF = 27; 1737 enum SIGSYS = 12; 1738 enum SIGTRAP = 5; 1739 enum SIGVTALRM = 26; 1740 enum SIGXCPU = 24; 1741 enum SIGXFSZ = 25; 1742 } 1743 else version (IBMZ_Any) 1744 { 1745 enum SIGPOLL = 29; 1746 enum SIGPROF = 27; 1747 enum SIGSYS = 31; 1748 enum SIGTRAP = 5; 1749 enum SIGVTALRM = 26; 1750 enum SIGXCPU = 24; 1751 enum SIGXFSZ = 25; 1752 } 1753 else 1754 static assert(0, "unimplemented"); 1755 1756 version (MIPS_Any) 1757 { 1758 enum SA_ONSTACK = 0x08000000; 1759 enum SA_RESETHAND = 0x80000000; 1760 enum SA_RESTART = 0x10000000; 1761 enum SA_SIGINFO = 8; 1762 enum SA_NOCLDWAIT = 0x10000; 1763 enum SA_NODEFER = 0x40000000; 1764 } 1765 else 1766 { 1767 enum SA_ONSTACK = 0x08000000; 1768 enum SA_RESETHAND = 0x80000000; 1769 enum SA_RESTART = 0x10000000; 1770 enum SA_SIGINFO = 4; 1771 enum SA_NOCLDWAIT = 2; 1772 enum SA_NODEFER = 0x40000000; 1773 } 1774 1775 enum SA_NOMASK = SA_NODEFER; 1776 enum SA_ONESHOT = SA_RESETHAND; 1777 enum SA_STACK = SA_ONSTACK; 1778 1779 enum 1780 { 1781 ILL_ILLOPC = 1, 1782 ILL_ILLOPN, 1783 ILL_ILLADR, 1784 ILL_ILLTRP, 1785 ILL_PRVOPC, 1786 ILL_PRVREG, 1787 ILL_COPROC, 1788 ILL_BADSTK 1789 } 1790 1791 enum 1792 { 1793 FPE_INTDIV = 1, 1794 FPE_INTOVF, 1795 FPE_FLTDIV, 1796 FPE_FLTOVF, 1797 FPE_FLTUND, 1798 FPE_FLTRES, 1799 FPE_FLTINV, 1800 FPE_FLTSUB 1801 } 1802 1803 enum 1804 { 1805 SEGV_MAPERR = 1, 1806 SEGV_ACCERR 1807 } 1808 1809 enum 1810 { 1811 BUS_ADRALN = 1, 1812 BUS_ADRERR, 1813 BUS_OBJERR 1814 } 1815 1816 enum 1817 { 1818 TRAP_BRKPT = 1, 1819 TRAP_TRACE 1820 } 1821 1822 enum 1823 { 1824 CLD_EXITED = 1, 1825 CLD_KILLED, 1826 CLD_DUMPED, 1827 CLD_TRAPPED, 1828 CLD_STOPPED, 1829 CLD_CONTINUED 1830 } 1831 1832 enum 1833 { 1834 POLL_IN = 1, 1835 POLL_OUT, 1836 POLL_MSG, 1837 POLL_ERR, 1838 POLL_PRI, 1839 POLL_HUP 1840 } 1841 } 1842 else version (Darwin) 1843 { 1844 enum SIGPOLL = 7; 1845 enum SIGPROF = 27; 1846 enum SIGSYS = 12; 1847 enum SIGTRAP = 5; 1848 enum SIGVTALRM = 26; 1849 enum SIGXCPU = 24; 1850 enum SIGXFSZ = 25; 1851 1852 enum SA_ONSTACK = 0x0001; 1853 enum SA_RESETHAND = 0x0004; 1854 enum SA_RESTART = 0x0002; 1855 enum SA_SIGINFO = 0x0040; 1856 enum SA_NOCLDWAIT = 0x0020; 1857 enum SA_NODEFER = 0x0010; 1858 1859 enum ILL_ILLOPC = 1; 1860 enum ILL_ILLOPN = 4; 1861 enum ILL_ILLADR = 5; 1862 enum ILL_ILLTRP = 2; 1863 enum ILL_PRVOPC = 3; 1864 enum ILL_PRVREG = 6; 1865 enum ILL_COPROC = 7; 1866 enum ILL_BADSTK = 8; 1867 1868 enum FPE_INTDIV = 7; 1869 enum FPE_INTOVF = 8; 1870 enum FPE_FLTDIV = 1; 1871 enum FPE_FLTOVF = 2; 1872 enum FPE_FLTUND = 3; 1873 enum FPE_FLTRES = 4; 1874 enum FPE_FLTINV = 5; 1875 enum FPE_FLTSUB = 6; 1876 1877 enum 1878 { 1879 SEGV_MAPERR = 1, 1880 SEGV_ACCERR 1881 } 1882 1883 enum 1884 { 1885 BUS_ADRALN = 1, 1886 BUS_ADRERR, 1887 BUS_OBJERR 1888 } 1889 1890 enum 1891 { 1892 TRAP_BRKPT = 1, 1893 TRAP_TRACE 1894 } 1895 1896 enum 1897 { 1898 CLD_EXITED = 1, 1899 CLD_KILLED, 1900 CLD_DUMPED, 1901 CLD_TRAPPED, 1902 CLD_STOPPED, 1903 CLD_CONTINUED 1904 } 1905 1906 enum 1907 { 1908 POLL_IN = 1, 1909 POLL_OUT, 1910 POLL_MSG, 1911 POLL_ERR, 1912 POLL_PRI, 1913 POLL_HUP 1914 } 1915 } 1916 else version (FreeBSD) 1917 { 1918 // No SIGPOLL on *BSD 1919 enum SIGPROF = 27; 1920 enum SIGSYS = 12; 1921 enum SIGTRAP = 5; 1922 enum SIGVTALRM = 26; 1923 enum SIGXCPU = 24; 1924 enum SIGXFSZ = 25; 1925 1926 enum 1927 { 1928 SA_ONSTACK = 0x0001, 1929 SA_RESTART = 0x0002, 1930 SA_RESETHAND = 0x0004, 1931 SA_NODEFER = 0x0010, 1932 SA_NOCLDWAIT = 0x0020, 1933 SA_SIGINFO = 0x0040, 1934 } 1935 1936 enum 1937 { 1938 ILL_ILLOPC = 1, 1939 ILL_ILLOPN, 1940 ILL_ILLADR, 1941 ILL_ILLTRP, 1942 ILL_PRVOPC, 1943 ILL_PRVREG, 1944 ILL_COPROC, 1945 ILL_BADSTK, 1946 } 1947 1948 enum 1949 { 1950 BUS_ADRALN = 1, 1951 BUS_ADRERR, 1952 BUS_OBJERR, 1953 } 1954 1955 enum 1956 { 1957 SEGV_MAPERR = 1, 1958 SEGV_ACCERR, 1959 } 1960 1961 enum 1962 { 1963 FPE_INTOVF = 1, 1964 FPE_INTDIV, 1965 FPE_FLTDIV, 1966 FPE_FLTOVF, 1967 FPE_FLTUND, 1968 FPE_FLTRES, 1969 FPE_FLTINV, 1970 FPE_FLTSUB, 1971 } 1972 1973 enum 1974 { 1975 TRAP_BRKPT = 1, 1976 TRAP_TRACE, 1977 } 1978 1979 enum 1980 { 1981 CLD_EXITED = 1, 1982 CLD_KILLED, 1983 CLD_DUMPED, 1984 CLD_TRAPPED, 1985 CLD_STOPPED, 1986 CLD_CONTINUED, 1987 } 1988 1989 enum 1990 { 1991 POLL_IN = 1, 1992 POLL_OUT, 1993 POLL_MSG, 1994 POLL_ERR, 1995 POLL_PRI, 1996 POLL_HUP, 1997 } 1998 } 1999 else version (NetBSD) 2000 { 2001 // No SIGPOLL on *BSD 2002 enum SIGPROF = 27; 2003 enum SIGSYS = 12; 2004 enum SIGTRAP = 5; 2005 enum SIGVTALRM = 26; 2006 enum SIGXCPU = 24; 2007 enum SIGXFSZ = 25; 2008 2009 enum 2010 { 2011 SA_ONSTACK = 0x0001, 2012 SA_RESTART = 0x0002, 2013 SA_RESETHAND = 0x0004, 2014 SA_NODEFER = 0x0010, 2015 SA_NOCLDWAIT = 0x0020, 2016 SA_SIGINFO = 0x0040, 2017 } 2018 2019 enum 2020 { 2021 ILL_ILLOPC = 1, 2022 ILL_ILLOPN, 2023 ILL_ILLADR, 2024 ILL_ILLTRP, 2025 ILL_PRVOPC, 2026 ILL_PRVREG, 2027 ILL_COPROC, 2028 ILL_BADSTK, 2029 } 2030 2031 enum 2032 { 2033 BUS_ADRALN = 1, 2034 BUS_ADRERR, 2035 BUS_OBJERR, 2036 } 2037 2038 enum 2039 { 2040 SEGV_MAPERR = 1, 2041 SEGV_ACCERR, 2042 } 2043 2044 enum 2045 { 2046 FPE_INTOVF = 1, 2047 FPE_INTDIV, 2048 FPE_FLTDIV, 2049 FPE_FLTOVF, 2050 FPE_FLTUND, 2051 FPE_FLTRES, 2052 FPE_FLTINV, 2053 FPE_FLTSUB, 2054 } 2055 2056 enum 2057 { 2058 TRAP_BRKPT = 1, 2059 TRAP_TRACE, 2060 } 2061 2062 enum 2063 { 2064 CLD_EXITED = 1, 2065 CLD_KILLED, 2066 CLD_DUMPED, 2067 CLD_TRAPPED, 2068 CLD_STOPPED, 2069 CLD_CONTINUED, 2070 } 2071 2072 enum 2073 { 2074 POLL_IN = 1, 2075 POLL_OUT, 2076 POLL_MSG, 2077 POLL_ERR, 2078 POLL_PRI, 2079 POLL_HUP, 2080 } 2081 } 2082 else version (OpenBSD) 2083 { 2084 // No SIGPOLL on *BSD 2085 enum SIGPROF = 27; 2086 enum SIGSYS = 12; 2087 enum SIGTRAP = 5; 2088 enum SIGVTALRM = 26; 2089 enum SIGXCPU = 24; 2090 enum SIGXFSZ = 25; 2091 2092 enum 2093 { 2094 SA_ONSTACK = 0x0001, 2095 SA_RESTART = 0x0002, 2096 SA_RESETHAND = 0x0004, 2097 SA_NODEFER = 0x0010, 2098 SA_NOCLDWAIT = 0x0020, 2099 SA_SIGINFO = 0x0040, 2100 } 2101 2102 enum 2103 { 2104 ILL_ILLOPC = 1, 2105 ILL_ILLOPN, 2106 ILL_ILLADR, 2107 ILL_ILLTRP, 2108 ILL_PRVOPC, 2109 ILL_PRVREG, 2110 ILL_COPROC, 2111 ILL_BADSTK, 2112 NSIGILL = ILL_BADSTK, 2113 } 2114 2115 enum 2116 { 2117 BUS_ADRALN = 1, 2118 BUS_ADRERR, 2119 BUS_OBJERR, 2120 NSIGBUS = BUS_OBJERR, 2121 } 2122 2123 enum 2124 { 2125 SEGV_MAPERR = 1, 2126 SEGV_ACCERR, 2127 NSIGSEGV = SEGV_ACCERR, 2128 } 2129 2130 enum 2131 { 2132 FPE_INTDIV = 1, 2133 FPE_INTOVF, 2134 FPE_FLTDIV, 2135 FPE_FLTOVF, 2136 FPE_FLTUND, 2137 FPE_FLTRES, 2138 FPE_FLTINV, 2139 FPE_FLTSUB, 2140 NSIGFPE = FPE_FLTSUB, 2141 } 2142 2143 enum 2144 { 2145 TRAP_BRKPT = 1, 2146 TRAP_TRACE, 2147 NSIGTRAP = TRAP_TRACE, 2148 } 2149 2150 enum 2151 { 2152 CLD_EXITED = 1, 2153 CLD_KILLED, 2154 CLD_DUMPED, 2155 CLD_TRAPPED, 2156 CLD_STOPPED, 2157 CLD_CONTINUED, 2158 NSIGCLD = CLD_CONTINUED, 2159 } 2160 2161 enum 2162 { 2163 POLL_IN = 1, 2164 POLL_OUT, 2165 POLL_MSG, 2166 POLL_ERR, 2167 POLL_PRI, 2168 POLL_HUP, 2169 NSIGPOLL = POLL_HUP, 2170 } 2171 } 2172 else version (DragonFlyBSD) 2173 { 2174 // No SIGPOLL on *BSD 2175 enum SIGPROF = 27; 2176 enum SIGSYS = 12; 2177 enum SIGTRAP = 5; 2178 enum SIGVTALRM = 26; 2179 enum SIGXCPU = 24; 2180 enum SIGXFSZ = 25; 2181 2182 enum 2183 { 2184 SA_ONSTACK = 0x0001, 2185 SA_RESTART = 0x0002, 2186 SA_RESETHAND = 0x0004, 2187 SA_NODEFER = 0x0010, 2188 SA_NOCLDWAIT = 0x0020, 2189 SA_SIGINFO = 0x0040, 2190 } 2191 2192 enum 2193 { 2194 ILL_ILLOPC = 1, 2195 ILL_ILLOPN, 2196 ILL_ILLADR, 2197 ILL_ILLTRP, 2198 ILL_PRVOPC, 2199 ILL_PRVREG, 2200 ILL_COPROC, 2201 ILL_BADSTK, 2202 } 2203 2204 enum 2205 { 2206 BUS_ADRALN = 1, 2207 BUS_ADRERR, 2208 BUS_OBJERR, 2209 } 2210 2211 enum 2212 { 2213 SEGV_MAPERR = 1, 2214 SEGV_ACCERR, 2215 } 2216 2217 enum 2218 { 2219 FPE_INTOVF = 1, 2220 FPE_INTDIV, 2221 FPE_FLTDIV, 2222 FPE_FLTOVF, 2223 FPE_FLTUND, 2224 FPE_FLTRES, 2225 FPE_FLTINV, 2226 FPE_FLTSUB, 2227 } 2228 2229 enum 2230 { 2231 TRAP_BRKPT = 1, 2232 TRAP_TRACE, 2233 } 2234 2235 enum 2236 { 2237 CLD_EXITED = 1, 2238 CLD_KILLED, 2239 CLD_DUMPED, 2240 CLD_TRAPPED, 2241 CLD_STOPPED, 2242 CLD_CONTINUED, 2243 } 2244 2245 enum 2246 { 2247 POLL_IN = 1, 2248 POLL_OUT, 2249 POLL_MSG, 2250 POLL_ERR, 2251 POLL_PRI, 2252 POLL_HUP, 2253 } 2254 } 2255 else version (Solaris) 2256 { 2257 enum SIGPOLL = 22; 2258 enum SIGIO = SIGPOLL; 2259 enum SIGPROF = 29; 2260 enum SIGSYS = 12; 2261 enum SIGTRAP = 5; 2262 enum SIGVTALRM = 28; 2263 enum SIGXCPU = 30; 2264 enum SIGXFSZ = 31; 2265 2266 enum 2267 { 2268 SA_ONSTACK = 0x00001, 2269 SA_RESTART = 0x00004, 2270 SA_RESETHAND = 0x00002, 2271 SA_NODEFER = 0x00010, 2272 SA_NOCLDWAIT = 0x10000, 2273 SA_SIGINFO = 0x00008, 2274 } 2275 2276 enum 2277 { 2278 ILL_ILLOPC = 1, 2279 ILL_ILLOPN, 2280 ILL_ILLADR, 2281 ILL_ILLTRP, 2282 ILL_PRVOPC, 2283 ILL_PRVREG, 2284 ILL_COPROC, 2285 ILL_BADSTK, 2286 } 2287 2288 enum 2289 { 2290 BUS_ADRALN = 1, 2291 BUS_ADRERR, 2292 BUS_OBJERR, 2293 } 2294 2295 enum 2296 { 2297 SEGV_MAPERR = 1, 2298 SEGV_ACCERR, 2299 } 2300 2301 enum 2302 { 2303 FPE_INTDIV = 1, 2304 FPE_INTOVF, 2305 FPE_FLTDIV, 2306 FPE_FLTOVF, 2307 FPE_FLTUND, 2308 FPE_FLTRES, 2309 FPE_FLTINV, 2310 FPE_FLTSUB, 2311 FPE_FLTDEN, 2312 } 2313 2314 enum 2315 { 2316 TRAP_BRKPT = 1, 2317 TRAP_TRACE, 2318 TRAP_RWATCH, 2319 TRAP_WWATCH, 2320 TRAP_XWATCH, 2321 TRAP_DTRACE, 2322 } 2323 2324 enum 2325 { 2326 CLD_EXITED = 1, 2327 CLD_KILLED, 2328 CLD_DUMPED, 2329 CLD_TRAPPED, 2330 CLD_STOPPED, 2331 CLD_CONTINUED, 2332 } 2333 2334 enum 2335 { 2336 POLL_IN = 1, 2337 POLL_OUT, 2338 POLL_MSG, 2339 POLL_ERR, 2340 POLL_PRI, 2341 POLL_HUP, 2342 } 2343 } 2344 else 2345 { 2346 static assert(false, "Unsupported platform"); 2347 } 2348 2349 /* 2350 SS_ONSTACK 2351 SS_DISABLE 2352 MINSIGSTKSZ 2353 SIGSTKSZ 2354 2355 ucontext_t // from ucontext 2356 mcontext_t // from ucontext 2357 2358 struct stack_t 2359 { 2360 void* ss_sp; 2361 size_t ss_size; 2362 int ss_flags; 2363 } 2364 2365 struct sigstack 2366 { 2367 int ss_onstack; 2368 void* ss_sp; 2369 } 2370 2371 sigfn_t bsd_signal(int sig, sigfn_t func); 2372 sigfn_t sigset(int sig, sigfn_t func); 2373 2374 int killpg(pid_t, int); 2375 int sigaltstack(const scope stack_t*, stack_t*); 2376 int sighold(int); 2377 int sigignore(int); 2378 int siginterrupt(int, int); 2379 int sigpause(int); 2380 int sigrelse(int); 2381 */ 2382 2383 version (CRuntime_Glibc) 2384 { 2385 enum SS_ONSTACK = 1; 2386 enum SS_DISABLE = 2; 2387 enum MINSIGSTKSZ = 2048; 2388 enum SIGSTKSZ = 8192; 2389 2390 //ucontext_t (defined in core.sys.posix.ucontext) 2391 //mcontext_t (defined in core.sys.posix.ucontext) 2392 2393 struct stack_t 2394 { 2395 void* ss_sp; 2396 int ss_flags; 2397 size_t ss_size; 2398 } 2399 2400 struct sigstack 2401 { 2402 void* ss_sp; 2403 int ss_onstack; 2404 } 2405 2406 sigfn_t bsd_signal(int sig, sigfn_t func); 2407 sigfn_t sigset(int sig, sigfn_t func); 2408 2409 nothrow: 2410 @nogc: 2411 sigfn_t2 bsd_signal(int sig, sigfn_t2 func); 2412 sigfn_t2 sigset(int sig, sigfn_t2 func); 2413 2414 int killpg(pid_t, int); 2415 int sigaltstack(const scope stack_t*, stack_t*); 2416 int sighold(int); 2417 int sigignore(int); 2418 int siginterrupt(int, int); 2419 int sigpause(int); 2420 int sigrelse(int); 2421 } 2422 else version (Darwin) 2423 { 2424 enum SS_ONSTACK = 0x0001; 2425 enum SS_DISABLE = 0x0004; 2426 enum MINSIGSTKSZ = 32768; 2427 enum SIGSTKSZ = 131072; 2428 2429 //ucontext_t (defined in core.sys.posix.ucontext) 2430 //mcontext_t (defined in core.sys.posix.ucontext) 2431 2432 struct stack_t 2433 { 2434 void* ss_sp; 2435 size_t ss_size; 2436 int ss_flags; 2437 } 2438 2439 struct sigstack 2440 { 2441 void* ss_sp; 2442 int ss_onstack; 2443 } 2444 2445 sigfn_t bsd_signal(int sig, sigfn_t func); 2446 sigfn_t sigset(int sig, sigfn_t func); 2447 2448 nothrow: 2449 @nogc: 2450 sigfn_t2 bsd_signal(int sig, sigfn_t2 func); 2451 sigfn_t2 sigset(int sig, sigfn_t2 func); 2452 2453 int killpg(pid_t, int); 2454 int sigaltstack(const scope stack_t*, stack_t*); 2455 int sighold(int); 2456 int sigignore(int); 2457 int siginterrupt(int, int); 2458 int sigpause(int); 2459 int sigrelse(int); 2460 } 2461 else version (FreeBSD) 2462 { 2463 enum 2464 { 2465 SS_ONSTACK = 0x0001, 2466 SS_DISABLE = 0x0004, 2467 } 2468 2469 enum MINSIGSTKSZ = 512 * 4; 2470 enum SIGSTKSZ = (MINSIGSTKSZ + 32768); 2471 2472 //ucontext_t (defined in core.sys.posix.ucontext) 2473 //mcontext_t (defined in core.sys.posix.ucontext) 2474 2475 struct stack_t 2476 { 2477 void* ss_sp; 2478 size_t ss_size; 2479 int ss_flags; 2480 } 2481 2482 struct sigstack 2483 { 2484 void* ss_sp; 2485 int ss_onstack; 2486 } 2487 2488 //sigfn_t bsd_signal(int sig, sigfn_t func); 2489 sigfn_t sigset(int sig, sigfn_t func); 2490 2491 nothrow: 2492 @nogc: 2493 //sigfn_t2 bsd_signal(int sig, sigfn_t2 func); 2494 sigfn_t2 sigset(int sig, sigfn_t2 func); 2495 2496 int killpg(pid_t, int); 2497 int sigaltstack(const scope stack_t*, stack_t*); 2498 int sighold(int); 2499 int sigignore(int); 2500 int siginterrupt(int, int); 2501 int sigpause(int); 2502 int sigrelse(int); 2503 } 2504 else version (NetBSD) 2505 { 2506 enum 2507 { 2508 SS_ONSTACK = 0x0001, 2509 SS_DISABLE = 0x0004, 2510 } 2511 2512 enum MINSIGSTKSZ = 8192; 2513 enum SIGSTKSZ = (MINSIGSTKSZ + 32768); 2514 2515 //ucontext_t (defined in core.sys.posix.ucontext) 2516 //mcontext_t (defined in core.sys.posix.ucontext) 2517 2518 struct stack_t 2519 { 2520 void* ss_sp; 2521 size_t ss_size; 2522 int ss_flags; 2523 } 2524 2525 struct sigstack 2526 { 2527 void* ss_sp; 2528 int ss_onstack; 2529 } 2530 2531 //sigfn_t bsd_signal(int sig, sigfn_t func); 2532 sigfn_t sigset(int sig, sigfn_t func); 2533 2534 nothrow: 2535 @nogc: 2536 //sigfn_t2 bsd_signal(int sig, sigfn_t2 func); 2537 sigfn_t2 sigset(int sig, sigfn_t2 func); 2538 2539 int killpg(pid_t, int); 2540 int sigaltstack(const scope stack_t*, stack_t*); 2541 int sighold(int); 2542 int sigignore(int); 2543 int siginterrupt(int, int); 2544 int sigpause(int); 2545 int sigrelse(int); 2546 } 2547 else version (OpenBSD) 2548 { 2549 enum 2550 { 2551 SS_ONSTACK = 0x0001, 2552 SS_DISABLE = 0x0004, 2553 } 2554 2555 enum MINSIGSTKSZ = 8192; 2556 enum SIGSTKSZ = (MINSIGSTKSZ + 32768); 2557 2558 //ucontext_t (defined in core.sys.posix.ucontext) 2559 //mcontext_t (defined in core.sys.posix.ucontext) 2560 2561 struct stack_t 2562 { 2563 void* ss_sp; 2564 size_t ss_size; 2565 int ss_flags; 2566 } 2567 2568 nothrow: 2569 @nogc: 2570 int killpg(pid_t, int); 2571 int sigaltstack(const scope stack_t*, stack_t*); 2572 int siginterrupt(int, int); 2573 int sigpause(int); 2574 } 2575 else version (DragonFlyBSD) 2576 { 2577 enum 2578 { 2579 SS_ONSTACK = 0x0001, 2580 SS_DISABLE = 0x0004, 2581 } 2582 2583 enum MINSIGSTKSZ = 8192; 2584 enum SIGSTKSZ = (MINSIGSTKSZ + 32768); 2585 2586 //ucontext_t (defined in core.sys.posix.ucontext) 2587 //mcontext_t (defined in core.sys.posix.ucontext) 2588 2589 struct stack_t 2590 { 2591 void* ss_sp; 2592 size_t ss_size; 2593 int ss_flags; 2594 } 2595 2596 struct sigstack 2597 { 2598 void* ss_sp; 2599 int ss_onstack; 2600 } 2601 2602 //sigfn_t bsd_signal(int sig, sigfn_t func); 2603 sigfn_t sigset(int sig, sigfn_t func); 2604 2605 nothrow: 2606 @nogc: 2607 //sigfn_t2 bsd_signal(int sig, sigfn_t2 func); 2608 sigfn_t2 sigset(int sig, sigfn_t2 func); 2609 2610 int killpg(pid_t, int); 2611 int sigaltstack(const scope stack_t*, stack_t*); 2612 int sighold(int); 2613 int sigignore(int); 2614 int siginterrupt(int, int); 2615 int sigpause(int); 2616 int sigrelse(int); 2617 } 2618 else version (Solaris) 2619 { 2620 enum 2621 { 2622 SS_ONSTACK = 0x0001, 2623 SS_DISABLE = 0x0002, 2624 } 2625 2626 enum MINSIGSTKSZ = 2048; 2627 enum SIGSTKSZ = 8192; 2628 2629 struct stack_t 2630 { 2631 void* ss_sp; 2632 size_t ss_size; 2633 int ss_flags; 2634 } 2635 2636 struct sigstack 2637 { 2638 void* ss_sp; 2639 int ss_onstack; 2640 } 2641 2642 sigfn_t sigset(int sig, sigfn_t func); 2643 2644 nothrow: 2645 @nogc: 2646 sigfn_t2 sigset(int sig, sigfn_t2 func); 2647 2648 int killpg(pid_t, int); 2649 int sigaltstack(const scope stack_t*, stack_t*); 2650 int sighold(int); 2651 int sigignore(int); 2652 int siginterrupt(int, int); 2653 int sigpause(int); 2654 int sigrelse(int); 2655 } 2656 else version (CRuntime_Bionic) 2657 { 2658 enum SS_ONSTACK = 1; 2659 enum SS_DISABLE = 2; 2660 enum MINSIGSTKSZ = 2048; 2661 enum SIGSTKSZ = 8192; 2662 2663 struct stack_t 2664 { 2665 void* ss_sp; 2666 int ss_flags; 2667 size_t ss_size; 2668 } 2669 2670 sigfn_t bsd_signal(int, sigfn_t); 2671 2672 nothrow: 2673 @nogc: 2674 sigfn_t2 bsd_signal(int, sigfn_t2); 2675 2676 int killpg(int, int); 2677 int sigaltstack(const scope stack_t*, stack_t*); 2678 int siginterrupt(int, int); 2679 } 2680 else version (CRuntime_Musl) 2681 { 2682 enum SS_ONSTACK = 1; 2683 enum SS_DISABLE = 2; 2684 2685 version (ARM) 2686 { 2687 enum MINSIGSTKSZ = 2048; 2688 enum SIGSTKSZ = 8192; 2689 } 2690 else version (AArch64) 2691 { 2692 enum MINSIGSTKSZ = 6144; 2693 enum SIGSTKSZ = 12288; 2694 } 2695 else version (IBMZ_Any) 2696 { 2697 enum MINSIGSTKSZ = 4096; 2698 enum SIGSTKSZ = 10240; 2699 } 2700 else version (MIPS_Any) 2701 { 2702 enum MINSIGSTKSZ = 2048; 2703 enum SIGSTKSZ = 8192; 2704 } 2705 else version (PPC_Any) 2706 { 2707 enum MINSIGSTKSZ = 4096; 2708 enum SIGSTKSZ = 10240; 2709 } 2710 else version (X86_Any) 2711 { 2712 enum MINSIGSTKSZ = 2048; 2713 enum SIGSTKSZ = 8192; 2714 } 2715 else 2716 static assert(0, "unimplemented"); 2717 2718 //ucontext_t (defined in core.sys.posix.ucontext) 2719 //mcontext_t (defined in core.sys.posix.ucontext) 2720 2721 version (MIPS_Any) 2722 { 2723 struct stack_t 2724 { 2725 void* ss_sp; 2726 size_t ss_size; 2727 int ss_flags; 2728 } 2729 } 2730 else 2731 { 2732 struct stack_t 2733 { 2734 void* ss_sp; 2735 int ss_flags; 2736 size_t ss_size; 2737 } 2738 } 2739 2740 sigfn_t bsd_signal(int sig, sigfn_t func); 2741 sigfn_t sigset(int sig, sigfn_t func); 2742 2743 nothrow: 2744 @nogc: 2745 sigfn_t2 bsd_signal(int sig, sigfn_t2 func); 2746 sigfn_t2 sigset(int sig, sigfn_t2 func); 2747 2748 int killpg(pid_t, int); 2749 int sigaltstack(const scope stack_t*, stack_t*); 2750 int sighold(int); 2751 int sigignore(int); 2752 int siginterrupt(int, int); 2753 int sigpause(int); 2754 int sigrelse(int); 2755 } 2756 else version (CRuntime_UClibc) 2757 { 2758 enum SS_ONSTACK = 1; 2759 enum SS_DISABLE = 2; 2760 enum MINSIGSTKSZ = 2048; 2761 enum SIGSTKSZ = 8192; 2762 2763 version (MIPS32) 2764 { 2765 struct stack_t 2766 { 2767 void *ss_sp; 2768 size_t ss_size; 2769 int ss_flags; 2770 } 2771 } 2772 else 2773 { 2774 struct stack_t 2775 { 2776 void* ss_sp; 2777 int ss_flags; 2778 size_t ss_size; 2779 } 2780 } 2781 2782 struct sigstack 2783 { 2784 void* ss_sp; 2785 int ss_onstack; 2786 } 2787 2788 sigfn_t sigset(int sig, sigfn_t func); 2789 2790 nothrow: 2791 @nogc: 2792 sigfn_t2 sigset(int sig, sigfn_t2 func); 2793 2794 int killpg(pid_t, int); 2795 int sigaltstack(const scope stack_t*, stack_t*); 2796 int sighold(int); 2797 int sigignore(int); 2798 int siginterrupt(int, int); 2799 int sigpause(int); 2800 int sigrelse(int); 2801 } 2802 else 2803 { 2804 static assert(false, "Unsupported platform"); 2805 } 2806 2807 // 2808 // Realtime Signals (RTS) 2809 // 2810 /* 2811 struct sigevent 2812 { 2813 int sigev_notify; 2814 int sigev_signo; 2815 sigval sigev_value; 2816 void(*)(sigval) sigev_notify_function; 2817 pthread_attr_t* sigev_notify_attributes; 2818 } 2819 */ 2820 2821 nothrow: 2822 @nogc: 2823 2824 version (linux) 2825 { 2826 private enum __SIGEV_MAX_SIZE = 64; 2827 2828 static if ( __WORDSIZE == 64 ) 2829 { 2830 private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 4); 2831 } 2832 else 2833 { 2834 private enum __SIGEV_PAD_SIZE = ((__SIGEV_MAX_SIZE / int.sizeof) - 3); 2835 } 2836 2837 struct sigevent 2838 { 2839 sigval sigev_value; 2840 int sigev_signo; 2841 int sigev_notify; 2842 2843 union 2844 { 2845 int[__SIGEV_PAD_SIZE] _pad; 2846 pid_t _tid; 2847 2848 struct 2849 { 2850 void function(sigval) sigev_notify_function; 2851 void* sigev_notify_attributes; 2852 } 2853 } 2854 } 2855 } 2856 else version (FreeBSD) 2857 { 2858 struct sigevent 2859 { 2860 int sigev_notify; 2861 int sigev_signo; 2862 sigval sigev_value; 2863 union 2864 { 2865 lwpid_t _threadid; 2866 struct 2867 { 2868 void function(sigval) sigev_notify_function; 2869 void* sigev_notify_attributes; 2870 } 2871 c_long[8] __spare__; 2872 } 2873 } 2874 } 2875 else version (NetBSD) 2876 { 2877 struct sigevent 2878 { 2879 int sigev_notify; 2880 int sigev_signo; 2881 sigval sigev_value; 2882 void function(sigval) sigev_notify_function; 2883 void /* pthread_attr_t */*sigev_notify_attributes; 2884 } 2885 } 2886 else version (OpenBSD) 2887 { 2888 // OpenBSD does not implement sigevent. 2889 alias sigevent = void; 2890 } 2891 else version (DragonFlyBSD) 2892 { 2893 union _sigev_un_t 2894 { 2895 int sigev_signo; 2896 int sigev_notify_kqueue; 2897 void /*pthread_attr_t*/ * sigev_notify_attributes; 2898 } 2899 union _sigval_t 2900 { 2901 int sival_int; 2902 void * sival_ptr; 2903 int sigval_int; 2904 void * sigval_ptr; 2905 } 2906 struct sigevent 2907 { 2908 int sigev_notify; 2909 _sigev_un_t sigev_un; 2910 _sigval_t sigev_value; 2911 void function(_sigval_t) sigev_notify_function; 2912 } 2913 } 2914 else version (Darwin) 2915 { 2916 struct sigevent 2917 { 2918 int sigev_notify; 2919 int sigev_signo; 2920 sigval sigev_value; 2921 void function(sigval) sigev_notify_function; 2922 pthread_attr_t* sigev_notify_attributes; 2923 } 2924 } 2925 else version (Solaris) 2926 { 2927 struct sigevent 2928 { 2929 int sigev_notify; 2930 int sigev_signo; 2931 sigval sigev_value; 2932 void function(sigval) sigev_notify_function; 2933 pthread_attr_t* sigev_notify_attributes; 2934 int __sigev_pad2; 2935 } 2936 } 2937 else 2938 { 2939 static assert(false, "Unsupported platform"); 2940 } 2941 2942 /* 2943 int sigqueue(pid_t, int, const sigval); 2944 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2945 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2946 */ 2947 2948 nothrow: 2949 @nogc: 2950 2951 version (CRuntime_Glibc) 2952 { 2953 int sigqueue(pid_t, int, const sigval); 2954 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2955 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2956 } 2957 else version (FreeBSD) 2958 { 2959 int sigqueue(pid_t, int, const sigval); 2960 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2961 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2962 } 2963 else version (NetBSD) 2964 { 2965 int sigqueue(pid_t, int, const sigval); 2966 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2967 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2968 } 2969 else version (OpenBSD) 2970 { 2971 } 2972 else version (DragonFlyBSD) 2973 { 2974 int sigqueue(pid_t, int, const sigval); 2975 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2976 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2977 } 2978 else version (Darwin) 2979 { 2980 } 2981 else version (Solaris) 2982 { 2983 int sigqueue(pid_t, int, const sigval); 2984 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2985 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2986 } 2987 else version (CRuntime_Bionic) 2988 { 2989 } 2990 else version (CRuntime_Musl) 2991 { 2992 int sigqueue(pid_t, int, const sigval); 2993 pragma(mangle, muslRedirTime64Mangle!("sigtimedwait", "__sigtimedwait_time64")) 2994 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 2995 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 2996 } 2997 else version (CRuntime_UClibc) 2998 { 2999 int sigqueue(pid_t, int, const sigval); 3000 int sigtimedwait(const scope sigset_t*, siginfo_t*, const scope timespec*); 3001 int sigwaitinfo(const scope sigset_t*, siginfo_t*); 3002 } 3003 else 3004 { 3005 static assert(false, "Unsupported platform"); 3006 } 3007 3008 // 3009 // Threads (THR) 3010 // 3011 /* 3012 int pthread_kill(pthread_t, int); 3013 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3014 */ 3015 3016 version (CRuntime_Glibc) 3017 { 3018 int pthread_kill(pthread_t, int); 3019 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3020 } 3021 else version (Darwin) 3022 { 3023 int pthread_kill(pthread_t, int); 3024 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3025 } 3026 else version (FreeBSD) 3027 { 3028 int pthread_kill(pthread_t, int); 3029 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3030 } 3031 else version (NetBSD) 3032 { 3033 int pthread_kill(pthread_t, int); 3034 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3035 } 3036 else version (OpenBSD) 3037 { 3038 int pthread_kill(pthread_t, int); 3039 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3040 } 3041 else version (DragonFlyBSD) 3042 { 3043 int pthread_kill(pthread_t, int); 3044 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3045 } 3046 else version (Solaris) 3047 { 3048 int pthread_kill(pthread_t, int); 3049 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3050 } 3051 else version (CRuntime_Bionic) 3052 { 3053 int pthread_kill(pthread_t, int); 3054 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3055 } 3056 else version (CRuntime_Musl) 3057 { 3058 int pthread_kill(pthread_t, int); 3059 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3060 } 3061 else version (CRuntime_UClibc) 3062 { 3063 int pthread_kill(pthread_t, int); 3064 int pthread_sigmask(int, const scope sigset_t*, sigset_t*); 3065 int pthread_sigqueue(pthread_t, int, sigval); 3066 } 3067 else 3068 { 3069 static assert(false, "Unsupported platform"); 3070 }