Ruby
2.7.0p0(2019-12-25revision647ee6f091eafcce70ffb75ddf7e121e192ab217)
|
Go to the documentation of this file.
27 #ifdef HAVE_UCONTEXT_H
31 #ifdef HAVE_VALGRIND_MEMCHECK_H
32 # include <valgrind/memcheck.h>
33 # ifndef VALGRIND_MAKE_MEM_DEFINED
34 # define VALGRIND_MAKE_MEM_DEFINED(p, n) VALGRIND_MAKE_READABLE((p), (n))
36 # ifndef VALGRIND_MAKE_MEM_UNDEFINED
37 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) VALGRIND_MAKE_WRITABLE((p), (n))
40 # define VALGRIND_MAKE_MEM_DEFINED(p, n) 0
41 # define VALGRIND_MAKE_MEM_UNDEFINED(p, n) 0
44 #ifdef NEED_RUBY_ATOMIC_OPS
65 #define FOREACH_SIGNAL(sig, offset) \
66 for (sig = siglist + (offset); sig < siglist + numberof(siglist); ++sig)
68 static const struct signals {
178 {
"DANGER", SIGDANGER},
181 {
"MIGRATE", SIGMIGRATE},
190 {
"RETRACT", SIGRETRACT},
200 static const char signame_prefix[] =
"SIG";
201 static const int signame_prefix_len = 3;
204 signm2signo(
VALUE *sig_ptr,
int negative,
int exit,
int *prefix_ptr)
206 const struct signals *sigs;
207 VALUE vsig = *sig_ptr;
221 *sig_ptr = vsig =
str;
230 if (
len > 0 && nm[0] ==
'-') {
238 if (
len >= prefix + signame_prefix_len) {
239 if (
memcmp(nm + prefix, signame_prefix, signame_prefix_len) == 0)
240 prefix += signame_prefix_len;
242 if (
len <= (
long)prefix) {
244 if (prefix == signame_prefix_len) {
247 else if (prefix > signame_prefix_len) {
248 prefix -= signame_prefix_len;
256 prefix = signame_prefix_len;
259 prefix, signame_prefix, vsig);
262 if (prefix_ptr) *prefix_ptr = prefix;
263 nmlen =
len - prefix;
267 if (
memcmp(sigs->signm, nm, nmlen) == 0 &&
268 sigs->signm[nmlen] ==
'\0') {
269 return negative ? -sigs->signo : sigs->signo;
278 const struct signals *sigs;
281 if (sigs->signo == no)
304 const char *signame = signo2signm(
NUM2INT(signo));
305 if (!signame)
return Qnil;
312 return signo2signm(no);
316 rb_signo2signm(
int signo)
318 const char *
const signm = signo2signm(signo);
351 if (signo < 0 || signo >
NSIG) {
358 sig = rb_signo2signm(signo);
364 if (prefix != signame_prefix_len) {
382 esignal_signo(
VALUE self)
404 #if USE_DEBUG_COUNTER
414 static int signal_ignored(
int sig);
415 static void signal_enque(
int sig);
421 #define killpg(pg, sig) kill(-(pg), (sig))
453 if ((
sig != 0) && (
self != -1) && (pid ==
self)) {
479 t = signal_ignored(
sig);
510 #define sighandler_t ruby_sighandler_t
512 #ifdef USE_SIGALTSTACK
514 #define SIGINFO_ARG , siginfo_t *info, void *ctx
515 #define SIGINFO_CTX ctx
519 #define SIGINFO_CTX 0
522 #ifdef USE_SIGALTSTACK
524 rb_sigaltstack_size(
void)
532 if (
size < minsigstksz)
536 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE)
554 newSS.
ss_size = rb_sigaltstack_size();
571 rb_trap_accept_nativethreads[signum] = 0;
575 #ifdef USE_SIGALTSTACK
577 sigact.sa_handler = handler;
585 sigact.sa_handler = handler;
594 # ifdef USE_SIGALTSTACK
599 sigact.sa_handler = sighandler;
602 sigact.sa_handler = handler;
611 #if defined(SA_ONSTACK) && defined(USE_SIGALTSTACK)
627 handler =
old.sa_handler;
646 return signal(signum, handler);
650 #define ruby_signal(sig,handler) ( signal((sig),(handler)))
653 ruby_nativethread_signal(
int signum,
sighandler_t handler)
658 rb_trap_accept_nativethreads[signum] = 1;
665 signal_ignored(
int sig)
672 func =
old.sa_handler;
679 return func == sighandler ? 0 : -1;
683 signal_enque(
int sig)
692 # define GET_SIGCHLD_HIT() ATOMIC_EXCHANGE(sigchld_hit, 0)
694 # define GET_SIGCHLD_HIT() 0
700 int old_errnum =
errno;
718 #if !defined(BSD_SIGNAL) && !defined(POSIX_SIGNAL)
728 return signal_buff.size;
736 rb_disable_interrupt(
void)
738 #ifdef HAVE_PTHREAD_SIGMASK
746 rb_enable_interrupt(
void)
748 #ifdef HAVE_PTHREAD_SIGMASK
760 if (signal_buff.size != 0) {
762 if (signal_buff.cnt[
i] > 0) {
773 #if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
774 static const char *received_signal;
775 # define clear_received_signal() (void)(ruby_disable_gc = 0, received_signal = 0)
777 # define clear_received_signal() ((void)0)
780 #if defined(USE_SIGALTSTACK) || defined(_WIN32)
782 # if defined __HAIKU__
783 # define USE_UCONTEXT_REG 1
784 # elif !(defined(HAVE_UCONTEXT_H) && (defined __i386__ || defined __x86_64__ || defined __amd64__))
785 # elif defined __linux__
786 # define USE_UCONTEXT_REG 1
787 # elif defined __APPLE__
788 # define USE_UCONTEXT_REG 1
789 # elif defined __FreeBSD__
790 # define USE_UCONTEXT_REG 1
792 #if defined(HAVE_PTHREAD_SIGMASK)
793 # define ruby_sigunmask pthread_sigmask
794 #elif defined(HAVE_SIGPROCMASK)
795 # define ruby_sigunmask sigprocmask
798 reset_sigmask(
int sig)
800 #if defined(ruby_sigunmask)
804 #if defined(ruby_sigunmask)
813 # ifdef USE_UCONTEXT_REG
818 # if defined __linux__
820 const greg_t sp = mctx->gregs[REG_RSP];
821 const greg_t
bp = mctx->gregs[REG_RBP];
823 const greg_t sp = mctx->gregs[REG_ESP];
824 const greg_t
bp = mctx->gregs[REG_EBP];
826 # elif defined __APPLE__
828 # define MCTX_SS_REG(reg) __ss.__##reg
830 # define MCTX_SS_REG(reg) ss.reg
832 # if defined(__LP64__)
833 const uintptr_t sp = mctx->MCTX_SS_REG(rsp);
836 const uintptr_t sp = mctx->MCTX_SS_REG(esp);
839 # elif defined __FreeBSD__
840 # if defined(__amd64__)
841 const __register_t sp = mctx->mc_rsp;
842 const __register_t
bp = mctx->mc_rbp;
844 const __register_t sp = mctx->mc_esp;
845 const __register_t
bp = mctx->mc_ebp;
847 # elif defined __HAIKU__
848 # if defined(__amd64__)
849 const unsigned long sp = mctx->rsp;
850 const unsigned long bp = mctx->rbp;
852 const unsigned long sp = mctx->esp;
853 const unsigned long bp = mctx->ebp;
856 enum {pagesize = 4096};
859 const uintptr_t fault_page = addr / pagesize;
863 if (sp_page == fault_page || sp_page == fault_page + 1 ||
864 (sp_page <= fault_page && fault_page <= bp_page)) {
880 check_stack_overflow(
int sig,
const void *addr)
882 int ruby_stack_overflowed_p(
const rb_thread_t *,
const void *);
884 if (ruby_stack_overflowed_p(th, addr)) {
891 # define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, 0)
893 # define FAULT_ADDRESS info->si_addr
894 # ifdef USE_UCONTEXT_REG
895 # define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, (uintptr_t)FAULT_ADDRESS, ctx)
897 # define CHECK_STACK_OVERFLOW() check_stack_overflow(sig, FAULT_ADDRESS)
899 # define MESSAGE_FAULT_ADDRESS " at %p", FAULT_ADDRESS
902 # define CHECK_STACK_OVERFLOW() (void)0
904 #ifndef MESSAGE_FAULT_ADDRESS
905 # define MESSAGE_FAULT_ADDRESS
908 #if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE
909 NOINLINE(
static void check_reserved_signal_(
const char *
name,
size_t name_len));
912 #define check_reserved_signal(name) check_reserved_signal_(name, sizeof(name)-1)
922 check_reserved_signal(
"BUS");
929 #if defined __APPLE__ || defined __linux__
944 check_reserved_signal(
"SEGV");
958 check_reserved_signal(
"ILL");
959 #if defined __APPLE__
967 NORETURN(
static void ruby_abort(
void));
984 check_reserved_signal_(
const char *
name,
size_t name_len)
990 #define NOZ(name, str) name[sizeof(str)-1] = str
991 static const char NOZ(msg1,
" received in ");
992 static const char NOZ(msg2,
" handler\n");
998 iov[0].iov_len = name_len;
999 iov[1].iov_base = (
void *)msg1;
1000 iov[1].iov_len =
sizeof(msg1);
1001 iov[2].iov_base = (
void *)prev;
1002 iov[2].iov_len =
strlen(prev);
1003 iov[3].iov_base = (
void *)msg2;
1004 iov[3].iov_len =
sizeof(msg2);
1005 err = writev(2, iov, 4);
1008 err =
write(2, msg1,
sizeof(msg1));
1010 err =
write(2, msg2,
sizeof(msg2));
1019 #if defined SIGPIPE || defined SIGSYS
1021 sig_do_nothing(
int sig)
1066 signal_exec(trap_exit, 0);
1114 else if (cmd ==
Qundef) {
1118 return signal_exec(cmd,
sig);
1124 default_handler(
int sig)
1164 func = sig_do_nothing;
1169 func = sig_do_nothing;
1195 if (!
NIL_P(command)) {
1206 if (
memcmp(cptr,
"SYSTEM_DEFAULT", 14) == 0) {
1215 if (
memcmp(cptr,
"SIG_IGN", 7) == 0) {
1220 else if (
memcmp(cptr,
"SIG_DFL", 7) == 0) {
1222 func = default_handler(
sig);
1225 else if (
memcmp(cptr,
"DEFAULT", 7) == 0) {
1230 if (
memcmp(cptr,
"IGNORE", 6) == 0) {
1235 if (
memcmp(cptr,
"EXIT", 4) == 0) {
1252 trap_signm(
VALUE vsig)
1258 if (sig < 0 || sig >=
NSIG) {
1293 else if (oldfunc == sighandler) oldcmd =
rb_str_new2(
"DEFAULT");
1309 reserved_signal_p(
int signo)
1379 if (reserved_signal_p(
sig)) {
1380 const char *
name = signo2signm(
sig);
1393 func = trap_handler(&cmd,
sig);
1396 return trap(
sig, func, cmd);
1412 const struct signals *sigs;
1420 #define INSTALL_SIGHANDLER(cond, signame, signum) do { \
1421 static const char failed[] = "failed to install "signame" handler"; \
1422 if (!(cond)) break; \
1423 if (reserved_signal_p(signum)) rb_bug(failed); \
1445 # define install_sighandler(signum, handler) \
1446 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, NULL), #signum, signum)
1447 # define force_install_sighandler(signum, handler, old_handler) \
1448 INSTALL_SIGHANDLER(install_sighandler_core(signum, handler, old_handler), #signum, signum)
1452 init_sigchld(
int sig)
1458 if (oldfunc ==
SIG_ERR)
return -1;
1465 # define init_sigchld(signum) \
1466 INSTALL_SIGHANDLER(init_sigchld(signum), #signum, signum)
1475 if (oldfunc == sighandler) {
1536 rb_disable_interrupt();
1581 rb_enable_interrupt();
1584 #if defined(HAVE_GRANTPT)
1588 fake_grantfd(
int masterfd)
1593 #define grantpt(fd) fake_grantfd(fd)
1618 if (ret < 0) e =
errno;
1622 if (ret < 0)
errno = e;
#define VALGRIND_MAKE_MEM_DEFINED(p, n)
void ruby_waitpid_all(rb_vm_t *)
#define RSTRING_GETMEM(str, ptrvar, lenvar)
void rb_nativethread_lock_unlock(rb_nativethread_lock_t *lock)
#define ATOMIC_PTR_EXCHANGE(var, val)
#define ruby_signal(sig, handler)
void rb_threadptr_signal_exit(rb_thread_t *th)
void rb_bug_errno(const char *mesg, int errno_arg)
void rb_nativethread_lock_lock(rb_nativethread_lock_t *lock)
#define RB_TYPE_P(obj, type)
#define rb_intern_const(str)
VALUE rb_thread_current(void)
VALUE rb_define_module(const char *name)
VALUE rb_f_kill(int argc, const VALUE *argv)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
VALUE rb_call_super(int, const VALUE *)
#define EC_JUMP_TAG(ec, st)
void ruby_sigchld_handler(rb_vm_t *vm)
VALUE rb_check_string_type(VALUE)
int rb_signal_buff_size(void)
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
void rb_vm_trap_exit(rb_vm_t *vm)
void ruby_default_signal(int sig)
#define force_install_sighandler(signum, handler, old_handler)
size_t strlen(const char *)
void rb_bug_for_fatal_signal(ruby_sighandler_t default_sighandler, int sig, const void *ctx, const char *fmt,...)
rb_execution_context_t * ec
rb_atomic_t ruby_atomic_compare_and_swap(rb_atomic_t *ptr, rb_atomic_t cmp, rb_atomic_t newval)
#define UNLIMITED_ARGUMENTS
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_ivar_get(VALUE, ID)
void rb_alias(VALUE, ID, ID)
void rb_threadptr_check_signal(rb_thread_t *mth)
void rb_thread_execute_interrupts(VALUE th)
#define GET_SIGCHLD_HIT()
void rb_must_asciicompat(VALUE)
#define clear_received_signal()
VALUE rb_check_to_integer(VALUE, const char *)
Tries to convert val into Integer.
rb_atomic_t cnt[RUBY_NSIG]
int rb_get_next_signal(void)
void rb_malloc_info_show_results(void)
void rb_sys_fail(const char *mesg)
void rb_interrupt(void)
Raises an Interrupt exception.
VALUE rb_eval_cmd_kw(VALUE, VALUE, int)
int memcmp(const void *s1, const void *s2, size_t len)
void rb_thread_wakeup_timer_thread(int)
#define GetProcPtr(obj, ptr)
rb_atomic_t ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val)
#define ACCESS_ONCE(type, x)
void rb_debug_counter_show_results(const char *msg)
int rb_grantpt(int masterfd)
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for module.
VALUE rb_str_append(VALUE, VALUE)
#define CHECK_STACK_OVERFLOW()
#define RB_ALTSTACK_INIT(var)
void ruby_sig_finalize(void)
VALUE rb_sprintf(const char *format,...)
struct rb_vm_struct::@184 trap_list
VALUE rb_str_subseq(VALUE, long, long)
char str[HTML_ESCAPE_MAX_LEN+1]
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
#define ATOMIC_EXCHANGE(var, val)
#define FOREACH_SIGNAL(sig, offset)
rb_atomic_t interrupt_mask
const char * rb_obj_classname(VALUE)
void rb_sys_fail_str(VALUE mesg)
MJIT_STATIC void rb_ec_stack_overflow(rb_execution_context_t *ec, int crit)
int rb_signal_exec(rb_thread_t *th, int sig)
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
const char * ruby_signal_name(int no)
VALUE rb_ivar_set(VALUE, ID, VALUE)
RETSIGTYPE ruby_sigaction_t(int)
#define install_sighandler(signum, handler)
#define MESSAGE_FAULT_ADDRESS
rb_nativethread_lock_t waitpid_lock
VALUE rb_block_proc(void)