14#include "ruby/internal/config.h"
36#include "debug_counter.h"
37#include "eval_intern.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"
47#include "ractor_core.h"
50#ifdef NEED_RUBY_ATOMIC_OPS
71#define FOREACH_SIGNAL(sig, offset) \
72 for (sig = siglist + (offset); sig < siglist + numberof(siglist); ++sig)
73enum { LONGEST_SIGNAME = 7 };
75 char signm[LONGEST_SIGNAME + 1];
138 {
"CHLD", RUBY_SIGCHLD },
139 {
"CLD", RUBY_SIGCHLD },
157 {
"VTALRM", SIGVTALRM},
184 {
"DANGER", SIGDANGER},
187 {
"MIGRATE", SIGMIGRATE},
196 {
"RETRACT", SIGRETRACT},
206static const char signame_prefix[] =
"SIG";
207static const int signame_prefix_len = 3;
210signm2signo(
VALUE *sig_ptr,
int negative,
int exit,
int *prefix_ptr)
213 VALUE vsig = *sig_ptr;
224 rb_raise(rb_eArgError,
"bad signal type %s",
227 *sig_ptr = vsig = str;
232 if (memchr(nm,
'\0',
len)) {
233 rb_raise(rb_eArgError,
"signal name with null byte");
236 if (
len > 0 && nm[0] ==
'-') {
238 rb_raise(rb_eArgError,
"negative signal name: % "PRIsVALUE, vsig);
244 if (
len >= prefix + signame_prefix_len) {
245 if (memcmp(nm + prefix, signame_prefix, signame_prefix_len) == 0)
246 prefix += signame_prefix_len;
248 if (
len <= (
long)prefix) {
252 if (prefix_ptr) *prefix_ptr = prefix;
253 nmlen =
len - 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;
264 if (prefix == signame_prefix_len) {
267 else if (prefix > signame_prefix_len) {
268 prefix -= signame_prefix_len;
276 prefix = signame_prefix_len;
278 rb_raise(rb_eArgError,
"unsupported signal '%.*s%"PRIsVALUE
"'",
279 prefix, signame_prefix, vsig);
288 FOREACH_SIGNAL(sigs, 0) {
289 if (sigs->signo == no)
312 const char *signame = signo2signm(
NUM2INT(signo));
313 if (!signame)
return Qnil;
320 return signo2signm(no);
324rb_signo2signm(
int signo)
326 const char *
const signm = signo2signm(signo);
328 return rb_sprintf(
"SIG%s", signm);
331 return rb_sprintf(
"SIG%u", signo);
345esignal_init(
int argc,
VALUE *argv,
VALUE self)
353 if (!
NIL_P(sig)) argnum = 2;
359 if (signo < 0 || signo > NSIG) {
360 rb_raise(rb_eArgError,
"invalid signal number (%d)", signo);
366 sig = rb_signo2signm(signo);
371 signo = signm2signo(&sig, FALSE, FALSE, &prefix);
372 if (prefix != signame_prefix_len) {
390esignal_signo(
VALUE self)
397interrupt_init(
int argc,
VALUE *argv,
VALUE self)
406#if defined(USE_SIGALTSTACK) || defined(_WIN32)
407static void reset_sigmask(
int sig);
414 rb_debug_counter_show_results(
"killed by signal.");
417 signal(sig, SIG_DFL);
418#if defined(USE_SIGALTSTACK) || defined(_WIN32)
424static void sighandler(
int sig);
425static int signal_ignored(
int sig);
426static void signal_enque(
int sig);
432#define killpg(pg, sig) kill(-(pg), (sig))
445 sig = signm2signo(&str, TRUE, FALSE, NULL);
448 if (argc <= 1)
return INT2FIX(0);
452 for (i=1; i<argc; i++) {
453 if (killpg(
NUM2PIDT(argv[i]), sig) < 0)
458 const rb_pid_t self = (GET_THREAD() == GET_VM()->ractor.main_thread) ? getpid() : -1;
461 for (i=1; i<argc; i++) {
464 if ((sig != 0) && (self != -1) && (pid == self)) {
490 t = signal_ignored(sig);
492 if (t < 0 && kill(pid, sig))
500 else if (kill(pid, sig) < 0) {
505 rb_threadptr_check_signal(GET_VM()->ractor.main_thread);
518#define sighandler_t ruby_sighandler_t
520#ifdef USE_SIGALTSTACK
521typedef void ruby_sigaction_t(
int, siginfo_t*,
void*);
522#define SIGINFO_ARG , siginfo_t *info, void *ctx
523#define SIGINFO_CTX ctx
525typedef void ruby_sigaction_t(
int);
530#ifdef USE_SIGALTSTACK
532#define RUBY_SIGALTSTACK_SIZE (16*1024)
535rb_sigaltstack_size(
void)
537 int size = RUBY_SIGALTSTACK_SIZE;
541 int minsigstksz = (int)MINSIGSTKSZ;
542 if (size < minsigstksz)
546#if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
549 pagesize = (int)sysconf(_SC_PAGE_SIZE);
558static int rb_sigaltstack_size_value = 0;
561rb_allocate_sigaltstack(
void)
564 if (!rb_sigaltstack_size_value) {
565 rb_sigaltstack_size_value = rb_sigaltstack_size();
567 altstack = malloc(rb_sigaltstack_size_value);
568 if (!altstack) rb_memerror();
574rb_register_sigaltstack(
void *altstack)
576 stack_t newSS, oldSS;
578 newSS.ss_size = rb_sigaltstack_size_value;
579 newSS.ss_sp = altstack;
582 sigaltstack(&newSS, &oldSS);
590ruby_signal(
int signum, sighandler_t handler)
592 struct sigaction sigact, old;
595 rb_trap_accept_nativethreads[signum] = 0;
598 sigemptyset(&sigact.sa_mask);
599#if defined(USE_SIGALTSTACK) && !defined(__wasm__)
600 if (handler == SIG_IGN || handler == SIG_DFL) {
601 sigact.sa_handler = handler;
605 sigact.sa_sigaction = (ruby_sigaction_t*)handler;
606 sigact.sa_flags = SA_SIGINFO;
609 sigact.sa_handler = handler;
614#if defined(SA_ONSTACK) && defined(USE_SIGALTSTACK)
619 sigact.sa_flags |= SA_ONSTACK;
623 (void)VALGRIND_MAKE_MEM_DEFINED(&old,
sizeof(old));
624 if (sigaction(signum, &sigact, &old) < 0) {
627 if (old.sa_flags & SA_SIGINFO)
628 handler = (sighandler_t)old.sa_sigaction;
630 handler = old.sa_handler;
631 ASSUME(handler != SIG_ERR);
636ruby_posix_signal(
int signum, sighandler_t handler)
638 return ruby_signal(signum, handler);
642static inline sighandler_t
643ruby_signal(
int signum, sighandler_t handler)
645 if (signum == SIGKILL) {
649 return signal(signum, handler);
653#define ruby_signal(sig,handler) ( signal((sig),(handler)))
656ruby_nativethread_signal(
int signum, sighandler_t handler)
660 old = signal(signum, handler);
661 rb_trap_accept_nativethreads[signum] = 1;
668signal_ignored(
int sig)
672 struct sigaction old;
673 (void)VALGRIND_MAKE_MEM_DEFINED(&old,
sizeof(old));
674 if (sigaction(sig, NULL, &old) < 0)
return FALSE;
675 func = old.sa_handler;
678 sighandler_t old = signal(sig, SIG_DFL);
682 if (func == SIG_IGN)
return 1;
683 return func == sighandler ? 0 : -1;
689 ATOMIC_INC(signal_buff.cnt[sig]);
690 ATOMIC_INC(signal_buff.size);
696 int old_errnum =
errno;
699 rb_thread_wakeup_timer_thread(sig);
701#if !defined(BSD_SIGNAL) && !defined(POSIX_SIGNAL)
702 ruby_signal(sig, sighandler);
709rb_signal_buff_size(
void)
715rb_disable_interrupt(
void)
717#ifdef HAVE_PTHREAD_SIGMASK
720 pthread_sigmask(SIG_SETMASK, &mask, NULL);
725rb_enable_interrupt(
void)
727#ifdef HAVE_PTHREAD_SIGMASK
730 pthread_sigmask(SIG_SETMASK, &mask, NULL);
735rb_get_next_signal(
void)
739 if (rb_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);
752#if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
753static const char *received_signal;
754# define clear_received_signal() do { \
755 if (GET_VM() != NULL) rb_gc_enable(); \
756 received_signal = 0; \
759# define clear_received_signal() ((void)0)
762#if defined(USE_SIGALTSTACK) || defined(_WIN32)
764# if defined __HAIKU__
765# define USE_UCONTEXT_REG 1
766# elif !(defined(HAVE_UCONTEXT_H) && (defined __i386__ || defined __x86_64__ || defined __amd64__))
767# elif defined __linux__
768# define USE_UCONTEXT_REG 1
769# elif defined __APPLE__
770# define USE_UCONTEXT_REG 1
771# elif defined __FreeBSD__
772# define USE_UCONTEXT_REG 1
774#if defined(HAVE_PTHREAD_SIGMASK)
775# define ruby_sigunmask pthread_sigmask
776#elif defined(HAVE_SIGPROCMASK)
777# define ruby_sigunmask sigprocmask
780reset_sigmask(
int sig)
782#if defined(ruby_sigunmask)
785 clear_received_signal();
786#if defined(ruby_sigunmask)
788 sigaddset(&mask, sig);
789 if (ruby_sigunmask(SIG_UNBLOCK, &mask, NULL)) {
795# ifdef USE_UCONTEXT_REG
797check_stack_overflow(
int sig,
const uintptr_t addr,
const ucontext_t *ctx)
799 const DEFINE_MCONTEXT_PTR(mctx, ctx);
800# if defined __linux__
802 const greg_t sp = mctx->gregs[REG_RSP];
803 const greg_t bp = mctx->gregs[REG_RBP];
805 const greg_t sp = mctx->gregs[REG_ESP];
806 const greg_t bp = mctx->gregs[REG_EBP];
808# elif defined __APPLE__
809# include <AvailabilityMacros.h>
810# if defined(MAC_OS_X_VERSION_10_5) && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
811# define MCTX_SS_REG(reg) __ss.__##reg
813# define MCTX_SS_REG(reg) ss.reg
815# if defined(__LP64__)
816 const uintptr_t sp = mctx->MCTX_SS_REG(rsp);
817 const uintptr_t bp = mctx->MCTX_SS_REG(rbp);
819 const uintptr_t sp = mctx->MCTX_SS_REG(esp);
820 const uintptr_t bp = mctx->MCTX_SS_REG(ebp);
822# elif defined __FreeBSD__
823# if defined(__amd64__)
824 const __register_t sp = mctx->mc_rsp;
825 const __register_t bp = mctx->mc_rbp;
827 const __register_t sp = mctx->mc_esp;
828 const __register_t bp = mctx->mc_ebp;
830# elif defined __HAIKU__
831# if defined(__amd64__)
832 const unsigned long sp = mctx->rsp;
833 const unsigned long bp = mctx->rbp;
835 const unsigned long sp = mctx->esp;
836 const unsigned long bp = mctx->ebp;
839 enum {pagesize = 4096};
840 const uintptr_t sp_page = (uintptr_t)sp / pagesize;
841 const uintptr_t bp_page = (uintptr_t)bp / pagesize;
842 const uintptr_t fault_page = addr / pagesize;
846 if (sp_page == fault_page || sp_page == fault_page + 1 ||
847 (sp_page <= fault_page && fault_page <= bp_page)) {
850 int uplevel = roomof(pagesize,
sizeof(*ec->tag)) / 2;
851 while ((uintptr_t)ec->tag->buf / pagesize <= fault_page + 1) {
855 if ((crit = (!ec->tag->prev || !--uplevel)) != FALSE)
break;
856 rb_vm_tag_jmpbuf_deinit(&ec->tag->buf);
857 ec->tag = ec->tag->prev;
860 rb_ec_stack_overflow(ec, crit + 1);
865check_stack_overflow(
int sig,
const void *addr)
867 int ruby_stack_overflowed_p(
const rb_thread_t *,
const void *);
869 if (ruby_stack_overflowed_p(th, addr)) {
871 rb_ec_stack_overflow(th->ec, 1);
877# define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, 0)
879# define FAULT_ADDRESS info->si_addr
880# ifdef USE_UCONTEXT_REG
881# define CHECK_STACK_OVERFLOW_() check_stack_overflow(sig, (uintptr_t)FAULT_ADDRESS, ctx)
883# define CHECK_STACK_OVERFLOW_() check_stack_overflow(sig, FAULT_ADDRESS)
885# define MESSAGE_FAULT_ADDRESS " at %p", FAULT_ADDRESS
886# define SIGNAL_FROM_USER_P() ((info)->si_code == SI_USER)
887# define CHECK_STACK_OVERFLOW() (SIGNAL_FROM_USER_P() ? (void)0 : CHECK_STACK_OVERFLOW_())
890# define CHECK_STACK_OVERFLOW() (void)0
892#ifndef MESSAGE_FAULT_ADDRESS
893# define MESSAGE_FAULT_ADDRESS
896#if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
897NOINLINE(
static void check_reserved_signal_(
const char *name,
size_t name_len,
int signo));
900#define check_reserved_signal(name) check_reserved_signal_(name, sizeof(name)-1, sig)
904static sighandler_t default_sigbus_handler;
905NORETURN(
static ruby_sigaction_t sigbus);
908sigbus(
int sig SIGINFO_ARG)
910 check_reserved_signal(
"BUS");
917#if defined __APPLE__ || defined __linux__
918 CHECK_STACK_OVERFLOW();
920 rb_bug_for_fatal_signal(default_sigbus_handler, sig, SIGINFO_CTX,
"Bus Error" MESSAGE_FAULT_ADDRESS);
926static sighandler_t default_sigsegv_handler;
927NORETURN(
static ruby_sigaction_t sigsegv);
930sigsegv(
int sig SIGINFO_ARG)
932 check_reserved_signal(
"SEGV");
933 CHECK_STACK_OVERFLOW();
934 rb_bug_for_fatal_signal(default_sigsegv_handler, sig, SIGINFO_CTX,
"Segmentation fault" MESSAGE_FAULT_ADDRESS);
940static sighandler_t default_sigill_handler;
941NORETURN(
static ruby_sigaction_t sigill);
944sigill(
int sig SIGINFO_ARG)
946 check_reserved_signal(
"ILL");
947#if defined __APPLE__ || defined __linux__
948 CHECK_STACK_OVERFLOW();
950 rb_bug_for_fatal_signal(default_sigill_handler, sig, SIGINFO_CTX,
"Illegal instruction" MESSAGE_FAULT_ADDRESS);
955NORETURN(
static void ruby_abort(
void));
972check_reserved_signal_(
const char *name,
size_t name_len,
int signo)
974 const char *prev = ATOMIC_PTR_EXCHANGE(received_signal, name);
977 ssize_t RB_UNUSED_VAR(err);
978 static const int stderr_fd = 2;
979#define NOZ(name, str) RBIMPL_ATTR_NONSTRING() name[sizeof(str)-1] = str
980 static const char NOZ(msg1,
" received in ");
981 static const char NOZ(msg2,
" handler\n");
986# define W(str, len) \
987 iov[i++] = (struct iovec){.iov_base = (void *)(str), .iov_len = (len)}
989# define W(str, len) err = write(stderr_fd, (str), (len))
992#if __has_feature(address_sanitizer) || \
993 __has_feature(memory_sanitizer) || \
994 defined(HAVE_VALGRIND_MEMCHECK_H)
995 ruby_posix_signal(signo, SIG_DFL);
998 W(msg1,
sizeof(msg1));
999 W(prev, strlen(prev));
1000 W(msg2,
sizeof(msg2));
1003 err = writev(stderr_fd, iov, i);
1008 if (GET_VM() != NULL) {
1009 rb_gc_disable_no_rest();
1014#if defined SIGPIPE || defined SIGSYS
1016sig_do_nothing(
int sig)
1022signal_exec(
VALUE cmd,
int sig)
1025 volatile rb_atomic_t old_interrupt_mask = ec->interrupt_mask;
1026 enum ruby_tag_type state;
1037 ec->interrupt_mask |= TRAP_INTERRUPT_MASK;
1039 if ((state = EC_EXEC_TAG()) == TAG_NONE) {
1045 ec->interrupt_mask = old_interrupt_mask;
1049 EC_JUMP_TAG(ec, state);
1057 VALUE trap_exit = vm->trap_list.cmd[0];
1060 vm->trap_list.cmd[0] = 0;
1061 signal_exec(trap_exit, 0);
1070 VALUE cmd = vm->trap_list.cmd[sig];
1095 rb_threadptr_signal_raise(th, sig);
1099 else if (UNDEF_P(cmd)) {
1100 rb_threadptr_signal_exit(th);
1103 return signal_exec(cmd, sig);
1109default_handler(
int sig)
1139 func = (sighandler_t)sigbus;
1144 func = (sighandler_t)sigsegv;
1149 func = sig_do_nothing;
1154 func = sig_do_nothing;
1166trap_handler(
VALUE *cmd,
int sig)
1168 sighandler_t func = sighandler;
1178 if (!command) rb_raise(rb_eArgError,
"bad handler");
1180 if (!
NIL_P(command)) {
1192 func = default_handler(sig);
1199 if (memcmp(cptr,
"SYSTEM_DEFAULT", 14) == 0) {
1205 if (memcmp(cptr,
"SIG_IGN", 7) == 0) {
1208 else if (memcmp(cptr,
"SIG_DFL", 7) == 0) {
1211 else if (memcmp(cptr,
"DEFAULT", 7) == 0) {
1216 if (memcmp(cptr,
"IGNORE", 6) == 0) {
1221 if (memcmp(cptr,
"EXIT", 4) == 0) {
1229 GetProcPtr(*cmd, proc);
1238trap_signm(
VALUE vsig)
1244 if (sig < 0 || sig >= NSIG) {
1245 rb_raise(rb_eArgError,
"invalid signal number (%d)", sig);
1249 sig = signm2signo(&vsig, FALSE, TRUE, NULL);
1255trap(
int sig, sighandler_t func,
VALUE command)
1257 sighandler_t oldfunc;
1270 oldfunc = ruby_signal(sig, func);
1271 if (oldfunc == SIG_ERR) rb_sys_fail_str(rb_signo2signm(sig));
1273 oldcmd = vm->trap_list.cmd[sig];
1277 if (oldfunc == SIG_IGN) oldcmd =
rb_str_new2(
"IGNORE");
1278 else if (oldfunc == SIG_DFL) oldcmd =
rb_str_new2(
"SYSTEM_DEFAULT");
1279 else if (oldfunc == sighandler) oldcmd =
rb_str_new2(
"DEFAULT");
1289 ACCESS_ONCE(
VALUE, vm->trap_list.cmd[sig]) = command;
1295reserved_signal_p(
int signo)
1299 if (signo == SIGSEGV)
1303 if (signo == SIGBUS)
1307 if (signo == SIGILL)
1311 if (signo == SIGFPE)
1317 if (signo == SIGVTALRM)
1364 sig = trap_signm(argv[0]);
1365 if (reserved_signal_p(sig)) {
1366 const char *name = signo2signm(sig);
1368 rb_raise(rb_eArgError,
"can't trap reserved signal: SIG%s", name);
1370 rb_raise(rb_eArgError,
"can't trap reserved signal: %d", sig);
1379 func = trap_handler(&cmd, sig);
1384 cmd = rb_proc_isolate(cmd);
1387 return trap(sig, func, cmd);
1402 VALUE h = rb_hash_new();
1405 FOREACH_SIGNAL(sigs, 0) {
1406 rb_hash_aset(h, rb_fstring_cstr(sigs->signm),
INT2FIX(sigs->signo));
1411#define INSTALL_SIGHANDLER(cond, signame, signum) do { \
1412 static const char failed[] = "failed to install "signame" handler"; \
1413 if (!(cond)) break; \
1414 if (reserved_signal_p(signum)) rb_bug(failed); \
1419install_sighandler_core(
int signum, sighandler_t handler, sighandler_t *old_handler)
1423 old = ruby_signal(signum, handler);
1424 if (old == SIG_ERR)
return -1;
1426 *old_handler = (old == SIG_DFL || old == SIG_IGN) ? 0 : old;
1430 if (old != SIG_DFL) {
1431 ruby_signal(signum, old);
1437# define install_sighandler(signum, handler) \
1438 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, NULL), #signum, signum)
1439# define force_install_sighandler(signum, handler, old_handler) \
1440 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, old_handler), #signum, signum)
1445 sighandler_t oldfunc;
1447 oldfunc = ruby_signal(SIGINT, SIG_IGN);
1448 if (oldfunc == sighandler) {
1449 ruby_signal(SIGINT, SIG_DFL);
1453int ruby_enable_coredump = 0;
1508 VM_ASSERT(GET_THREAD()->pending_interrupt_queue);
1511 rb_disable_interrupt();
1513 install_sighandler(SIGINT, sighandler);
1515 install_sighandler(SIGHUP, sighandler);
1518 install_sighandler(SIGQUIT, sighandler);
1521 install_sighandler(SIGTERM, sighandler);
1524 install_sighandler(SIGALRM, sighandler);
1527 install_sighandler(SIGUSR1, sighandler);
1530 install_sighandler(SIGUSR2, sighandler);
1533 if (!ruby_enable_coredump) {
1535 force_install_sighandler(SIGBUS, (sighandler_t)sigbus, &default_sigbus_handler);
1538 force_install_sighandler(SIGILL, (sighandler_t)sigill, &default_sigill_handler);
1541 RB_ALTSTACK_INIT(GET_VM()->main_altstack, rb_allocate_sigaltstack());
1542 force_install_sighandler(SIGSEGV, (sighandler_t)sigsegv, &default_sigsegv_handler);
1546 install_sighandler(SIGPIPE, sig_do_nothing);
1549 install_sighandler(SIGSYS, sig_do_nothing);
1553 install_sighandler(RUBY_SIGCHLD, sighandler);
1556 rb_enable_interrupt();
std::atomic< unsigned > rb_atomic_t
Type that is eligible for atomic operations.
#define RUBY_ATOMIC_LOAD(var)
Atomic load.
#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.
VALUE rb_define_module(const char *name)
Defines a top-level module.
#define rb_str_new2
Old name of rb_str_new_cstr.
#define T_STRING
Old name of RUBY_T_STRING.
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
#define FIX2INT
Old name of RB_FIX2INT.
#define ASSUME
Old name of RBIMPL_ASSUME.
#define rb_ary_new3
Old name of rb_ary_new_from_args.
#define Qtrue
Old name of RUBY_Qtrue.
#define NUM2INT
Old name of RB_NUM2INT.
#define INT2NUM
Old name of RB_INT2NUM.
#define Qnil
Old name of RUBY_Qnil.
#define NIL_P
Old name of RB_NIL_P.
#define IMMEDIATE_P
Old name of RB_IMMEDIATE_P.
#define FIXNUM_P
Old name of RB_FIXNUM_P.
#define SYMBOL_P
Old name of RB_SYMBOL_P.
void ruby_sig_finalize(void)
Clear signal handlers.
VALUE rb_eInterrupt
Interrupt exception.
void rb_bug_errno(const char *mesg, int errno_arg)
This is a wrapper of rb_bug() which automatically constructs appropriate message from the passed errn...
VALUE rb_eSignal
SignalException exception.
VALUE rb_check_to_integer(VALUE val, const char *mid)
Identical to rb_check_convert_type(), except the return value type is fixed to rb_cInteger.
VALUE rb_call_super(int argc, const VALUE *argv)
This resembles ruby's super.
#define UNLIMITED_ARGUMENTS
This macro is used in conjunction with rb_check_arity().
static int rb_check_arity(int argc, int min, int max)
Ensures that the passed integer is in the passed range.
VALUE rb_block_proc(void)
Constructs a Proc object from implicitly passed components.
VALUE rb_obj_is_proc(VALUE recv)
Queries if the given object is a proc.
void ruby_default_signal(int sig)
Pretends as if there was no custom signal handler.
const char * ruby_signal_name(int signo)
Queries the name of the signal.
VALUE rb_f_kill(int argc, const VALUE *argv)
Sends a signal ("kills") to processes.
VALUE rb_str_append(VALUE dst, VALUE src)
Identical to rb_str_buf_append(), except it converts the right hand side before concatenating.
VALUE rb_str_subseq(VALUE str, long beg, long len)
Identical to rb_str_substr(), except the numbers are interpreted as byte offsets instead of character...
void rb_must_asciicompat(VALUE obj)
Asserts that the given string's encoding is (Ruby's definition of) ASCII compatible.
VALUE rb_check_string_type(VALUE obj)
Try converting an object to its stringised representation using its to_str method,...
#define rb_str_new_cstr(str)
Identical to rb_str_new, except it assumes the passed pointer is a pointer to a C string.
VALUE rb_thread_current(void)
Obtains the "current" thread.
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
VALUE rb_ivar_get(VALUE obj, ID name)
Identical to rb_iv_get(), except it accepts the name as an ID instead of a C string.
void rb_alias(VALUE klass, ID dst, ID src)
Resembles alias.
VALUE rb_eval_cmd_kw(VALUE cmd, VALUE arg, int kw_splat)
This API is practically a variant of rb_proc_call_kw() now.
static ID rb_intern_const(const char *str)
This is a "tiny optimisation" over rb_intern().
VALUE rb_sym2str(VALUE symbol)
Obtain a frozen string representation of a symbol (not including the leading colon).
int len
Length of the buffer.
static bool rb_ractor_shareable_p(VALUE obj)
Queries if multiple Ractors can share the passed object or not.
Defines RBIMPL_ATTR_NONSTRING.
#define NUM2PIDT
Converts an instance of rb_cNumeric into C's pid_t.
#define StringValue(v)
Ensures that the parameter object is a String.
#define RSTRING_GETMEM(str, ptrvar, lenvar)
Convenient macro to obtain the contents and length at once.
const char * rb_obj_classname(VALUE obj)
Queries the name of the class of the passed object.
#define errno
Ractor-aware version of errno.
#define RB_NO_KEYWORDS
Do not pass keywords.
#define _(args)
This was a transition path from K&R to ANSI.
uintptr_t VALUE
Type that represents a Ruby object.
static bool RB_SYMBOL_P(VALUE obj)
Queries if the object is an instance of rb_cSymbol.
static bool RB_TYPE_P(VALUE obj, enum ruby_value_type t)
Queries if the given object is of given type.