signal.c

   1 /**********************************************************************
   2
   3   signal.c -
   4
   5   $Author$
   6   created at: Tue Dec 20 10:13:44 JST 1994
   7
   8   Copyright (C) 1993-2007 Yukihiro Matsumoto
   9   Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
  10   Copyright (C) 2000  Information-technology Promotion Agency, Japan
  11
  12 **********************************************************************/
  13
  14 #include "ruby/internal/config.h"
  15
  16 #include <errno.h>
  17 #include <signal.h>
  18 #include <stdio.h>
  19
  20 #ifdef HAVE_UNISTD_H
  21 # include <unistd.h>
  22 #endif
  23
  24 #ifdef HAVE_SYS_UIO_H
  25 # include <sys/uio.h>
  26 #endif
  27
  28 #ifdef HAVE_UCONTEXT_H
  29 # include <ucontext.h>
  30 #endif
  31
  32 #ifdef HAVE_PTHREAD_H
  33 # include <pthread.h>
  34 #endif
  35
  36 #include "debug_counter.h"
  37 #include "eval_intern.h"
  38 #include "internal.h"
  39 #include "internal/error.h"
  40 #include "internal/eval.h"
  41 #include "internal/sanitizers.h"
  42 #include "internal/signal.h"
  43 #include "internal/string.h"
  44 #include "internal/thread.h"
  45 #include "ruby_atomic.h"
  46 #include "vm_core.h"
  47 #include "ractor_core.h"
  48
  49 #ifdef NEED_RUBY_ATOMIC_OPS
  50 rb_atomic_t
  51 ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val)
  52 {
  53     rb_atomic_t old = *ptr;
  54     *ptr = val;
  55     return old;
  56 }
  57
  58 rb_atomic_t
  59 ruby_atomic_compare_and_swap(rb_atomic_t *ptr, rb_atomic_t cmp,
  60                              rb_atomic_t newval)
  61 {
  62     rb_atomic_t old = *ptr;
  63     if (old == cmp) {
  64         *ptr = newval;
  65     }
  66     return old;
  67 }
  68 #endif
  69
  70 #define FOREACH_SIGNAL(sig, offset) \
  71     for (sig = siglist + (offset); sig < siglist + numberof(siglist); ++sig)
  72 enum { LONGEST_SIGNAME = 7 }; /* MIGRATE and RETRACT */
  73 static const struct signals {
  74     char signm[LONGEST_SIGNAME + 1];
  75     int  signo;
  76 } siglist [] = {
  77     {"EXIT", 0},
  78 #ifdef SIGHUP
  79     {"HUP", SIGHUP},
  80 #endif
  81     {"INT", SIGINT},
  82 #ifdef SIGQUIT
  83     {"QUIT", SIGQUIT},
  84 #endif
  85 #ifdef SIGILL
  86     {"ILL", SIGILL},
  87 #endif
  88 #ifdef SIGTRAP
  89     {"TRAP", SIGTRAP},
  90 #endif
  91 #ifdef SIGABRT
  92     {"ABRT", SIGABRT},
  93 #endif
  94 #ifdef SIGIOT
  95     {"IOT", SIGIOT},
  96 #endif
  97 #ifdef SIGEMT
  98     {"EMT", SIGEMT},
  99 #endif
 100 #ifdef SIGFPE
 101     {"FPE", SIGFPE},
 102 #endif
 103 #ifdef SIGKILL
 104     {"KILL", SIGKILL},
 105 #endif
 106 #ifdef SIGBUS
 107     {"BUS", SIGBUS},
 108 #endif
 109 #ifdef SIGSEGV
 110     {"SEGV", SIGSEGV},
 111 #endif
 112 #ifdef SIGSYS
 113     {"SYS", SIGSYS},
 114 #endif
 115 #ifdef SIGPIPE
 116     {"PIPE", SIGPIPE},
 117 #endif
 118 #ifdef SIGALRM
 119     {"ALRM", SIGALRM},
 120 #endif
 121 #ifdef SIGTERM
 122     {"TERM", SIGTERM},
 123 #endif
 124 #ifdef SIGURG
 125     {"URG", SIGURG},
 126 #endif
 127 #ifdef SIGSTOP
 128     {"STOP", SIGSTOP},
 129 #endif
 130 #ifdef SIGTSTP
 131     {"TSTP", SIGTSTP},
 132 #endif
 133 #ifdef SIGCONT
 134     {"CONT", SIGCONT},
 135 #endif
 136 #ifdef RUBY_SIGCHLD
 137     {"CHLD", RUBY_SIGCHLD },
 138     {"CLD", RUBY_SIGCHLD },
 139 #endif
 140 #ifdef SIGTTIN
 141     {"TTIN", SIGTTIN},
 142 #endif
 143 #ifdef SIGTTOU
 144     {"TTOU", SIGTTOU},
 145 #endif
 146 #ifdef SIGIO
 147     {"IO", SIGIO},
 148 #endif
 149 #ifdef SIGXCPU
 150     {"XCPU", SIGXCPU},
 151 #endif
 152 #ifdef SIGXFSZ
 153     {"XFSZ", SIGXFSZ},
 154 #endif
 155 #ifdef SIGVTALRM
 156     {"VTALRM", SIGVTALRM},
 157 #endif
 158 #ifdef SIGPROF
 159     {"PROF", SIGPROF},
 160 #endif
 161 #ifdef SIGWINCH
 162     {"WINCH", SIGWINCH},
 163 #endif
 164 #ifdef SIGUSR1
 165     {"USR1", SIGUSR1},
 166 #endif
 167 #ifdef SIGUSR2
 168     {"USR2", SIGUSR2},
 169 #endif
 170 #ifdef SIGLOST
 171     {"LOST", SIGLOST},
 172 #endif
 173 #ifdef SIGMSG
 174     {"MSG", SIGMSG},
 175 #endif
 176 #ifdef SIGPWR
 177     {"PWR", SIGPWR},
 178 #endif
 179 #ifdef SIGPOLL
 180     {"POLL", SIGPOLL},
 181 #endif
 182 #ifdef SIGDANGER
 183     {"DANGER", SIGDANGER},
 184 #endif
 185 #ifdef SIGMIGRATE
 186     {"MIGRATE", SIGMIGRATE},
 187 #endif
 188 #ifdef SIGPRE
 189     {"PRE", SIGPRE},
 190 #endif
 191 #ifdef SIGGRANT
 192     {"GRANT", SIGGRANT},
 193 #endif
 194 #ifdef SIGRETRACT
 195     {"RETRACT", SIGRETRACT},
 196 #endif
 197 #ifdef SIGSOUND
 198     {"SOUND", SIGSOUND},
 199 #endif
 200 #ifdef SIGINFO
 201     {"INFO", SIGINFO},
 202 #endif
 203 };
 204
 205 static const char signame_prefix[] = "SIG";
 206 static const int signame_prefix_len = 3;
 207
 208 static int
 209 signm2signo(VALUE *sig_ptr, int negative, int exit, int *prefix_ptr)
 210 {
 211     const struct signals *sigs;
 212     VALUE vsig = *sig_ptr;
 213     const char *nm;
 214     long len, nmlen;
 215     int prefix = 0;
 216
 217     if (RB_SYMBOL_P(vsig)) {
 218         *sig_ptr = vsig = rb_sym2str(vsig);
 219     }
 220     else if (!RB_TYPE_P(vsig, T_STRING)) {
 221         VALUE str = rb_check_string_type(vsig);
 222         if (NIL_P(str)) {
 223             rb_raise(rb_eArgError, "bad signal type %s",
 224                      rb_obj_classname(vsig));
 225         }
 226         *sig_ptr = vsig = str;
 227     }
 228
 229     rb_must_asciicompat(vsig);
 230     RSTRING_GETMEM(vsig, nm, len);
 231     if (memchr(nm, '\0', len)) {
 232         rb_raise(rb_eArgError, "signal name with null byte");
 233     }
 234
 235     if (len > 0 && nm[0] == '-') {
 236         if (!negative)
 237             rb_raise(rb_eArgError, "negative signal name: % "PRIsVALUE, vsig);
 238         prefix = 1;
 239     }
 240     else {
 241         negative = 0;
 242     }
 243     if (len >= prefix + signame_prefix_len) {
 244         if (memcmp(nm + prefix, signame_prefix, signame_prefix_len) == 0)
 245             prefix += signame_prefix_len;
 246     }
 247     if (len <= (long)prefix) {
 248         goto unsupported;
 249     }
 250
 251     if (prefix_ptr) *prefix_ptr = prefix;
 252     nmlen = len - prefix;
 253     nm += prefix;
 254     if (nmlen > LONGEST_SIGNAME) goto unsupported;
 255     FOREACH_SIGNAL(sigs, !exit) {
 256         if (memcmp(sigs->signm, nm, nmlen) == 0 &&
 257             sigs->signm[nmlen] == '\0') {
 258             return negative ? -sigs->signo : sigs->signo;
 259         }
 260     }
 261
 262   unsupported:
 263     if (prefix == signame_prefix_len) {
 264         prefix = 0;
 265     }
 266     else if (prefix > signame_prefix_len) {
 267         prefix -= signame_prefix_len;
 268         len -= prefix;
 269         vsig = rb_str_subseq(vsig, prefix, len);
 270         prefix = 0;
 271     }
 272     else {
 273         len -= prefix;
 274         vsig = rb_str_subseq(vsig, prefix, len);
 275         prefix = signame_prefix_len;
 276     }
 277     rb_raise(rb_eArgError, "unsupported signal '%.*s%"PRIsVALUE"'",
 278              prefix, signame_prefix, vsig);
 279     UNREACHABLE_RETURN(0);
 280 }
 281
 282 static const char*
 283 signo2signm(int no)
 284 {
 285     const struct signals *sigs;
 286
 287     FOREACH_SIGNAL(sigs, 0) {
 288         if (sigs->signo == no)
 289             return sigs->signm;
 290     }
 291     return 0;
 292 }
 293
 294 /*
 295  * call-seq:
 296  *     Signal.signame(signo)  ->  string or nil
 297  *
 298  *  Convert signal number to signal name.
 299  *  Returns +nil+ if the signo is an invalid signal number.
 300  *
 301  *     Signal.trap("INT") { |signo| puts Signal.signame(signo) }
 302  *     Process.kill("INT", 0)
 303  *
 304  *  <em>produces:</em>
 305  *
 306  *     INT
 307  */
 308 static VALUE
 309 sig_signame(VALUE recv, VALUE signo)
 310 {
 311     const char *signame = signo2signm(NUM2INT(signo));
 312     if (!signame) return Qnil;
 313     return rb_str_new_cstr(signame);
 314 }
 315
 316 const char *
 317 ruby_signal_name(int no)
 318 {
 319     return signo2signm(no);
 320 }
 321
 322 static VALUE
 323 rb_signo2signm(int signo)
 324 {
 325     const char *const signm = signo2signm(signo);
 326     if (signm) {
 327         return rb_sprintf("SIG%s", signm);
 328     }
 329     else {
 330         return rb_sprintf("SIG%u", signo);
 331     }
 332 }
 333
 334 /*
 335  * call-seq:
 336  *    SignalException.new(sig_name)              ->  signal_exception
 337  *    SignalException.new(sig_number [, name])   ->  signal_exception
 338  *
 339  *  Construct a new SignalException object.  +sig_name+ should be a known
 340  *  signal name.
 341  */
 342
 343 static VALUE
 344 esignal_init(int argc, VALUE *argv, VALUE self)
 345 {
 346     int argnum = 1;
 347     VALUE sig = Qnil;
 348     int signo;
 349
 350     if (argc > 0) {
 351         sig = rb_check_to_integer(argv[0], "to_int");
 352         if (!NIL_P(sig)) argnum = 2;
 353         else sig = argv[0];
 354     }
 355     rb_check_arity(argc, 1, argnum);
 356     if (argnum == 2) {
 357         signo = NUM2INT(sig);
 358         if (signo < 0 || signo > NSIG) {
 359             rb_raise(rb_eArgError, "invalid signal number (%d)", signo);
 360         }
 361         if (argc > 1) {
 362             sig = argv[1];
 363         }
 364         else {
 365             sig = rb_signo2signm(signo);
 366         }
 367     }
 368     else {
 369         int prefix;
 370         signo = signm2signo(&sig, FALSE, FALSE, &prefix);
 371         if (prefix != signame_prefix_len) {
 372             sig = rb_str_append(rb_str_new_cstr("SIG"), sig);
 373         }
 374     }
 375     rb_call_super(1, &sig);
 376     rb_ivar_set(self, id_signo, INT2NUM(signo));
 377
 378     return self;
 379 }
 380
 381 /*
 382  * call-seq:
 383  *    signal_exception.signo   ->  num
 384  *
 385  *  Returns a signal number.
 386  */
 387
 388 static VALUE
 389 esignal_signo(VALUE self)
 390 {
 391     return rb_ivar_get(self, id_signo);
 392 }
 393
 394 /* :nodoc: */
 395 static VALUE
 396 interrupt_init(int argc, VALUE *argv, VALUE self)
 397 {
 398     VALUE args[2];
 399
 400     args[0] = INT2FIX(SIGINT);
 401     args[1] = rb_check_arity(argc, 0, 1) ? argv[0] : Qnil;
 402     return rb_call_super(2, args);
 403 }
 404
 405 void rb_malloc_info_show_results(void); /* gc.c */
 406 #if defined(USE_SIGALTSTACK) || defined(_WIN32)
 407 static void reset_sigmask(int sig);
 408 #endif
 409
 410 void
 411 ruby_default_signal(int sig)
 412 {
 413 #if USE_DEBUG_COUNTER
 414     rb_debug_counter_show_results("killed by signal.");
 415 #endif
 416     rb_malloc_info_show_results();
 417
 418     signal(sig, SIG_DFL);
 419 #if defined(USE_SIGALTSTACK) || defined(_WIN32)
 420     reset_sigmask(sig);
 421 #endif
 422     raise(sig);
 423 }
 424
 425 static void sighandler(int sig);
 426 static int signal_ignored(int sig);
 427 static void signal_enque(int sig);
 428
 429 VALUE
 430 rb_f_kill(int argc, const VALUE *argv)
 431 {
 432 #ifndef HAVE_KILLPG
 433 #define killpg(pg, sig) kill(-(pg), (sig))
 434 #endif
 435     int sig;
 436     int i;
 437     VALUE str;
 438
 439     rb_check_arity(argc, 2, UNLIMITED_ARGUMENTS);
 440
 441     if (FIXNUM_P(argv[0])) {
 442         sig = FIX2INT(argv[0]);
 443     }
 444     else {
 445         str = argv[0];
 446         sig = signm2signo(&str, TRUE, FALSE, NULL);
 447     }
 448
 449     if (argc <= 1) return INT2FIX(0);
 450
 451     if (sig < 0) {
 452         sig = -sig;
 453         for (i=1; i<argc; i++) {
 454             if (killpg(NUM2PIDT(argv[i]), sig) < 0)
 455                 rb_sys_fail(0);
 456         }
 457     }
 458     else {
 459         const rb_pid_t self = (GET_THREAD() == GET_VM()->ractor.main_thread) ? getpid() : -1;
 460         int wakeup = 0;
 461
 462         for (i=1; i<argc; i++) {
 463             rb_pid_t pid = NUM2PIDT(argv[i]);
 464
 465             if ((sig != 0) && (self != -1) && (pid == self)) {
 466                 int t;
 467                 /*
 468                  * When target pid is self, many caller assume signal will be
 469                  * delivered immediately and synchronously.
 470                  */
 471                 switch (sig) {
 472                   case SIGSEGV:
 473 #ifdef SIGBUS
 474                   case SIGBUS:
 475 #endif
 476 #ifdef SIGKILL
 477                   case SIGKILL:
 478 #endif
 479 #ifdef SIGILL
 480                   case SIGILL:
 481 #endif
 482 #ifdef SIGFPE
 483                   case SIGFPE:
 484 #endif
 485 #ifdef SIGSTOP
 486                   case SIGSTOP:
 487 #endif
 488                     kill(pid, sig);
 489                     break;
 490                   default:
 491                     t = signal_ignored(sig);
 492                     if (t) {
 493                         if (t < 0 && kill(pid, sig))
 494                             rb_sys_fail(0);
 495                         break;
 496                     }
 497                     signal_enque(sig);
 498                     wakeup = 1;
 499                 }
 500             }
 501             else if (kill(pid, sig) < 0) {
 502                 rb_sys_fail(0);
 503             }
 504         }
 505         if (wakeup) {
 506             rb_threadptr_check_signal(GET_VM()->ractor.main_thread);
 507         }
 508     }
 509     rb_thread_execute_interrupts(rb_thread_current());
 510
 511     return INT2FIX(i-1);
 512 }
 513
 514 static struct {
 515     rb_atomic_t cnt[RUBY_NSIG];
 516     rb_atomic_t size;
 517 } signal_buff;
 518
 519 #define sighandler_t ruby_sighandler_t
 520
 521 #ifdef USE_SIGALTSTACK
 522 typedef void ruby_sigaction_t(int, siginfo_t*, void*);
 523 #define SIGINFO_ARG , siginfo_t *info, void *ctx
 524 #define SIGINFO_CTX ctx
 525 #else
 526 typedef void ruby_sigaction_t(int);
 527 #define SIGINFO_ARG
 528 #define SIGINFO_CTX 0
 529 #endif
 530
 531 #ifdef USE_SIGALTSTACK
 532 /* XXX: BSD_vfprintf() uses >1500B stack and x86-64 need >5KiB stack. */
 533 #define RUBY_SIGALTSTACK_SIZE (16*1024)
 534
 535 static int
 536 rb_sigaltstack_size(void)
 537 {
 538     int size = RUBY_SIGALTSTACK_SIZE;
 539
 540 #ifdef MINSIGSTKSZ
 541     {
 542         int minsigstksz = (int)MINSIGSTKSZ;
 543         if (size < minsigstksz)
 544             size = minsigstksz;
 545     }
 546 #endif
 547 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
 548     {
 549         int pagesize;
 550         pagesize = (int)sysconf(_SC_PAGE_SIZE);
 551         if (size < pagesize)
 552             size = pagesize;
 553     }
 554 #endif
 555
 556     return size;
 557 }
 558
 559 static int rb_sigaltstack_size_value = 0;
 560
 561 void *
 562 rb_allocate_sigaltstack(void)
 563 {
 564     void *altstack;
 565     if (!rb_sigaltstack_size_value) {
 566         rb_sigaltstack_size_value = rb_sigaltstack_size();
 567     }
 568     altstack = malloc(rb_sigaltstack_size_value);
 569     if (!altstack) rb_memerror();
 570     return altstack;
 571 }
 572
 573 /* alternate stack for SIGSEGV */
 574 void *
 575 rb_register_sigaltstack(void *altstack)
 576 {
 577     stack_t newSS, oldSS;
 578
 579     newSS.ss_size = rb_sigaltstack_size_value;
 580     newSS.ss_sp = altstack;
 581     newSS.ss_flags = 0;
 582
 583     sigaltstack(&newSS, &oldSS); /* ignore error. */
 584
 585     return newSS.ss_sp;
 586 }
 587 #endif /* USE_SIGALTSTACK */
 588
 589 #ifdef POSIX_SIGNAL
 590 static sighandler_t
 591 ruby_signal(int signum, sighandler_t handler)
 592 {
 593     struct sigaction sigact, old;
 594
 595 #if 0
 596     rb_trap_accept_nativethreads[signum] = 0;
 597 #endif
 598
 599     sigemptyset(&sigact.sa_mask);
 600 #if defined(USE_SIGALTSTACK) && !defined(__wasm__)
 601     if (handler == SIG_IGN || handler == SIG_DFL) {
 602         sigact.sa_handler = handler;
 603         sigact.sa_flags = 0;
 604     }
 605     else {
 606         sigact.sa_sigaction = (ruby_sigaction_t*)handler;
 607         sigact.sa_flags = SA_SIGINFO;
 608     }
 609 #else
 610     sigact.sa_handler = handler;
 611     sigact.sa_flags = 0;
 612 #endif
 613
 614     switch (signum) {
 615 #if defined(SA_ONSTACK) && defined(USE_SIGALTSTACK)
 616       case SIGSEGV:
 617 #ifdef SIGBUS
 618       case SIGBUS:
 619 #endif
 620         sigact.sa_flags |= SA_ONSTACK;
 621         break;
 622 #endif
 623     }
 624     (void)VALGRIND_MAKE_MEM_DEFINED(&old, sizeof(old));
 625     if (sigaction(signum, &sigact, &old) < 0) {
 626         return SIG_ERR;
 627     }
 628     if (old.sa_flags & SA_SIGINFO)
 629         handler = (sighandler_t)old.sa_sigaction;
 630     else
 631         handler = old.sa_handler;
 632     ASSUME(handler != SIG_ERR);
 633     return handler;
 634 }
 635
 636 sighandler_t
 637 ruby_posix_signal(int signum, sighandler_t handler)
 638 {
 639     return ruby_signal(signum, handler);
 640 }
 641
 642 #elif defined _WIN32
 643 static inline sighandler_t
 644 ruby_signal(int signum, sighandler_t handler)
 645 {
 646     if (signum == SIGKILL) {
 647         errno = EINVAL;
 648         return SIG_ERR;
 649     }
 650     return signal(signum, handler);
 651 }
 652
 653 #else /* !POSIX_SIGNAL */
 654 #define ruby_signal(sig,handler) (/* rb_trap_accept_nativethreads[(sig)] = 0,*/ signal((sig),(handler)))
 655 #if 0 /* def HAVE_NATIVETHREAD */
 656 static sighandler_t
 657 ruby_nativethread_signal(int signum, sighandler_t handler)
 658 {
 659     sighandler_t old;
 660
 661     old = signal(signum, handler);
 662     rb_trap_accept_nativethreads[signum] = 1;
 663     return old;
 664 }
 665 #endif
 666 #endif
 667
 668 static int
 669 signal_ignored(int sig)
 670 {
 671     sighandler_t func;
 672 #ifdef POSIX_SIGNAL
 673     struct sigaction old;
 674     (void)VALGRIND_MAKE_MEM_DEFINED(&old, sizeof(old));
 675     if (sigaction(sig, NULL, &old) < 0) return FALSE;
 676     func = old.sa_handler;
 677 #else
 678     sighandler_t old = signal(sig, SIG_DFL);
 679     signal(sig, old);
 680     func = old;
 681 #endif
 682     if (func == SIG_IGN) return 1;
 683     return func == sighandler ? 0 : -1;
 684 }
 685
 686 static void
 687 signal_enque(int sig)
 688 {
 689     ATOMIC_INC(signal_buff.cnt[sig]);
 690     ATOMIC_INC(signal_buff.size);
 691 }
 692
 693 static void
 694 sighandler(int sig)
 695 {
 696     int old_errnum = errno;
 697
 698     signal_enque(sig);
 699     rb_thread_wakeup_timer_thread(sig);
 700
 701 #if !defined(BSD_SIGNAL) && !defined(POSIX_SIGNAL)
 702     ruby_signal(sig, sighandler);
 703 #endif
 704
 705     errno = old_errnum;
 706 }
 707
 708 int
 709 rb_signal_buff_size(void)
 710 {
 711     return signal_buff.size;
 712 }
 713
 714 static void
 715 rb_disable_interrupt(void)
 716 {
 717 #ifdef HAVE_PTHREAD_SIGMASK
 718     sigset_t mask;
 719     sigfillset(&mask);
 720     pthread_sigmask(SIG_SETMASK, &mask, NULL);
 721 #endif
 722 }
 723
 724 static void
 725 rb_enable_interrupt(void)
 726 {
 727 #ifdef HAVE_PTHREAD_SIGMASK
 728     sigset_t mask;
 729     sigemptyset(&mask);
 730     pthread_sigmask(SIG_SETMASK, &mask, NULL);
 731 #endif
 732 }
 733
 734 int
 735 rb_get_next_signal(void)
 736 {
 737     int i, sig = 0;
 738
 739     if (signal_buff.size != 0) {
 740         for (i=1; i<RUBY_NSIG; i++) {
 741             if (signal_buff.cnt[i] > 0) {
 742                 ATOMIC_DEC(signal_buff.cnt[i]);
 743                 ATOMIC_DEC(signal_buff.size);
 744                 sig = i;
 745                 break;
 746             }
 747         }
 748     }
 749     return sig;
 750 }
 751
 752 #if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
 753 static const char *received_signal;
 754 # define clear_received_signal() (void)(ruby_disable_gc = 0, received_signal = 0)
 755 #else
 756 # define clear_received_signal() ((void)0)
 757 #endif
 758
 759 #if defined(USE_SIGALTSTACK) || defined(_WIN32)
 760 NORETURN(void rb_ec_stack_overflow(rb_execution_context_t *ec, int crit));
 761 # if defined __HAIKU__
 762 #   define USE_UCONTEXT_REG 1
 763 # elif !(defined(HAVE_UCONTEXT_H) && (defined __i386__ || defined __x86_64__ || defined __amd64__))
 764 # elif defined __linux__
 765 #   define USE_UCONTEXT_REG 1
 766 # elif defined __APPLE__
 767 #   define USE_UCONTEXT_REG 1
 768 # elif defined __FreeBSD__
 769 #   define USE_UCONTEXT_REG 1
 770 # endif
 771 #if defined(HAVE_PTHREAD_SIGMASK)
 772 # define ruby_sigunmask pthread_sigmask
 773 #elif defined(HAVE_SIGPROCMASK)
 774 # define ruby_sigunmask sigprocmask
 775 #endif
 776 static void
 777 reset_sigmask(int sig)
 778 {
 779 #if defined(ruby_sigunmask)
 780     sigset_t mask;
 781 #endif
 782     clear_received_signal();
 783 #if defined(ruby_sigunmask)
 784     sigemptyset(&mask);
 785     sigaddset(&mask, sig);
 786     if (ruby_sigunmask(SIG_UNBLOCK, &mask, NULL)) {
 787         rb_bug_errno(STRINGIZE(ruby_sigunmask)":unblock", errno);
 788     }
 789 #endif
 790 }
 791
 792 # ifdef USE_UCONTEXT_REG
 793 static void
 794 check_stack_overflow(int sig, const uintptr_t addr, const ucontext_t *ctx)
 795 {
 796     const DEFINE_MCONTEXT_PTR(mctx, ctx);
 797 # if defined __linux__
 798 #   if defined REG_RSP
 799     const greg_t sp = mctx->gregs[REG_RSP];
 800     const greg_t bp = mctx->gregs[REG_RBP];
 801 #   else
 802     const greg_t sp = mctx->gregs[REG_ESP];
 803     const greg_t bp = mctx->gregs[REG_EBP];
 804 #   endif
 805 # elif defined __APPLE__
 806 #   if __DARWIN_UNIX03
 807 #     define MCTX_SS_REG(reg) __ss.__##reg
 808 #   else
 809 #     define MCTX_SS_REG(reg) ss.reg
 810 #   endif
 811 #   if defined(__LP64__)
 812     const uintptr_t sp = mctx->MCTX_SS_REG(rsp);
 813     const uintptr_t bp = mctx->MCTX_SS_REG(rbp);
 814 #   else
 815     const uintptr_t sp = mctx->MCTX_SS_REG(esp);
 816     const uintptr_t bp = mctx->MCTX_SS_REG(ebp);
 817 #   endif
 818 # elif defined __FreeBSD__
 819 #   if defined(__amd64__)
 820     const __register_t sp = mctx->mc_rsp;
 821     const __register_t bp = mctx->mc_rbp;
 822 #   else
 823     const __register_t sp = mctx->mc_esp;
 824     const __register_t bp = mctx->mc_ebp;
 825 #   endif
 826 # elif defined __HAIKU__
 827 #   if defined(__amd64__)
 828     const unsigned long sp = mctx->rsp;
 829     const unsigned long bp = mctx->rbp;
 830 #   else
 831     const unsigned long sp = mctx->esp;
 832     const unsigned long bp = mctx->ebp;
 833 #   endif
 834 # endif
 835     enum {pagesize = 4096};
 836     const uintptr_t sp_page = (uintptr_t)sp / pagesize;
 837     const uintptr_t bp_page = (uintptr_t)bp / pagesize;
 838     const uintptr_t fault_page = addr / pagesize;
 839
 840     /* SP in ucontext is not decremented yet when `push` failed, so
 841      * the fault page can be the next. */
 842     if (sp_page == fault_page || sp_page == fault_page + 1 ||
 843         (sp_page <= fault_page && fault_page <= bp_page)) {
 844         rb_execution_context_t *ec = GET_EC();
 845         int crit = FALSE;
 846         int uplevel = roomof(pagesize, sizeof(*ec->tag)) / 2; /* XXX: heuristic */
 847         while ((uintptr_t)ec->tag->buf / pagesize <= fault_page + 1) {
 848             /* drop the last tag if it is close to the fault,
 849              * otherwise it can cause stack overflow again at the same
 850              * place. */
 851             if ((crit = (!ec->tag->prev || !--uplevel)) != FALSE) break;
 852             ec->tag = ec->tag->prev;
 853         }
 854         reset_sigmask(sig);
 855         rb_ec_stack_overflow(ec, crit);
 856     }
 857 }
 858 # else
 859 static void
 860 check_stack_overflow(int sig, const void *addr)
 861 {
 862     int ruby_stack_overflowed_p(const rb_thread_t *, const void *);
 863     rb_thread_t *th = GET_THREAD();
 864     if (ruby_stack_overflowed_p(th, addr)) {
 865         reset_sigmask(sig);
 866         rb_ec_stack_overflow(th->ec, FALSE);
 867     }
 868 }
 869 # endif
 870
 871 # ifdef _WIN32
 872 #   define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, 0)
 873 # else
 874 #   define FAULT_ADDRESS info->si_addr
 875 #   ifdef USE_UCONTEXT_REG
 876 #     define CHECK_STACK_OVERFLOW_() check_stack_overflow(sig, (uintptr_t)FAULT_ADDRESS, ctx)
 877 #   else
 878 #     define CHECK_STACK_OVERFLOW_() check_stack_overflow(sig, FAULT_ADDRESS)
 879 #   endif
 880 #   define MESSAGE_FAULT_ADDRESS " at %p", FAULT_ADDRESS
 881 #   define SIGNAL_FROM_USER_P() ((info)->si_code == SI_USER)
 882 #   define CHECK_STACK_OVERFLOW() (SIGNAL_FROM_USER_P() ? (void)0 : CHECK_STACK_OVERFLOW_())
 883 # endif
 884 #else
 885 # define CHECK_STACK_OVERFLOW() (void)0
 886 #endif
 887 #ifndef MESSAGE_FAULT_ADDRESS
 888 # define MESSAGE_FAULT_ADDRESS
 889 #endif
 890
 891 #if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
 892 NOINLINE(static void check_reserved_signal_(const char *name, size_t name_len, int signo));
 893 /* noinine to reduce stack usage in signal handers */
 894
 895 #define check_reserved_signal(name) check_reserved_signal_(name, sizeof(name)-1, sig)
 896
 897 #ifdef SIGBUS
 898
 899 static sighandler_t default_sigbus_handler;
 900 NORETURN(static ruby_sigaction_t sigbus);
 901
 902 static void
 903 sigbus(int sig SIGINFO_ARG)
 904 {
 905     check_reserved_signal("BUS");
 906 /*
 907  * Mac OS X makes KERN_PROTECTION_FAILURE when thread touch guard page.
 908  * and it's delivered as SIGBUS instead of SIGSEGV to userland. It's crazy
 909  * wrong IMHO. but anyway we have to care it. Sigh.
 910  */
 911     /* Seems Linux also delivers SIGBUS. */
 912 #if defined __APPLE__ || defined __linux__
 913     CHECK_STACK_OVERFLOW();
 914 #endif
 915     rb_bug_for_fatal_signal(default_sigbus_handler, sig, SIGINFO_CTX, "Bus Error" MESSAGE_FAULT_ADDRESS);
 916 }
 917 #endif
 918
 919 #ifdef SIGSEGV
 920
 921 static sighandler_t default_sigsegv_handler;
 922 NORETURN(static ruby_sigaction_t sigsegv);
 923
 924 static void
 925 sigsegv(int sig SIGINFO_ARG)
 926 {
 927     check_reserved_signal("SEGV");
 928     CHECK_STACK_OVERFLOW();
 929     rb_bug_for_fatal_signal(default_sigsegv_handler, sig, SIGINFO_CTX, "Segmentation fault" MESSAGE_FAULT_ADDRESS);
 930 }
 931 #endif
 932
 933 #ifdef SIGILL
 934
 935 static sighandler_t default_sigill_handler;
 936 NORETURN(static ruby_sigaction_t sigill);
 937
 938 static void
 939 sigill(int sig SIGINFO_ARG)
 940 {
 941     check_reserved_signal("ILL");
 942 #if defined __APPLE__ || defined __linux__
 943     CHECK_STACK_OVERFLOW();
 944 #endif
 945     rb_bug_for_fatal_signal(default_sigill_handler, sig, SIGINFO_CTX, "Illegal instruction" MESSAGE_FAULT_ADDRESS);
 946 }
 947 #endif
 948
 949 #ifndef __sun
 950 NORETURN(static void ruby_abort(void));
 951 #endif
 952
 953 static void
 954 ruby_abort(void)
 955 {
 956 #ifdef __sun
 957     /* Solaris's abort() is async signal unsafe. Of course, it is not
 958      *  POSIX compliant.
 959      */
 960     raise(SIGABRT);
 961 #else
 962     abort();
 963 #endif
 964 }
 965
 966 static void
 967 check_reserved_signal_(const char *name, size_t name_len, int signo)
 968 {
 969     const char *prev = ATOMIC_PTR_EXCHANGE(received_signal, name);
 970
 971     if (prev) {
 972         ssize_t RB_UNUSED_VAR(err);
 973         static const int stderr_fd = 2;
 974 #define NOZ(name, str) name[sizeof(str)-1] = str
 975         static const char NOZ(msg1, " received in ");
 976         static const char NOZ(msg2, " handler\n");
 977
 978 #ifdef HAVE_WRITEV
 979         struct iovec iov[4];
 980         int i = 0;
 981 # define W(str, len) \
 982         iov[i++] = (struct iovec){.iov_base = (void *)(str), .iov_len = (len)}
 983 #else
 984 # define W(str, len) err = write(stderr_fd, (str), (len))
 985 #endif
 986
 987 #if __has_feature(address_sanitizer) || \
 988     __has_feature(memory_sanitizer) || \
 989     defined(HAVE_VALGRIND_MEMCHECK_H)
 990         ruby_posix_signal(signo, SIG_DFL);
 991 #endif
 992         W(name, name_len);
 993         W(msg1, sizeof(msg1));
 994         W(prev, strlen(prev));
 995         W(msg2, sizeof(msg2));
 996 # undef W
 997 #ifdef HAVE_WRITEV
 998         err = writev(stderr_fd, iov, i);
 999 #endif
1000         ruby_abort();
1001     }
1002
1003     ruby_disable_gc = 1;
1004 }
1005 #endif
1006
1007 #if defined SIGPIPE || defined SIGSYS
1008 static void
1009 sig_do_nothing(int sig)
1010 {
1011 }
1012 #endif
1013
1014 static int
1015 signal_exec(VALUE cmd, int sig)
1016 {
1017     rb_execution_context_t *ec = GET_EC();
1018     volatile rb_atomic_t old_interrupt_mask = ec->interrupt_mask;
1019     enum ruby_tag_type state;
1020
1021     /*
1022      * workaround the following race:
1023      * 1. signal_enque queues signal for execution
1024      * 2. user calls trap(sig, "IGNORE"), setting SIG_IGN
1025      * 3. rb_signal_exec runs on queued signal
1026      */
1027     if (IMMEDIATE_P(cmd))
1028         return FALSE;
1029
1030     ec->interrupt_mask |= TRAP_INTERRUPT_MASK;
1031     EC_PUSH_TAG(ec);
1032     if ((state = EC_EXEC_TAG()) == TAG_NONE) {
1033         VALUE signum = INT2NUM(sig);
1034         rb_eval_cmd_kw(cmd, rb_ary_new3(1, signum), RB_NO_KEYWORDS);
1035     }
1036     EC_POP_TAG();
1037     ec = GET_EC();
1038     ec->interrupt_mask = old_interrupt_mask;
1039
1040     if (state) {
1041         /* XXX: should be replaced with rb_threadptr_pending_interrupt_enque() */
1042         EC_JUMP_TAG(ec, state);
1043     }
1044     return TRUE;
1045 }
1046
1047 void
1048 rb_vm_trap_exit(rb_vm_t *vm)
1049 {
1050     VALUE trap_exit = vm->trap_list.cmd[0];
1051
1052     if (trap_exit) {
1053         vm->trap_list.cmd[0] = 0;
1054         signal_exec(trap_exit, 0);
1055     }
1056 }
1057
1058 /* returns true if a trap handler was run, false otherwise */
1059 int
1060 rb_signal_exec(rb_thread_t *th, int sig)
1061 {
1062     rb_vm_t *vm = GET_VM();
1063     VALUE cmd = vm->trap_list.cmd[sig];
1064
1065     if (cmd == 0) {
1066         switch (sig) {
1067           case SIGINT:
1068             rb_interrupt();
1069             break;
1070 #ifdef SIGHUP
1071           case SIGHUP:
1072 #endif
1073 #ifdef SIGQUIT
1074           case SIGQUIT:
1075 #endif
1076 #ifdef SIGTERM
1077           case SIGTERM:
1078 #endif
1079 #ifdef SIGALRM
1080           case SIGALRM:
1081 #endif
1082 #ifdef SIGUSR1
1083           case SIGUSR1:
1084 #endif
1085 #ifdef SIGUSR2
1086           case SIGUSR2:
1087 #endif
1088             rb_threadptr_signal_raise(th, sig);
1089             break;
1090         }
1091     }
1092     else if (UNDEF_P(cmd)) {
1093         rb_threadptr_signal_exit(th);
1094     }
1095     else {
1096         return signal_exec(cmd, sig);
1097     }
1098     return FALSE;
1099 }
1100
1101 static sighandler_t
1102 default_handler(int sig)
1103 {
1104     sighandler_t func;
1105     switch (sig) {
1106       case SIGINT:
1107 #ifdef SIGHUP
1108       case SIGHUP:
1109 #endif
1110 #ifdef SIGQUIT
1111       case SIGQUIT:
1112 #endif
1113 #ifdef SIGTERM
1114       case SIGTERM:
1115 #endif
1116 #ifdef SIGALRM
1117       case SIGALRM:
1118 #endif
1119 #ifdef SIGUSR1
1120       case SIGUSR1:
1121 #endif
1122 #ifdef SIGUSR2
1123       case SIGUSR2:
1124 #endif
1125 #ifdef RUBY_SIGCHLD
1126       case RUBY_SIGCHLD:
1127 #endif
1128         func = sighandler;
1129         break;
1130 #ifdef SIGBUS
1131       case SIGBUS:
1132         func = (sighandler_t)sigbus;
1133         break;
1134 #endif
1135 #ifdef SIGSEGV
1136       case SIGSEGV:
1137         func = (sighandler_t)sigsegv;
1138         break;
1139 #endif
1140 #ifdef SIGPIPE
1141       case SIGPIPE:
1142         func = sig_do_nothing;
1143         break;
1144 #endif
1145 #ifdef SIGSYS
1146       case SIGSYS:
1147         func = sig_do_nothing;
1148         break;
1149 #endif
1150       default:
1151         func = SIG_DFL;
1152         break;
1153     }
1154
1155     return func;
1156 }
1157
1158 static sighandler_t
1159 trap_handler(VALUE *cmd, int sig)
1160 {
1161     sighandler_t func = sighandler;
1162     VALUE command;
1163
1164     if (NIL_P(*cmd)) {
1165         func = SIG_IGN;
1166     }
1167     else {
1168         command = rb_check_string_type(*cmd);
1169         if (NIL_P(command) && SYMBOL_P(*cmd)) {
1170             command = rb_sym2str(*cmd);
1171             if (!command) rb_raise(rb_eArgError, "bad handler");
1172         }
1173         if (!NIL_P(command)) {
1174             const char *cptr;
1175             long len;
1176             StringValue(command);
1177             *cmd = command;
1178             RSTRING_GETMEM(command, cptr, len);
1179             switch (len) {
1180               sig_ign:
1181                 func = SIG_IGN;
1182                 *cmd = Qtrue;
1183                 break;
1184               sig_dfl:
1185                 func = default_handler(sig);
1186                 *cmd = 0;
1187                 break;
1188               case 0:
1189                 goto sig_ign;
1190                 break;
1191               case 14:
1192                 if (memcmp(cptr, "SYSTEM_DEFAULT", 14) == 0) {
1193                     func = SIG_DFL;
1194                     *cmd = 0;
1195                 }
1196                 break;
1197               case 7:
1198                 if (memcmp(cptr, "SIG_IGN", 7) == 0) {
1199                     goto sig_ign;
1200                 }
1201                 else if (memcmp(cptr, "SIG_DFL", 7) == 0) {
1202                     goto sig_dfl;
1203                 }
1204                 else if (memcmp(cptr, "DEFAULT", 7) == 0) {
1205                     goto sig_dfl;
1206                 }
1207                 break;
1208               case 6:
1209                 if (memcmp(cptr, "IGNORE", 6) == 0) {
1210                     goto sig_ign;
1211                 }
1212                 break;
1213               case 4:
1214                 if (memcmp(cptr, "EXIT", 4) == 0) {
1215                     *cmd = Qundef;
1216                 }
1217                 break;
1218             }
1219         }
1220         else {
1221             rb_proc_t *proc;
1222             GetProcPtr(*cmd, proc);
1223             (void)proc;
1224         }
1225     }
1226
1227     return func;
1228 }
1229
1230 static int
1231 trap_signm(VALUE vsig)
1232 {
1233     int sig = -1;
1234
1235     if (FIXNUM_P(vsig)) {
1236         sig = FIX2INT(vsig);
1237         if (sig < 0 || sig >= NSIG) {
1238             rb_raise(rb_eArgError, "invalid signal number (%d)", sig);
1239         }
1240     }
1241     else {
1242         sig = signm2signo(&vsig, FALSE, TRUE, NULL);
1243     }
1244     return sig;
1245 }
1246
1247 static VALUE
1248 trap(int sig, sighandler_t func, VALUE command)
1249 {
1250     sighandler_t oldfunc;
1251     VALUE oldcmd;
1252     rb_vm_t *vm = GET_VM();
1253
1254     /*
1255      * Be careful. ruby_signal() and trap_list.cmd[sig] must be changed
1256      * atomically. In current implementation, we only need to don't call
1257      * RUBY_VM_CHECK_INTS().
1258      */
1259     if (sig == 0) {
1260         oldfunc = SIG_ERR;
1261     }
1262     else {
1263         oldfunc = ruby_signal(sig, func);
1264         if (oldfunc == SIG_ERR) rb_sys_fail_str(rb_signo2signm(sig));
1265     }
1266     oldcmd = vm->trap_list.cmd[sig];
1267     switch (oldcmd) {
1268       case 0:
1269       case Qtrue:
1270         if (oldfunc == SIG_IGN) oldcmd = rb_str_new2("IGNORE");
1271         else if (oldfunc == SIG_DFL) oldcmd = rb_str_new2("SYSTEM_DEFAULT");
1272         else if (oldfunc == sighandler) oldcmd = rb_str_new2("DEFAULT");
1273         else oldcmd = Qnil;
1274         break;
1275       case Qnil:
1276         break;
1277       case Qundef:
1278         oldcmd = rb_str_new2("EXIT");
1279         break;
1280     }
1281
1282     ACCESS_ONCE(VALUE, vm->trap_list.cmd[sig]) = command;
1283
1284     return oldcmd;
1285 }
1286
1287 static int
1288 reserved_signal_p(int signo)
1289 {
1290 /* Synchronous signal can't deliver to main thread */
1291 #ifdef SIGSEGV
1292     if (signo == SIGSEGV)
1293         return 1;
1294 #endif
1295 #ifdef SIGBUS
1296     if (signo == SIGBUS)
1297         return 1;
1298 #endif
1299 #ifdef SIGILL
1300     if (signo == SIGILL)
1301         return 1;
1302 #endif
1303 #ifdef SIGFPE
1304     if (signo == SIGFPE)
1305         return 1;
1306 #endif
1307
1308 /* used ubf internal see thread_pthread.c. */
1309 #ifdef SIGVTALRM
1310     if (signo == SIGVTALRM)
1311         return 1;
1312 #endif
1313
1314     return 0;
1315 }
1316
1317 /*
1318  * call-seq:
1319  *   Signal.trap( signal, command ) -> obj
1320  *   Signal.trap( signal ) {| | block } -> obj
1321  *
1322  * Specifies the handling of signals. The first parameter is a signal
1323  * name (a string such as ``SIGALRM'', ``SIGUSR1'', and so on) or a
1324  * signal number. The characters ``SIG'' may be omitted from the
1325  * signal name. The command or block specifies code to be run when the
1326  * signal is raised.
1327  * If the command is the string ``IGNORE'' or ``SIG_IGN'', the signal
1328  * will be ignored.
1329  * If the command is ``DEFAULT'' or ``SIG_DFL'', the Ruby's default handler
1330  * will be invoked.
1331  * If the command is ``EXIT'', the script will be terminated by the signal.
1332  * If the command is ``SYSTEM_DEFAULT'', the operating system's default
1333  * handler will be invoked.
1334  * Otherwise, the given command or block will be run.
1335  * The special signal name ``EXIT'' or signal number zero will be
1336  * invoked just prior to program termination.
1337  * trap returns the previous handler for the given signal.
1338  *
1339  *     Signal.trap(0, proc { puts "Terminating: #{$$}" })
1340  *     Signal.trap("CLD")  { puts "Child died" }
1341  *     fork && Process.wait
1342  *
1343  * <em>produces:</em>
1344  *     Terminating: 27461
1345  *     Child died
1346  *     Terminating: 27460
1347  */
1348 static VALUE
1349 sig_trap(int argc, VALUE *argv, VALUE _)
1350 {
1351     int sig;
1352     sighandler_t func;
1353     VALUE cmd;
1354
1355     rb_check_arity(argc, 1, 2);
1356
1357     sig = trap_signm(argv[0]);
1358     if (reserved_signal_p(sig)) {
1359         const char *name = signo2signm(sig);
1360         if (name)
1361             rb_raise(rb_eArgError, "can't trap reserved signal: SIG%s", name);
1362         else
1363             rb_raise(rb_eArgError, "can't trap reserved signal: %d", sig);
1364     }
1365
1366     if (argc == 1) {
1367         cmd = rb_block_proc();
1368         func = sighandler;
1369     }
1370     else {
1371         cmd = argv[1];
1372         func = trap_handler(&cmd, sig);
1373     }
1374
1375     if (rb_obj_is_proc(cmd) &&
1376         !rb_ractor_main_p() && !rb_ractor_shareable_p(cmd)) {
1377         cmd = rb_proc_isolate(cmd);
1378     }
1379
1380     return trap(sig, func, cmd);
1381 }
1382
1383 /*
1384  * call-seq:
1385  *   Signal.list -> a_hash
1386  *
1387  * Returns a list of signal names mapped to the corresponding
1388  * underlying signal numbers.
1389  *
1390  *   Signal.list   #=> {"EXIT"=>0, "HUP"=>1, "INT"=>2, "QUIT"=>3, "ILL"=>4, "TRAP"=>5, "IOT"=>6, "ABRT"=>6, "FPE"=>8, "KILL"=>9, "BUS"=>7, "SEGV"=>11, "SYS"=>31, "PIPE"=>13, "ALRM"=>14, "TERM"=>15, "URG"=>23, "STOP"=>19, "TSTP"=>20, "CONT"=>18, "CHLD"=>17, "CLD"=>17, "TTIN"=>21, "TTOU"=>22, "IO"=>29, "XCPU"=>24, "XFSZ"=>25, "VTALRM"=>26, "PROF"=>27, "WINCH"=>28, "USR1"=>10, "USR2"=>12, "PWR"=>30, "POLL"=>29}
1391  */
1392 static VALUE
1393 sig_list(VALUE _)
1394 {
1395     VALUE h = rb_hash_new();
1396     const struct signals *sigs;
1397
1398     FOREACH_SIGNAL(sigs, 0) {
1399         rb_hash_aset(h, rb_fstring_cstr(sigs->signm), INT2FIX(sigs->signo));
1400     }
1401     return h;
1402 }
1403
1404 #define INSTALL_SIGHANDLER(cond, signame, signum) do {  \
1405         static const char failed[] = "failed to install "signame" handler"; \
1406         if (!(cond)) break; \
1407         if (reserved_signal_p(signum)) rb_bug(failed); \
1408         perror(failed); \
1409     } while (0)
1410
1411 static int
1412 install_sighandler_core(int signum, sighandler_t handler, sighandler_t *old_handler)
1413 {
1414     sighandler_t old;
1415
1416     old = ruby_signal(signum, handler);
1417     if (old == SIG_ERR) return -1;
1418     if (old_handler) {
1419         *old_handler = (old == SIG_DFL || old == SIG_IGN) ? 0 : old;
1420     }
1421     else {
1422         /* signal handler should be inherited during exec. */
1423         if (old != SIG_DFL) {
1424             ruby_signal(signum, old);
1425         }
1426     }
1427     return 0;
1428 }
1429
1430 #  define install_sighandler(signum, handler) \
1431     INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, NULL), #signum, signum)
1432 #  define force_install_sighandler(signum, handler, old_handler) \
1433     INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, old_handler), #signum, signum)
1434
1435 void
1436 ruby_sig_finalize(void)
1437 {
1438     sighandler_t oldfunc;
1439
1440     oldfunc = ruby_signal(SIGINT, SIG_IGN);
1441     if (oldfunc == sighandler) {
1442         ruby_signal(SIGINT, SIG_DFL);
1443     }
1444 }
1445
1446 int ruby_enable_coredump = 0;
1447
1448 /*
1449  * Many operating systems allow signals to be sent to running
1450  * processes. Some signals have a defined effect on the process, while
1451  * others may be trapped at the code level and acted upon. For
1452  * example, your process may trap the USR1 signal and use it to toggle
1453  * debugging, and may use TERM to initiate a controlled shutdown.
1454  *
1455  *     pid = fork do
1456  *       Signal.trap("USR1") do
1457  *         $debug = !$debug
1458  *         puts "Debug now: #$debug"
1459  *       end
1460  *       Signal.trap("TERM") do
1461  *         puts "Terminating..."
1462  *         shutdown()
1463  *       end
1464  *       # . . . do some work . . .
1465  *     end
1466  *
1467  *     Process.detach(pid)
1468  *
1469  *     # Controlling program:
1470  *     Process.kill("USR1", pid)
1471  *     # ...
1472  *     Process.kill("USR1", pid)
1473  *     # ...
1474  *     Process.kill("TERM", pid)
1475  *
1476  * <em>produces:</em>
1477  *     Debug now: true
1478  *     Debug now: false
1479  *     Terminating...
1480  *
1481  * The list of available signal names and their interpretation is
1482  * system dependent. Signal delivery semantics may also vary between
1483  * systems; in particular signal delivery may not always be reliable.
1484  */
1485 void
1486 Init_signal(void)
1487 {
1488     VALUE mSignal = rb_define_module("Signal");
1489
1490     rb_define_global_function("trap", sig_trap, -1);
1491     rb_define_module_function(mSignal, "trap", sig_trap, -1);
1492     rb_define_module_function(mSignal, "list", sig_list, 0);
1493     rb_define_module_function(mSignal, "signame", sig_signame, 1);
1494
1495     rb_define_method(rb_eSignal, "initialize", esignal_init, -1);
1496     rb_define_method(rb_eSignal, "signo", esignal_signo, 0);
1497     rb_alias(rb_eSignal, rb_intern_const("signm"), rb_intern_const("message"));
1498     rb_define_method(rb_eInterrupt, "initialize", interrupt_init, -1);
1499
1500     // It should be ready to call rb_signal_exec()
1501     VM_ASSERT(GET_THREAD()->pending_interrupt_queue);
1502
1503     /* At this time, there is no subthread. Then sigmask guarantee atomics. */
1504     rb_disable_interrupt();
1505
1506     install_sighandler(SIGINT, sighandler);
1507 #ifdef SIGHUP
1508     install_sighandler(SIGHUP, sighandler);
1509 #endif
1510 #ifdef SIGQUIT
1511     install_sighandler(SIGQUIT, sighandler);
1512 #endif
1513 #ifdef SIGTERM
1514     install_sighandler(SIGTERM, sighandler);
1515 #endif
1516 #ifdef SIGALRM
1517     install_sighandler(SIGALRM, sighandler);
1518 #endif
1519 #ifdef SIGUSR1
1520     install_sighandler(SIGUSR1, sighandler);
1521 #endif
1522 #ifdef SIGUSR2
1523     install_sighandler(SIGUSR2, sighandler);
1524 #endif
1525
1526     if (!ruby_enable_coredump) {
1527 #ifdef SIGBUS
1528         force_install_sighandler(SIGBUS, (sighandler_t)sigbus, &default_sigbus_handler);
1529 #endif
1530 #ifdef SIGILL
1531         force_install_sighandler(SIGILL, (sighandler_t)sigill, &default_sigill_handler);
1532 #endif
1533 #ifdef SIGSEGV
1534         RB_ALTSTACK_INIT(GET_VM()->main_altstack, rb_allocate_sigaltstack());
1535         force_install_sighandler(SIGSEGV, (sighandler_t)sigsegv, &default_sigsegv_handler);
1536 #endif
1537     }
1538 #ifdef SIGPIPE
1539     install_sighandler(SIGPIPE, sig_do_nothing);
1540 #endif
1541 #ifdef SIGSYS
1542     install_sighandler(SIGSYS, sig_do_nothing);
1543 #endif
1544
1545 #ifdef RUBY_SIGCHLD
1546     install_sighandler(RUBY_SIGCHLD, sighandler);
1547 #endif
1548
1549     rb_enable_interrupt();
1550 }