From c7069f88162bb409c4bfb4a16c6905684dcf87c2 Mon Sep 17 00:00:00 2001 From: Suraj N. Kurapati Date: Sat, 24 Oct 2009 20:55:11 -0700 Subject: [PATCH] * include/ruby/ruby.h: declare ruby_bind_stack(). [ruby-core:26361] * gc.c: implement ruby_bind_stack(). restrict GC marking region to ruby_bind_stack() boundaries for main thread. --- ChangeLog | 7 +++++++ gc.c | 22 ++++++++++++++++++++++ include/ruby/ruby.h | 11 +++++++++++ 3 files changed, 40 insertions(+), 0 deletions(-) diff --git a/ChangeLog b/ChangeLog index 37b8510..2009a33 100644 --- a/ChangeLog +++ b/ChangeLog @@ -337,6 +337,13 @@ Sun Oct 25 13:33:58 2009 Nobuyoshi Nakada Mon Oct 25 13:28:00 2009 Suraj N. Kurapati + * include/ruby/ruby.h: declare ruby_bind_stack(). [ruby-core:26361] + + * gc.c: implement ruby_bind_stack(). restrict GC marking + region to ruby_bind_stack() boundaries for main thread. + +Mon Oct 25 13:28:00 2009 Suraj N. Kurapati + * gc.c: refactor common code from mark_current_machine_context() and rb_gc_mark_machine_stack() into get_machine_stack_bounds(). diff --git a/gc.c b/gc.c index 0b588dc..904d366 100644 --- a/gc.c +++ b/gc.c @@ -19,6 +19,7 @@ #include "eval_intern.h" #include "vm_core.h" #include "gc.h" +#include #include #include #include @@ -2089,6 +2090,18 @@ obj_free(rb_objspace_t *objspace, VALUE obj) void rb_vm_mark(void *ptr); +static VALUE *ruby_stack_lower_bound = 0, *ruby_stack_upper_bound = 0; +static char ruby_stack_is_bound = 0; + +void +ruby_bind_stack(void *lower_boundary, void *upper_boundary) +{ + assert(upper_boundary > lower_boundary && lower_boundary > 0); + ruby_stack_lower_bound = lower_boundary; + ruby_stack_upper_bound = upper_boundary; + ruby_stack_is_bound = 1; +} + static void get_machine_stack_bounds(rb_thread_t *th, VALUE **stack_start, VALUE **stack_end, unsigned stack_end_increment) { @@ -2108,6 +2121,15 @@ get_machine_stack_bounds(rb_thread_t *th, VALUE **stack_start, VALUE **stack_end *stack_end = th->machine_stack_end + stack_end_increment; } #endif + if (ruby_stack_is_bound && th == th->vm->main_thread) { + if (*stack_start < ruby_stack_lower_bound) { + *stack_start = ruby_stack_lower_bound; + } + + if (*stack_end > ruby_stack_upper_bound) { + *stack_end = ruby_stack_upper_bound; + } + } } static void diff --git a/include/ruby/ruby.h b/include/ruby/ruby.h index 55836a8..8f5715a 100644 --- a/include/ruby/ruby.h +++ b/include/ruby/ruby.h @@ -1143,6 +1143,17 @@ void ruby_init_stack(volatile VALUE*); #define RUBY_INIT_STACK \ VALUE variable_in_this_stack_frame; \ ruby_init_stack(&variable_in_this_stack_frame); +/* + * Binds the stack of Ruby's main thread to the region of memory that spans + * inclusively from the given lower boundary to the given upper boundary: + * + * lower boundary <= stack pointer of Ruby's main thread <= upper boundary + * + * These boundaries *do not* protect Ruby's main thread against stack + * overflow and they *do not* apply to non-main Ruby threads (whose stacks + * are dynamically allocated and managed by the native Operating System). + */ +void ruby_bind_stack(void *lower_boundary, void *upper_boundary); void ruby_init(void); void *ruby_options(int, char**); int ruby_run_node(void *); -- 1.6.5.2