Add ASSERT_vm_unlocking() to vm_call0_body

luke-gruber · luke-gruber · commit 2ad1da8cfc5e · 2025-09-19T14:47:49.000-04:00
This uncovered many more test failures.
diff --git a/encoding.c b/encoding.c
@@ -345,6 +345,7 @@ static int
 enc_table_expand(struct enc_table *enc_table, int newsize)
 {
     if (newsize > ENCODING_LIST_CAPA) {
+        RB_VM_UNLOCK();
         rb_raise(rb_eEncodingError, "too many encoding (> %d)", ENCODING_LIST_CAPA);
     }
     return newsize;
@@ -491,9 +492,11 @@ static void
 enc_check_addable(struct enc_table *enc_table, const char *name)
 {
     if (enc_registered(enc_table, name) >= 0) {
+        RB_VM_UNLOCK();
         rb_raise(rb_eArgError, "encoding %s is already registered", name);
     }
     else if (!valid_encoding_name_p(name)) {
+        RB_VM_UNLOCK();
         rb_raise(rb_eArgError, "invalid encoding name: %s", name);
     }
 }
@@ -541,7 +544,10 @@ enc_replicate(struct enc_table *enc_table, const char *name, rb_encoding *encodi
 
     enc_check_addable(enc_table, name);
     idx = enc_register(enc_table, name, encoding);
-    if (idx < 0) rb_raise(rb_eArgError, "invalid encoding name: %s", name);
+    if (idx < 0) {
+        RB_VM_UNLOCK();
+        rb_raise(rb_eArgError, "invalid encoding name: %s", name);
+    }
     set_base_encoding(enc_table, idx, encoding);
     return idx;
 }
@@ -559,6 +565,7 @@ enc_replicate_with_index(struct enc_table *enc_table, const char *name, rb_encod
         set_base_encoding(enc_table, idx, origenc);
     }
     else {
+        RB_VM_UNLOCK();
         rb_raise(rb_eArgError, "failed to replicate encoding");
     }
     return idx;
@@ -885,7 +892,7 @@ int
 rb_enc_find_index(const char *name)
 {
     int i;
-#if RUBY_DEBUG > 0
+#if RUBY_DEBUG
     if (rb_multi_ractor_p() || !rb_enc_registered(name)) {
         ASSERT_vm_unlocking(); // it needs to be unlocked so it can call `load_encoding` if necessary
     }
diff --git a/eval.c b/eval.c
@@ -2078,7 +2078,14 @@ errat_getter(ID id, VALUE *_)
 {
     VALUE err = get_errinfo();
     if (!NIL_P(err)) {
-        return rb_get_backtrace(err);
+        VALUE bt;
+        RB_VM_UNLOCK();
+        {
+            bt = rb_get_backtrace(err);
+        }
+        RB_VM_LOCK();
+
+        return bt;
     }
     else {
         return Qnil;
@@ -2089,10 +2096,14 @@ static void
 errat_setter(VALUE val, ID id, VALUE *var)
 {
     VALUE err = get_errinfo();
-    if (NIL_P(err)) {
-        rb_raise(rb_eArgError, "$! not set");
+    RB_VM_UNLOCK();
+    {
+        if (NIL_P(err)) {
+            rb_raise(rb_eArgError, "$! not set");
+        }
+        set_backtrace(err, val);
     }
-    set_backtrace(err, val);
+    RB_VM_LOCK();
 }
 
 /*
diff --git a/gc/default/default.c b/gc/default/default.c
@@ -2765,20 +2765,23 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)
 
     if (st_lookup(finalizer_table, obj, &data)) {
         table = (VALUE)data;
+        VALUE dup_table = rb_ary_dup(table);
 
+        RB_GC_VM_UNLOCK(lev);
         /* avoid duplicate block, table is usually small */
         {
             long len = RARRAY_LEN(table);
             long i;
 
             for (i = 0; i < len; i++) {
-                VALUE recv = RARRAY_AREF(table, i);
-                if (rb_equal(recv, block)) { // TODO: unsafe, can context switch
-                    RB_GC_VM_UNLOCK(lev);
+                VALUE recv = RARRAY_AREF(dup_table, i);
+                if (rb_equal(recv, block)) { // can't be called with VM lock held
                     return recv;
                 }
             }
         }
+        lev = RB_GC_VM_LOCK();
+        RB_GC_GUARD(dup_table);
 
         rb_ary_push(table, block);
     }
diff --git a/io.c b/io.c
@@ -8675,7 +8675,11 @@ deprecated_str_setter(VALUE val, ID id, VALUE *var)
 {
     rb_str_setter(val, id, &val);
     if (!NIL_P(val)) {
-        rb_warn_deprecated("'%s'", NULL, rb_id2name(id));
+        RB_VM_UNLOCK();
+        {
+            rb_warn_deprecated("'%s'", NULL, rb_id2name(id));
+        }
+        RB_VM_LOCK();
     }
     *var = val;
 }
@@ -8684,17 +8688,21 @@ static void
 deprecated_rs_setter(VALUE val, ID id, VALUE *var)
 {
     if (!NIL_P(val)) {
-        if (!RB_TYPE_P(val, T_STRING)) {
-            rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id));
-        }
-        if (rb_str_equal(val, rb_default_rs)) {
-            val = rb_default_rs;
-        }
-        else {
-            val = rb_str_frozen_bare_string(val);
+        RB_VM_UNLOCK();
+        {
+            if (!RB_TYPE_P(val, T_STRING)) {
+                rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id));
+            }
+            if (rb_str_equal(val, rb_default_rs)) {
+                val = rb_default_rs;
+            }
+            else {
+                val = rb_str_frozen_bare_string(val);
+            }
+            rb_enc_str_coderange(val);
+            rb_warn_deprecated("'%s'", NULL, rb_id2name(id));
         }
-        rb_enc_str_coderange(val);
-        rb_warn_deprecated("'%s'", NULL, rb_id2name(id));
+        RB_VM_LOCK();
     }
     *var = val;
 }
@@ -9246,7 +9254,11 @@ stdin_getter(ID id, VALUE *ptr)
 static void
 stdout_setter(VALUE val, ID id, VALUE *ptr)
 {
-    must_respond_to(id_write, val, id);
+    RB_VM_UNLOCK();
+    {
+        must_respond_to(id_write, val, id);
+    }
+    RB_VM_LOCK();
     rb_ractor_stdout_set(val);
 }
 
@@ -9259,7 +9271,11 @@ stdout_getter(ID id, VALUE *ptr)
 static void
 stderr_setter(VALUE val, ID id, VALUE *ptr)
 {
-    must_respond_to(id_write, val, id);
+    RB_VM_UNLOCK();
+    {
+        must_respond_to(id_write, val, id);
+    }
+    RB_VM_LOCK();
     rb_ractor_stderr_set(val);
 }
 
diff --git a/ractor.c b/ractor.c
@@ -1374,10 +1374,15 @@ make_shareable_check_shareable(VALUE obj)
     }
     else if (!allow_frozen_shareable_p(obj)) {
         if (rb_obj_is_proc(obj)) {
-            rb_proc_ractor_make_shareable(obj);
+            int lev = RB_VM_UNLOCK_ALL();
+            {
+                rb_proc_ractor_make_shareable(obj);
+            }
+            RB_VM_RELOCK_ALL(lev);
             return traverse_cont;
         }
         else {
+            (void)RB_VM_UNLOCK_ALL();
             rb_raise(rb_eRactorError, "can not make shareable object for %+"PRIsVALUE, obj);
         }
     }
diff --git a/re.c b/re.c
@@ -4627,7 +4627,9 @@ static void
 match_setter(VALUE val, ID _x, VALUE *_y)
 {
     if (!NIL_P(val)) {
+        RB_VM_UNLOCK();
         Check_Type(val, T_MATCH);
+        RB_VM_LOCK();
     }
     rb_backref_set(val);
 }
diff --git a/ruby.c b/ruby.c
@@ -42,6 +42,7 @@
 
 #include "dln.h"
 #include "eval_intern.h"
+#include "vm_sync.h"
 #include "internal.h"
 #include "internal/cmdlineopt.h"
 #include "internal/cont.h"
@@ -3019,10 +3020,13 @@ ruby_setproctitle(VALUE title)
 static void
 set_arg0(VALUE val, ID id, VALUE *_)
 {
-    if (origarg.argv == 0)
+    RB_VM_UNLOCK();
+    if (origarg.argv == 0) {
         rb_raise(rb_eRuntimeError, "$0 not initialized");
+    }
 
     rb_progname = rb_str_new_frozen(ruby_setproctitle(val));
+    RB_VM_LOCK();
 }
 
 static inline VALUE
diff --git a/string.c b/string.c
@@ -11444,6 +11444,7 @@ void
 rb_str_setter(VALUE val, ID id, VALUE *var)
 {
     if (!NIL_P(val) && !RB_TYPE_P(val, T_STRING)) {
+        RB_VM_UNLOCK_ALL();
         rb_raise(rb_eTypeError, "value of %"PRIsVALUE" must be String", rb_id2str(id));
     }
     *var = val;
@@ -11452,15 +11453,19 @@ rb_str_setter(VALUE val, ID id, VALUE *var)
 static void
 rb_fs_setter(VALUE val, ID id, VALUE *var)
 {
-    val = rb_fs_check(val);
-    if (!val) {
-        rb_raise(rb_eTypeError,
-                 "value of %"PRIsVALUE" must be String or Regexp",
-                 rb_id2str(id));
-    }
-    if (!NIL_P(val)) {
-        rb_warn_deprecated("'$;'", NULL);
+    RB_VM_UNLOCK();
+    {
+        val = rb_fs_check(val);
+        if (!val) {
+            rb_raise(rb_eTypeError,
+                    "value of %"PRIsVALUE" must be String or Regexp",
+                    rb_id2str(id));
+        }
+        if (!NIL_P(val)) {
+                rb_warn_deprecated("'$;'", NULL);
+        }
     }
+    RB_VM_LOCK();
     *var = val;
 }
 
diff --git a/transcode.c b/transcode.c
@@ -1856,13 +1856,9 @@ rb_econv_asciicompat_encoding(const char *ascii_incompat_name)
                     RB_VM_LOCK_ENTER_LEV(&lev);
                 }
                 else {
-#if RUBY_DEBUG > 0
                     RB_VM_LOCK_LEAVE_LEV(&lev);
-#endif
                     st_foreach(table2, asciicompat_encoding_i, (st_data_t)&data);
-#if RUBY_DEBUG > 0
                     RB_VM_LOCK_ENTER_LEV(&lev);
-#endif
                 }
             }
 
diff --git a/variable.c b/variable.c
@@ -596,6 +596,7 @@ rb_find_global_entry(ID id)
     }
 
     if (UNLIKELY(!rb_ractor_main_p()) && (!entry || !entry->ractor_local)) {
+        if (RB_VM_LOCKED_P()) RB_VM_UNLOCK_ALL();
         rb_raise(rb_eRactorIsolationError, "can not access global variable %s from non-main Ractor", rb_id2name(id));
     }
 
