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 #if defined(__native_client__) && defined(NACL_NEWLIB) 49 #define id_signo ruby_static_id_signo 51 #ifdef NEED_RUBY_ATOMIC_OPS 73 # define NSIG (_SIGMAX + 1) 165 {
"VTALRM", SIGVTALRM},
192 {
"DANGER", SIGDANGER},
195 {
"MIGRATE", SIGMIGRATE},
204 {
"RETRACT", SIGRETRACT},
223 if (strcmp(sigs->
signm, nm) == 0)
234 if (sigs->
signo == no)
257 if (!signame)
return Qnil;
298 if (!
NIL_P(sig)) argnum = 2;
304 if (signo < 0 || signo >
NSIG) {
362 signal(sig, SIG_DFL);
410 #define killpg(pg, sig) kill(-(pg), (sig)) 420 switch (
TYPE(argv[0])) {
459 if (argc <= 1)
return INT2FIX(0);
463 for (i=1; i<
argc; i++) {
469 const rb_pid_t
self = (
GET_THREAD() ==
GET_VM()->main_thread) ? getpid() : -1;
472 for (i=1; i<
argc; i++) {
475 if ((sig != 0) && (
self != -1) && (pid ==
self)) {
503 if (t < 0 &&
kill(pid, sig))
511 else if (
kill(pid, sig) < 0) {
530 #define sighandler_t sh_t 532 #define sighandler_t ruby_sighandler_t 536 #ifdef USE_SIGALTSTACK 538 #define SIGINFO_ARG , siginfo_t *info, void *ctx 539 #define SIGINFO_CTX ctx 543 #define SIGINFO_CTX 0 546 #ifdef USE_SIGALTSTACK 554 if (size < MINSIGSTKSZ)
557 #if defined(HAVE_SYSCONF) && defined(_SC_PAGE_SIZE) 560 pagesize = (int)sysconf(_SC_PAGE_SIZE);
573 stack_t newSS, oldSS;
576 rb_bug(
"rb_register_sigaltstack: th->altstack not initialized\n");
578 newSS.ss_sp = th->altstack;
582 sigaltstack(&newSS, &oldSS);
590 struct sigaction sigact, old;
593 rb_trap_accept_nativethreads[signum] = 0;
596 sigemptyset(&sigact.sa_mask);
597 #ifdef USE_SIGALTSTACK 598 if (handler == SIG_IGN || handler == SIG_DFL) {
599 sigact.sa_handler = handler;
604 sigact.sa_flags = SA_SIGINFO;
607 sigact.sa_handler = handler;
614 if (handler == SIG_IGN)
615 sigact.sa_flags |= SA_NOCLDWAIT;
618 #if defined(SA_ONSTACK) && defined(USE_SIGALTSTACK) 623 sigact.sa_flags |= SA_ONSTACK;
628 if (sigaction(signum, &sigact, &old) < 0) {
631 if (old.sa_flags & SA_SIGINFO)
634 return old.sa_handler;
651 return signal(signum, handler);
655 #define ruby_signal(sig,handler) ( signal((sig),(handler))) 658 ruby_nativethread_signal(
int signum,
sighandler_t handler)
662 old = signal(signum, handler);
663 rb_trap_accept_nativethreads[signum] = 1;
674 struct sigaction old;
676 if (sigaction(sig,
NULL, &old) < 0)
return FALSE;
677 func = old.sa_handler;
683 if (func == SIG_IGN)
return 1;
697 int old_errnum =
errno;
701 #if !defined(BSD_SIGNAL) && !defined(POSIX_SIGNAL) 721 #ifdef HAVE_PTHREAD_SIGMASK 724 pthread_sigmask(SIG_SETMASK, &mask,
NULL);
731 #ifdef HAVE_PTHREAD_SIGMASK 734 pthread_sigmask(SIG_SETMASK, &mask,
NULL);
756 #if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE 757 static const char *received_signal;
758 # define clear_received_signal() (void)(ruby_disable_gc = 0, received_signal = 0) 760 # define clear_received_signal() ((void)0) 763 #if defined(USE_SIGALTSTACK) || defined(_WIN32) 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 775 # ifdef USE_UCONTEXT_REG 777 check_stack_overflow(
const uintptr_t addr,
const ucontext_t *ctx)
779 const DEFINE_MCONTEXT_PTR(mctx, ctx);
780 # if defined __linux__ 782 const greg_t sp = mctx->gregs[REG_RSP];
783 const greg_t
bp = mctx->gregs[REG_RBP];
785 const greg_t sp = mctx->gregs[REG_ESP];
786 const greg_t bp = mctx->gregs[REG_EBP];
788 # elif defined __APPLE__ 789 # if defined(__LP64__) 796 # elif defined __FreeBSD__ 797 # if defined(__amd64__) 798 const __register_t sp = mctx->mc_rsp;
799 const __register_t bp = mctx->mc_rbp;
801 const __register_t sp = mctx->mc_esp;
802 const __register_t bp = mctx->mc_ebp;
804 # elif defined __HAIKU__ 805 # if defined(__amd64__) 806 const unsigned long sp = mctx->rsp;
807 const unsigned long bp = mctx->rbp;
809 const unsigned long sp = mctx->esp;
810 const unsigned long bp = mctx->ebp;
813 enum {pagesize = 4096};
816 const uintptr_t fault_page = addr / pagesize;
820 if (sp_page == fault_page || sp_page == fault_page + 1 ||
821 sp_page <= fault_page && fault_page <= bp_page) {
835 check_stack_overflow(
const void *addr)
837 int ruby_stack_overflowed_p(
const rb_thread_t *,
const void *);
839 if (ruby_stack_overflowed_p(th, addr)) {
846 # define CHECK_STACK_OVERFLOW() check_stack_overflow(0) 848 # define FAULT_ADDRESS info->si_addr 849 # ifdef USE_UCONTEXT_REG 850 # define CHECK_STACK_OVERFLOW() check_stack_overflow((uintptr_t)FAULT_ADDRESS, ctx) 852 # define CHECK_STACK_OVERFLOW() check_stack_overflow(FAULT_ADDRESS) 854 # define MESSAGE_FAULT_ADDRESS " at %p", FAULT_ADDRESS 857 # define CHECK_STACK_OVERFLOW() (void)0 859 #ifndef MESSAGE_FAULT_ADDRESS 860 # define MESSAGE_FAULT_ADDRESS 863 #if defined SIGSEGV || defined SIGBUS || defined SIGILL || defined SIGFPE 864 NOINLINE(
static void check_reserved_signal_(
const char *
name,
size_t name_len));
867 #define check_reserved_signal(name) check_reserved_signal_(name, sizeof(name)-1) 873 check_reserved_signal(
"BUS");
880 #if defined __APPLE__ || defined __linux__ 905 check_reserved_signal(
"SEGV");
915 check_reserved_signal(
"ILL");
916 #if defined __APPLE__ 924 check_reserved_signal_(
const char *
name,
size_t name_len)
930 #define NOZ(name, str) name[sizeof(str)-1] = str 931 static const char NOZ(msg1,
" received in ");
932 static const char NOZ(msg2,
" handler\n");
938 iov[0].iov_len = name_len;
939 iov[1].iov_base = (
void *)msg1;
940 iov[1].iov_len =
sizeof(msg1);
941 iov[2].iov_base = (
void *)prev;
942 iov[2].iov_len =
strlen(prev);
943 iov[3].iov_base = (
void *)msg2;
944 iov[3].iov_len =
sizeof(msg2);
945 err = writev(2, iov, 4);
947 err = write(2, name, name_len);
948 err = write(2, msg1,
sizeof(msg1));
950 err = write(2, msg2,
sizeof(msg2));
959 #if defined SIGPIPE || defined SIGSYS 961 sig_do_nothing(
int sig)
970 volatile unsigned long old_interrupt_mask = cur_th->
interrupt_mask;
1044 else if (cmd ==
Qundef) {
1090 func = sig_do_nothing;
1095 func = sig_do_nothing;
1121 if (!
NIL_P(command)) {
1132 if (
memcmp(cptr,
"SYSTEM_DEFAULT", 14) == 0) {
1138 if (
memcmp(cptr,
"SIG_IGN", 7) == 0) {
1143 else if (
memcmp(cptr,
"SIG_DFL", 7) == 0) {
1148 else if (
memcmp(cptr,
"DEFAULT", 7) == 0) {
1153 if (
memcmp(cptr,
"IGNORE", 6) == 0) {
1158 if (
memcmp(cptr,
"EXIT", 4) == 0) {
1180 switch (
TYPE(vsig)) {
1183 if (sig < 0 || sig >=
NSIG) {
1200 if (sig == 0 && strcmp(s,
"EXIT") != 0) {
1232 if (oldfunc == SIG_IGN) oldcmd =
rb_str_new2(
"IGNORE");
1233 else if (oldfunc == SIG_DFL) oldcmd =
rb_str_new2(
"SYSTEM_DEFAULT");
1255 if (signo == SIGSEGV)
1259 if (signo == SIGBUS)
1263 if (signo == SIGILL)
1267 if (signo == SIGFPE)
1273 if (signo == SIGVTALRM)
1342 return trap(sig, func, cmd);
1372 if (old == SIG_ERR)
return -1;
1374 if (old != SIG_DFL) {
1379 #ifndef __native_client__ 1380 # define install_sighandler(signum, handler) (install_sighandler(signum, handler) ? rb_bug(#signum) : (void)0) 1383 #if defined(SIGCLD) || defined(SIGCHLD) 1385 init_sigchld(
int sig)
1390 if (oldfunc == SIG_ERR)
return -1;
1391 if (oldfunc != SIG_DFL && oldfunc != SIG_IGN) {
1395 GET_VM()->trap_list[sig].cmd = 0;
1399 # ifndef __native_client__ 1400 # define init_sigchld(signum) (init_sigchld(signum) ? rb_bug(#signum) : (void)0) 1417 #ifndef RUBY_DEBUG_ENV 1418 #define ruby_enable_coredump 0 1496 if (!ruby_enable_coredump) {
1504 # ifdef USE_SIGALTSTACK 1518 init_sigchld(SIGCLD);
1519 #elif defined(SIGCHLD) 1520 init_sigchld(SIGCHLD);
static VALUE rb_signo2signm(int signo)
static VALUE sig_list(void)
static int cmp(VALUE x, VALUE y)
static void signal_exec(VALUE cmd, int safe, int sig)
#define MESSAGE_FAULT_ADDRESS
static void signal_enque(int sig)
const char * ruby_signal_name(int no)
void ruby_thread_stack_overflow(rb_thread_t *th)
void rb_bug(const char *fmt,...)
size_t strlen(const char *)
static VALUE trap(int sig, sighandler_t func, VALUE command)
rb_atomic_t ruby_atomic_exchange(rb_atomic_t *ptr, rb_atomic_t val)
#define GetProcPtr(obj, ptr)
VALUE rb_fstring_cstr(const char *str)
static int signal_ignored(int sig)
static VALUE interrupt_init(int argc, VALUE *argv, VALUE self)
static void rb_enable_interrupt(void)
void rb_threadptr_signal_raise(rb_thread_t *th, int sig)
#define TH_JUMP_TAG(th, st)
SSL_METHOD *(* func)(void)
RETSIGTYPE ruby_sigaction_t(int)
void rb_signal_exec(rb_thread_t *th, int sig)
#define ruby_enable_coredump
void rb_raise(VALUE exc, const char *fmt,...)
VALUE rb_ivar_get(VALUE, ID)
#define RSTRING_GETMEM(str, ptrvar, lenvar)
void ruby_default_signal(int sig)
#define ATOMIC_PTR_EXCHANGE(var, val)
static VALUE esignal_signo(VALUE self)
void rb_define_global_function(const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a global function.
VALUE rb_check_to_integer(VALUE, const char *)
static sighandler_t trap_handler(VALUE *cmd, int sig)
const char * rb_obj_classname(VALUE)
static VALUE sig_signame(VALUE recv, VALUE signo)
#define install_sighandler(signum, handler)
static int reserved_signal_p(int signo)
void rb_thread_wakeup_timer_thread(void)
VALUE rb_hash_aset(VALUE hash, VALUE key, VALUE val)
struct rb_vm_struct::@200 trap_list[RUBY_NSIG]
static RETSIGTYPE sighandler(int sig)
VALUE rb_thread_current(void)
static const char signame_prefix[3]
static const struct signals siglist[]
void rb_sys_fail_str(VALUE mesg)
rb_atomic_t cnt[RUBY_NSIG]
VALUE rb_f_kill(int argc, const VALUE *argv)
void rb_threadptr_check_signal(rb_thread_t *mth)
static sighandler_t default_handler(int sig)
static VALUE sig_trap(int argc, VALUE *argv)
static int signm2signo(const char *nm)
VALUE rb_str_subseq(VALUE, long, long)
void rb_define_module_function(VALUE module, const char *name, VALUE(*func)(ANYARGS), int argc)
Defines a module function for module.
VALUE rb_sprintf(const char *format,...)
int rb_scan_args(int argc, const VALUE *argv, const char *fmt,...)
void rb_thread_execute_interrupts(VALUE th)
VALUE rb_ivar_set(VALUE, ID, VALUE)
static const char * signo2signm(int no)
rb_thread_t * ruby_current_thread
#define VALGRIND_MAKE_MEM_DEFINED(p, n)
static void rb_disable_interrupt(void)
void rb_alias(VALUE, ID, ID)
VALUE rb_call_super(int, const VALUE *)
VALUE rb_str_new_cstr(const char *)
int memcmp(const void *s1, const void *s2, size_t len)
int rb_sigaltstack_size(void)
void rb_sys_fail(const char *mesg)
static struct @173 signal_buff
register unsigned int len
int rb_get_next_signal(void)
rb_atomic_t ruby_atomic_compare_and_swap(rb_atomic_t *ptr, rb_atomic_t cmp, rb_atomic_t newval)
#define CHECK_STACK_OVERFLOW()
#define UNLIMITED_ARGUMENTS
unsigned long interrupt_mask
VALUE rb_block_proc(void)
void ruby_sig_finalize(void)
VALUE rb_check_string_type(VALUE)
int rb_signal_buff_size(void)
static VALUE esignal_init(int argc, VALUE *argv, VALUE self)
VALUE rb_eval_cmd(VALUE, VALUE, int)
#define SafeStringValue(v)
void ruby_kill(rb_pid_t pid, int sig)
static int trap_signm(VALUE vsig)
#define StringValuePtr(v)
#define ruby_signal(sig, handler)
#define rb_intern_const(str)
void rb_bug_context(const void *ctx, const char *fmt,...)
VALUE rb_define_module(const char *name)
#define clear_received_signal()
void rb_define_method(VALUE klass, const char *name, VALUE(*func)(ANYARGS), int argc)
void rb_threadptr_signal_exit(rb_thread_t *th)