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