@@ -653,7 +654,11 @@ rb_global_entry(ID id)
 VALUE
 rb_gvar_undef_getter(ID id, VALUE *_)
 {
-    rb_warning("global variable '%"PRIsVALUE"' not initialized", QUOTE_ID(id));
+    RB_VM_UNLOCK();
+    {
+        rb_warning("global variable '%"PRIsVALUE"' not initialized", QUOTE_ID(id));
+    }
+    RB_VM_LOCK();
 
     return Qnil;
 }
@@ -732,6 +737,7 @@ rb_gvar_var_marker(VALUE *var)
 void
 rb_gvar_readonly_setter(VALUE v, ID id, VALUE *_)
 {
+    RB_VM_UNLOCK();
     rb_name_error(id, "%"PRIsVALUE" is a read-only variable", QUOTE_ID(id));
 }
 
@@ -1165,6 +1171,7 @@ rb_alias_variable(ID name1, ID name2)
         else if ((entry1 = (struct rb_global_entry *)data1)->var != entry2->var) {
             struct rb_global_variable *var = entry1->var;
             if (var->block_trace) {
+                RB_VM_UNLOCK();
                 rb_raise(rb_eRuntimeError, "can't alias in tracer");
             }
             var->counter--;
@@ -3857,7 +3864,6 @@ static void
 const_added(VALUE klass, ID const_name)
 {
     if (GET_VM()->running) {
-        ASSERT_vm_unlocking();
         VALUE name = ID2SYM(const_name);
         rb_funcallv(klass, idConst_added, 1, &name);
     }
@@ -3992,14 +3998,28 @@ const_tbl_update(struct autoload_const *ac, int autoload_force)
         else {
             VALUE name = QUOTE_ID(id);
             visibility = ce->flag;
-            if (klass == rb_cObject)
-                rb_warn("already initialized constant %"PRIsVALUE"", name);
-            else
-                rb_warn("already initialized constant %"PRIsVALUE"::%"PRIsVALUE"",
-                        rb_class_name(klass), name);
+            if (klass == rb_cObject) {
+                RB_VM_UNLOCK();
+                {
+                    rb_warn("already initialized constant %"PRIsVALUE"", name);
+                }
+                RB_VM_LOCK();
+            }
+            else {
+                RB_VM_UNLOCK();
+                {
+                    rb_warn("already initialized constant %"PRIsVALUE"::%"PRIsVALUE"",
+                            rb_class_name(klass), name);
+                }
+                RB_VM_LOCK();
+            }
             if (!NIL_P(ce->file) && ce->line) {
-                rb_compile_warn(RSTRING_PTR(ce->file), ce->line,
-                                "previous definition of %"PRIsVALUE" was here", name);
+                RB_VM_UNLOCK();
+                {
+                    rb_compile_warn(RSTRING_PTR(ce->file), ce->line,
+                                    "previous definition of %"PRIsVALUE" was here", name);
+                }
+                RB_VM_LOCK();
             }
         }
         rb_clear_constant_cache_for_id(id);
diff --git a/vm.c b/vm.c
@@ -1307,6 +1307,8 @@ collect_outer_variable_names(ID id, VALUE val, void *ptr)
 static const rb_env_t *
 env_copy(const VALUE *src_ep, VALUE read_only_variables)
 {
+    ASSERT_vm_unlocking();
+
     const rb_env_t *src_env = (rb_env_t *)VM_ENV_ENVVAL(src_ep);
     VM_ASSERT(src_env->ep == src_ep);
 
@@ -1675,7 +1677,6 @@ invoke_block_from_c_bh(rb_execution_context_t *ec, VALUE block_handler,
                        int kw_splat, VALUE passed_block_handler, const rb_cref_t *cref,
                        int is_lambda, int force_blockarg)
 {
-    ASSERT_vm_unlocking();
   again:
     switch (vm_block_handler_type(block_handler)) {
       case block_handler_type_iseq:
@@ -1718,7 +1719,6 @@ check_block_handler(rb_execution_context_t *ec)
 static VALUE
 vm_yield_with_cref(rb_execution_context_t *ec, int argc, const VALUE *argv, int kw_splat, const rb_cref_t *cref, int is_lambda)
 {
-    ASSERT_vm_unlocking();
     return invoke_block_from_c_bh(ec, check_block_handler(ec),
                                   argc, argv, kw_splat, VM_BLOCK_HANDLER_NONE,
                                   cref, is_lambda, FALSE);
diff --git a/vm_eval.c b/vm_eval.c
@@ -199,6 +199,8 @@ vm_call0_body(rb_execution_context_t *ec, struct rb_calling_info *calling, const
     const struct rb_callcache *cc = calling->cc;
     VALUE ret;
 
+    ASSERT_vm_unlocking();
+
   retry:
 
     switch (vm_cc_cme(cc)->def->type) {
diff --git a/vm_sync.h b/vm_sync.h

Original file line number	Diff line number	Diff line change
`@@ -345,6 +345,7 @@ static int`
`345`	`345`	`enc_table_expand(struct enc_table *enc_table, int newsize)`
`346`	`346`	`{`
`347`	`347`	`if (newsize > ENCODING_LIST_CAPA) {`
	`348`	`+ RB_VM_UNLOCK();`
`348`	`349`	`rb_raise(rb_eEncodingError, "too many encoding (> %d)", ENCODING_LIST_CAPA);`
`349`	`350`	`}`
`350`	`351`	`return newsize;`
`@@ -491,9 +492,11 @@ static void`
`491`	`492`	`enc_check_addable(struct enc_table enc_table, const char name)`
`492`	`493`	`{`
`493`	`494`	`if (enc_registered(enc_table, name) >= 0) {`
	`495`	`+ RB_VM_UNLOCK();`
`494`	`496`	`rb_raise(rb_eArgError, "encoding %s is already registered", name);`
`495`	`497`	`}`
`496`	`498`	`else if (!valid_encoding_name_p(name)) {`
	`499`	`+ RB_VM_UNLOCK();`
`497`	`500`	`rb_raise(rb_eArgError, "invalid encoding name: %s", name);`
`498`	`501`	`}`
`499`	`502`	`}`
`@@ -541,7 +544,10 @@ enc_replicate(struct enc_table enc_table, const char name, rb_encoding *encodi`
`541`	`544`
`542`	`545`	`enc_check_addable(enc_table, name);`
`543`	`546`	`idx = enc_register(enc_table, name, encoding);`
`544`		`- if (idx < 0) rb_raise(rb_eArgError, "invalid encoding name: %s", name);`
	`547`	`+ if (idx < 0) {`
	`548`	`+ RB_VM_UNLOCK();`
	`549`	`+ rb_raise(rb_eArgError, "invalid encoding name: %s", name);`
	`550`	`+ }`
`545`	`551`	`set_base_encoding(enc_table, idx, encoding);`
`546`	`552`	`return idx;`
`547`	`553`	`}`
`@@ -559,6 +565,7 @@ enc_replicate_with_index(struct enc_table enc_table, const char name, rb_encod`
`559`	`565`	`set_base_encoding(enc_table, idx, origenc);`
`560`	`566`	`}`
`561`	`567`	`else {`
	`568`	`+ RB_VM_UNLOCK();`
`562`	`569`	`rb_raise(rb_eArgError, "failed to replicate encoding");`
`563`	`570`	`}`
`564`	`571`	`return idx;`
`@@ -885,7 +892,7 @@ int`
`885`	`892`	`rb_enc_find_index(const char *name)`
`886`	`893`	`{`
`887`	`894`	`int i;`
`888`		`-#if RUBY_DEBUG > 0`
	`895`	`+#if RUBY_DEBUG`
`889`	`896`	`if (rb_multi_ractor_p() \|\| !rb_enc_registered(name)) {`
`890`	`897`	ASSERT_vm_unlocking(); // it needs to be unlocked so it can call `load_encoding` if necessary
`891`	`898`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2765,20 +2765,23 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)`
`2765`	`2765`
`2766`	`2766`	`if (st_lookup(finalizer_table, obj, &data)) {`
`2767`	`2767`	`table = (VALUE)data;`
	`2768`	`+ VALUE dup_table = rb_ary_dup(table);`
`2768`	`2769`
	`2770`	`+ RB_GC_VM_UNLOCK(lev);`
`2769`	`2771`	`/* avoid duplicate block, table is usually small */`
`2770`	`2772`	`{`
`2771`	`2773`	`long len = RARRAY_LEN(table);`
`2772`	`2774`	`long i;`
`2773`	`2775`
`2774`	`2776`	`for (i = 0; i < len; i++) {`
`2775`		`- VALUE recv = RARRAY_AREF(table, i);`
`2776`		`- if (rb_equal(recv, block)) { // TODO: unsafe, can context switch`
`2777`		`- RB_GC_VM_UNLOCK(lev);`
	`2777`	`+ VALUE recv = RARRAY_AREF(dup_table, i);`
	`2778`	`+ if (rb_equal(recv, block)) { // can't be called with VM lock held`
`2778`	`2779`	`return recv;`
`2779`	`2780`	`}`
`2780`	`2781`	`}`
`2781`	`2782`	`}`
	`2783`	`+ lev = RB_GC_VM_LOCK();`
	`2784`	`+ RB_GC_GUARD(dup_table);`
`2782`	`2785`
`2783`	`2786`	`rb_ary_push(table, block);`
`2784`	`2787`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1374,10 +1374,15 @@ make_shareable_check_shareable(VALUE obj)`
`1374`	`1374`	`}`
`1375`	`1375`	`else if (!allow_frozen_shareable_p(obj)) {`
`1376`	`1376`	`if (rb_obj_is_proc(obj)) {`
`1377`		`- rb_proc_ractor_make_shareable(obj);`
	`1377`	`+ int lev = RB_VM_UNLOCK_ALL();`
	`1378`	`+ {`
	`1379`	`+ rb_proc_ractor_make_shareable(obj);`
	`1380`	`+ }`
	`1381`	`+ RB_VM_RELOCK_ALL(lev);`
`1378`	`1382`	`return traverse_cont;`
`1379`	`1383`	`}`
`1380`	`1384`	`else {`
	`1385`	`+ (void)RB_VM_UNLOCK_ALL();`
`1381`	`1386`	`rb_raise(rb_eRactorError, "can not make shareable object for %+"PRIsVALUE, obj);`
`1382`	`1387`	`}`
`1383`	`1388`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4627,7 +4627,9 @@ static void`
`4627`	`4627`	`match_setter(VALUE val, ID _x, VALUE *_y)`
`4628`	`4628`	`{`
`4629`	`4629`	`if (!NIL_P(val)) {`
	`4630`	`+ RB_VM_UNLOCK();`
`4630`	`4631`	`Check_Type(val, T_MATCH);`
	`4632`	`+ RB_VM_LOCK();`
`4631`	`4633`	`}`
`4632`	`4634`	`rb_backref_set(val);`
`4633`	`4635`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1856,13 +1856,9 @@ rb_econv_asciicompat_encoding(const char *ascii_incompat_name)`
`1856`	`1856`	`RB_VM_LOCK_ENTER_LEV(&lev);`
`1857`	`1857`	`}`
`1858`	`1858`	`else {`
`1859`		`-#if RUBY_DEBUG > 0`
`1860`	`1859`	`RB_VM_LOCK_LEAVE_LEV(&lev);`
`1861`		`-#endif`
`1862`	`1860`	`st_foreach(table2, asciicompat_encoding_i, (st_data_t)&data);`
`1863`		`-#if RUBY_DEBUG > 0`
`1864`	`1861`	`RB_VM_LOCK_ENTER_LEV(&lev);`
`1865`		`-#endif`
`1866`	`1862`	`}`
`1867`	`1863`	`}`
`1868`	`1864`