39#include "internal/eval.h"
48#ifdef NEED_RUBY_ATOMIC_OPS
50ruby_atomic_exchange(rb_atomic_t *
ptr, rb_atomic_t val)
52 rb_atomic_t old = *
ptr;
58ruby_atomic_compare_and_swap(rb_atomic_t *
ptr, rb_atomic_t cmp,
61 rb_atomic_t old = *
ptr;
69#define FOREACH_SIGNAL(sig, offset) \
70 for (sig = siglist + (offset); sig < siglist + numberof(siglist); ++sig)
72static const struct signals {
155 {
"VTALRM", SIGVTALRM},
182 {
"DANGER", SIGDANGER},
185 {
"MIGRATE", SIGMIGRATE},
194 {
"RETRACT", SIGRETRACT},
204static const char signame_prefix[] =
"SIG";
205static const int signame_prefix_len = 3;
208signm2signo(
VALUE *sig_ptr,
int negative,
int exit,
int *prefix_ptr)
210 const struct signals *sigs;
211 VALUE vsig = *sig_ptr;
216 if (RB_SYMBOL_P(vsig)) {
219 else if (!RB_TYPE_P(vsig,
T_STRING)) {
225 *sig_ptr = vsig =
str;
230 if (memchr(nm,
'\0',
len)) {
234 if (
len > 0 && nm[0] ==
'-') {
242 if (
len >=
prefix + signame_prefix_len) {
243 if (
memcmp(nm +
prefix, signame_prefix, signame_prefix_len) == 0)
244 prefix += signame_prefix_len;
250 if (prefix_ptr) *prefix_ptr =
prefix;
255 if (
memcmp(sigs->signm, nm, nmlen) == 0 &&
256 sigs->signm[nmlen] ==
'\0') {
257 return negative ? -sigs->signo : sigs->signo;
262 if (
prefix == signame_prefix_len) {
265 else if (
prefix > signame_prefix_len) {
266 prefix -= signame_prefix_len;
274 prefix = signame_prefix_len;
277 prefix, signame_prefix, vsig);
284 const struct signals *sigs;
287 if (sigs->signo == no)
310 const char *signame = signo2signm(
NUM2INT(signo));
311 if (!signame)
return Qnil;
318 return signo2signm(no);
322rb_signo2signm(
int signo)
324 const char *
const signm = signo2signm(signo);
351 if (!
NIL_P(sig)) argnum = 2;
357 if (signo < 0 || signo >
NSIG) {
364 sig = rb_signo2signm(signo);
370 if (
prefix != signame_prefix_len) {
388esignal_signo(
VALUE self)
414 signal(sig, SIG_DFL);
418static void sighandler(
int sig);
419static int signal_ignored(
int sig);
420static void signal_enque(
int sig);
426#define killpg(pg, sig) kill(-(pg), (sig))
446 for (i=1; i<
argc; i++) {
452 const rb_pid_t self = (GET_THREAD() == GET_VM()->ractor.main_thread) ? getpid() : -1;
455 for (i=1; i<
argc; i++) {
458 if ((sig != 0) && (self != -1) && (pid == self)) {
484 t = signal_ignored(sig);
486 if (
t < 0 &&
kill(pid, sig))
494 else if (
kill(pid, sig) < 0) {
515#define sighandler_t ruby_sighandler_t
517#ifdef USE_SIGALTSTACK
519#define SIGINFO_ARG , siginfo_t *info, void *ctx
520#define SIGINFO_CTX ctx
527#ifdef USE_SIGALTSTACK
529#define RUBY_SIGALTSTACK_SIZE (16*1024)
532rb_sigaltstack_size(
void)
534 int size = RUBY_SIGALTSTACK_SIZE;
538 int minsigstksz = (
int)MINSIGSTKSZ;
539 if (
size < minsigstksz)
543#if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
546 pagesize = (
int)sysconf(_SC_PAGE_SIZE);
555static int rb_sigaltstack_size_value = 0;
558rb_allocate_sigaltstack(
void)
561 if (!rb_sigaltstack_size_value) {
562 rb_sigaltstack_size_value = rb_sigaltstack_size();
564 altstack =
malloc(rb_sigaltstack_size_value);
571rb_register_sigaltstack(
void *altstack)
573 stack_t newSS, oldSS;
575 newSS.ss_size = rb_sigaltstack_size_value;
576 newSS.ss_sp = altstack;
579 sigaltstack(&newSS, &oldSS);
589 struct sigaction sigact, old;
592 rb_trap_accept_nativethreads[signum] = 0;
595 sigemptyset(&sigact.sa_mask);
596#ifdef USE_SIGALTSTACK
597 if (handler == SIG_IGN || handler == SIG_DFL) {
598 sigact.sa_handler = handler;
603 sigact.sa_flags = SA_SIGINFO;
606 sigact.sa_handler = handler;
613 if (handler == SIG_IGN) {
615# ifdef USE_SIGALTSTACK
616 if (sigact.sa_flags & SA_SIGINFO) {
620 sigact.sa_handler = sighandler;
623 sigact.sa_handler = handler;
632#if defined(SA_ONSTACK) && defined(USE_SIGALTSTACK)
637 sigact.sa_flags |= SA_ONSTACK;
642 if (sigaction(signum, &sigact, &old) < 0) {
645 if (old.sa_flags & SA_SIGINFO)
648 handler = old.sa_handler;
649 ASSUME(handler != SIG_ERR);
667 return signal(signum, handler);
671#define ruby_signal(sig,handler) ( signal((sig),(handler)))
674ruby_nativethread_signal(
int signum,
sighandler_t handler)
678 old = signal(signum, handler);
679 rb_trap_accept_nativethreads[signum] = 1;
686signal_ignored(
int sig)
690 struct sigaction old;
692 if (sigaction(sig,
NULL, &old) < 0)
return FALSE;
693 func = old.sa_handler;
699 if (func == SIG_IGN)
return 1;
700 return func == sighandler ? 0 : -1;
711static rb_atomic_t sigchld_hit;
713# define GET_SIGCHLD_HIT() ATOMIC_EXCHANGE(sigchld_hit, 0)
715# define GET_SIGCHLD_HIT() 0
721 int old_errnum = errno;
739#if !defined(BSD_SIGNAL) && !defined(POSIX_SIGNAL)
749 return signal_buff.size;
753rb_disable_interrupt(
void)
755#ifdef HAVE_PTHREAD_SIGMASK
758 pthread_sigmask(SIG_SETMASK, &
mask,
NULL);
763rb_enable_interrupt(
void)
765#ifdef HAVE_PTHREAD_SIGMASK
768 pthread_sigmask(SIG_SETMASK, &
mask,
NULL);
777 if (signal_buff.size != 0) {
779 if (signal_buff.cnt[i] > 0) {
790#if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
791static const char *received_signal;
792# define clear_received_signal() (void)(ruby_disable_gc = 0, received_signal = 0)
794# define clear_received_signal() ((void)0)
797#if defined(USE_SIGALTSTACK) || defined(_WIN32)
799# if defined __HAIKU__
800# define USE_UCONTEXT_REG 1
801# elif !(defined(HAVE_UCONTEXT_H) && (defined __i386__ || defined __x86_64__ || defined __amd64__))
802# elif defined __linux__
803# define USE_UCONTEXT_REG 1
804# elif defined __APPLE__
805# define USE_UCONTEXT_REG 1
806# elif defined __FreeBSD__
807# define USE_UCONTEXT_REG 1
809#if defined(HAVE_PTHREAD_SIGMASK)
810# define ruby_sigunmask pthread_sigmask
811#elif defined(HAVE_SIGPROCMASK)
812# define ruby_sigunmask sigprocmask
815reset_sigmask(
int sig)
817#if defined(ruby_sigunmask)
821#if defined(ruby_sigunmask)
823 sigaddset(&
mask, sig);
824 if (ruby_sigunmask(SIG_UNBLOCK, &
mask,
NULL)) {
830# ifdef USE_UCONTEXT_REG
832check_stack_overflow(
int sig,
const uintptr_t addr,
const ucontext_t *ctx)
834 const DEFINE_MCONTEXT_PTR(mctx, ctx);
835# if defined __linux__
837 const greg_t sp = mctx->gregs[REG_RSP];
838 const greg_t
bp = mctx->gregs[REG_RBP];
840 const greg_t sp = mctx->gregs[REG_ESP];
841 const greg_t
bp = mctx->gregs[REG_EBP];
843# elif defined __APPLE__
845# define MCTX_SS_REG(reg) __ss.__##reg
847# define MCTX_SS_REG(reg) ss.reg
849# if defined(__LP64__)
850 const uintptr_t sp = mctx->MCTX_SS_REG(rsp);
853 const uintptr_t sp = mctx->MCTX_SS_REG(esp);
856# elif defined __FreeBSD__
857# if defined(__amd64__)
858 const __register_t sp = mctx->mc_rsp;
859 const __register_t
bp = mctx->mc_rbp;
861 const __register_t sp = mctx->mc_esp;
862 const __register_t
bp = mctx->mc_ebp;
864# elif defined __HAIKU__
865# if defined(__amd64__)
866 const unsigned long sp = mctx->rsp;
867 const unsigned long bp = mctx->rbp;
869 const unsigned long sp = mctx->esp;
870 const unsigned long bp = mctx->ebp;
873 enum {pagesize = 4096};
876 const uintptr_t fault_page = addr / pagesize;
880 if (sp_page == fault_page || sp_page == fault_page + 1 ||
881 (sp_page <= fault_page && fault_page <= bp_page)) {
897check_stack_overflow(
int sig,
const void *addr)
899 int ruby_stack_overflowed_p(
const rb_thread_t *,
const void *);
901 if (ruby_stack_overflowed_p(th, addr)) {
908# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, 0)
910# define FAULT_ADDRESS info->si_addr
911# ifdef USE_UCONTEXT_REG
912# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, (uintptr_t)FAULT_ADDRESS, ctx)
914# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, FAULT_ADDRESS)
916# define MESSAGE_FAULT_ADDRESS " at %p", FAULT_ADDRESS
919# define CHECK_STACK_OVERFLOW() (void)0
921#ifndef MESSAGE_FAULT_ADDRESS
922# define MESSAGE_FAULT_ADDRESS
925#if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
926NOINLINE(
static void check_reserved_signal_(
const char *
name,
size_t name_len));
929#define check_reserved_signal(name) check_reserved_signal_(name, sizeof(name)-1)
939 check_reserved_signal(
"BUS");
946#if defined __APPLE__ || defined __linux__
961 check_reserved_signal(
"SEGV");
975 check_reserved_signal(
"ILL");
984NORETURN(
static void ruby_abort(
void));
1001check_reserved_signal_(
const char *
name,
size_t name_len)
1007#define NOZ(name, str) name[sizeof(str)-1] = str
1008 static const char NOZ(msg1,
" received in ");
1009 static const char NOZ(msg2,
" handler\n");
1012 struct iovec iov[4];
1015 iov[0].iov_len = name_len;
1016 iov[1].iov_base = (
void *)msg1;
1017 iov[1].iov_len =
sizeof(msg1);
1018 iov[2].iov_base = (
void *)prev;
1019 iov[2].iov_len =
strlen(prev);
1020 iov[3].iov_base = (
void *)msg2;
1021 iov[3].iov_len =
sizeof(msg2);
1022 err = writev(2, iov, 4);
1025 err =
write(2, msg1,
sizeof(msg1));
1027 err =
write(2, msg2,
sizeof(msg2));
1036#if defined SIGPIPE || defined SIGSYS
1038sig_do_nothing(
int sig)
1044signal_exec(
VALUE cmd,
int sig)
1083 signal_exec(trap_exit, 0);
1131 else if (cmd ==
Qundef) {
1135 return signal_exec(cmd, sig);
1141default_handler(
int sig)
1181 func = sig_do_nothing;
1186 func = sig_do_nothing;
1198trap_handler(
VALUE *cmd,
int sig)
1212 if (!
NIL_P(command)) {
1224 func = default_handler(sig);
1231 if (
memcmp(cptr,
"SYSTEM_DEFAULT", 14) == 0) {
1240 if (
memcmp(cptr,
"SIG_IGN", 7) == 0) {
1243 else if (
memcmp(cptr,
"SIG_DFL", 7) == 0) {
1246 else if (
memcmp(cptr,
"DEFAULT", 7) == 0) {
1251 if (
memcmp(cptr,
"IGNORE", 6) == 0) {
1256 if (
memcmp(cptr,
"EXIT", 4) == 0) {
1273trap_signm(
VALUE vsig)
1279 if (sig < 0 || sig >=
NSIG) {
1312 if (oldfunc == SIG_IGN) oldcmd =
rb_str_new2(
"IGNORE");
1313 else if (oldfunc == SIG_DFL) oldcmd =
rb_str_new2(
"SYSTEM_DEFAULT");
1314 else if (oldfunc == sighandler) oldcmd =
rb_str_new2(
"DEFAULT");
1330reserved_signal_p(
int signo)
1334 if (signo == SIGSEGV)
1338 if (signo == SIGBUS)
1342 if (signo == SIGILL)
1346 if (signo == SIGFPE)
1352 if (signo == SIGVTALRM)
1399 sig = trap_signm(
argv[0]);
1400 if (reserved_signal_p(sig)) {
1401 const char *
name = signo2signm(sig);
1414 func = trap_handler(&cmd, sig);
1418 !rb_ractor_main_p() && !rb_ractor_shareable_p(cmd)) {
1422 return trap(sig, func, cmd);
1438 const struct signals *sigs;
1446#define INSTALL_SIGHANDLER(cond, signame, signum) do { \
1447 static const char failed[] = "failed to install "signame" handler"; \
1448 if (!(cond)) break; \
1449 if (reserved_signal_p(signum)) rb_bug(failed); \
1458 if (old == SIG_ERR)
return -1;
1460 *old_handler = (old == SIG_DFL || old == SIG_IGN) ? 0 : old;
1464 if (old != SIG_DFL) {
1471# define install_sighandler(signum, handler) \
1472 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, NULL), #signum, signum)
1473# define force_install_sighandler(signum, handler, old_handler) \
1474 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, old_handler), #signum, signum)
1478init_sigchld(
int sig)
1484 if (oldfunc == SIG_ERR)
return -1;
1491# define init_sigchld(signum) \
1492 INSTALL_SIGHANDLER(init_sigchld(signum), #signum, signum)
1501 if (oldfunc == sighandler) {
1562 rb_disable_interrupt();
1607 rb_enable_interrupt();
1610#if defined(HAVE_GRANTPT)
1614fake_grantfd(
int masterfd)
1619#define grantpt(fd) fake_grantfd(fd)
1644 if (ret < 0) e = errno;
1648 if (ret < 0) errno = e;
#define UNREACHABLE_RETURN
#define rb_define_method(klass, mid, func, arity)
Defines klass#mid.
#define rb_define_module_function(klass, mid, func, arity)
Defines klass#mid and makes it a module function.
#define rb_define_global_function(mid, func, arity)
Defines rb_mKernel #mid.
void rb_debug_counter_show_results(const char *msg)
char str[HTML_ESCAPE_MAX_LEN+1]
#define EC_JUMP_TAG(ec, st)
VALUE rb_define_module(const char *name)
void ruby_sig_finalize(void)
void rb_raise(VALUE exc, const char *fmt,...)
void rb_interrupt(void)
Raises an Interrupt exception.
void rb_sys_fail_str(VALUE mesg)
void rb_bug_errno(const char *mesg, int errno_arg)
void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *ctx, const char *fmt,...)
void rb_sys_fail(const char *mesg)
VALUE rb_check_to_integer(VALUE, const char *)
Tries to convert val into Integer.
unsigned short prefix[65536]
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
Thin wrapper to ruby/config.h.
VALUE rb_call_super(int, const VALUE *)
#define UNLIMITED_ARGUMENTS
VALUE rb_obj_is_proc(VALUE)
VALUE rb_block_proc(void)
void rb_must_asciicompat(VALUE)
VALUE rb_check_string_type(VALUE)
VALUE rb_str_subseq(VALUE, long, long)
VALUE rb_str_append(VALUE, VALUE)
#define rb_str_new_cstr(str)
VALUE rb_thread_current(void)
VALUE rb_ivar_get(VALUE, ID)
VALUE rb_ivar_set(VALUE, ID, VALUE)
void rb_alias(VALUE, ID, ID)
VALUE rb_eval_cmd_kw(VALUE, VALUE, int)
Internal header for SignalException.
Internal header for String.
Internal header for Thread.
void rb_thread_execute_interrupts(VALUE th)
#define rb_fstring_cstr(...)
#define ACCESS_ONCE(type, x)
typedef int(ZCALLBACK *close_file_func) OF((voidpf opaque
int memcmp(const void *s1, const void *s2, size_t len)
#define RSTRING_GETMEM(str, ptrvar, lenvar)
const char * rb_obj_classname(VALUE)
#define ATOMIC_EXCHANGE(var, val)
#define ATOMIC_PTR_EXCHANGE(var, val)
Internal header for ASAN / MSAN / etc.
#define ruby_signal(sig, handler)
#define CHECK_STACK_OVERFLOW()
void ruby_sigaction_t(int)
#define GET_SIGCHLD_HIT()
void ruby_default_signal(int sig)
void ruby_sigchld_handler(rb_vm_t *vm)
const char * ruby_signal_name(int no)
#define force_install_sighandler(signum, handler, old_handler)
rb_atomic_t cnt[RUBY_NSIG]
#define FOREACH_SIGNAL(sig, offset)
int rb_signal_exec(rb_thread_t *th, int sig)
int rb_grantpt(int masterfd)
int rb_get_next_signal(void)
#define MESSAGE_FAULT_ADDRESS
void rb_malloc_info_show_results(void)
VALUE rb_f_kill(int argc, const VALUE *argv)
void rb_vm_trap_exit(rb_vm_t *vm)
int rb_signal_buff_size(void)
void ruby_waitpid_all(rb_vm_t *)
#define install_sighandler(signum, handler)
#define clear_received_signal()
VALUE rb_sprintf(const char *,...)
size_t strlen(const char *)
rb_atomic_t interrupt_mask
rb_execution_context_t * ec
struct rb_vm_struct::@195 trap_list
rb_nativethread_lock_t waitpid_lock
void rb_threadptr_check_signal(rb_thread_t *mth)
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
void rb_threadptr_signal_exit(rb_thread_t *th)
void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock)
void rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock)
VALUE rb_proc_isolate(VALUE self)
#define RB_ALTSTACK_INIT(var, altstack)
void rb_thread_wakeup_timer_thread(int)
#define GetProcPtr(obj, ptr)
void rb_ec_stack_overflow(rb_execution_context_t *ec, int crit)
#define VALGRIND_MAKE_MEM_DEFINED(p, n)
int write(ozstream &zs, const T *x, Items items)