From 7f7e4e2dff2dd96e442993322b4b8828fc381d12 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 01fae7a..980c729 100644 --- a/ChangeLog +++ b/ChangeLog @@ -313,6 +313,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..7247565 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,17 @@ 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; + +void +ruby_bind_stack(void *lower_boundary, void *upper_boundary) +{ + assert(upper_boundary > lower_boundary); + ruby_stack_lower_bound = lower_boundary; + ruby_stack_upper_bound = upper_boundary; +} + static void get_machine_stack_bounds(rb_thread_t *th, VALUE **stack_start, VALUE **stack_end, unsigned stack_end_increment) { @@ -2108,6 +2120,16 @@ 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 (th == th->vm->main_thread) { + if (ruby_stack_lower_bound && *stack_start < ruby_stack_lower_bound) { + *stack_start = ruby_stack_lower_bound; + } + + if (ruby_stack_upper_bound && *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