Make sure we never context switch while holding VM lock.

luke-gruber · luke-gruber · commit c9c473455f02 · 2025-09-10T14:50:22.000-04:00
We were seeing errors in our application that looked like:

```
[BUG] unexpected situation - recordd:1 current:0
/error.c:1097 rb_bug_without_die_internal
/vm_sync.c:275 disallow_reentry
/eval_intern.h:136 rb_ec_vm_lock_rec_check
/eval_intern.h:147 rb_ec_tag_state
/vm.c:2619 rb_vm_exec
/vm.c:1702 rb_yield
/eval.c:1173 rb_ensure
```

We concluded that there was context switching going on while a thread
held the VM lock. During the investigation into the issue, we added
assertions that we never yield to another thread with the VM lock held.
We enabled these VM lock assertions even in single ractor mode. These
assertions were failing in a few places, but most notably in finalizers.
We were running finalizers with the VM lock held, and they were context
switching and causing this issue.

These rules must be held going forward to ensure we don't context switch unexpectedly:

If you have the VM lock held,
    * Don't enter the interpreter loop.
    * Don't yield to ruby code.
    * Don't call rb_nogvl (it will context switch you and will not unlock the VM lock).
    * Don't check your own interrupts, it can switch you.

If you don't have the GVL:
    * Don't call rb_ensure/rb_protect, etc (these are old rules but good to have assertions for).
diff --git a/encoding.c b/encoding.c
@@ -717,34 +717,35 @@ rb_encdb_alias(const char *alias, const char *orig)
 static void
 rb_enc_init(struct enc_table *enc_table)
 {
-    ASSERT_vm_locking();
-    enc_table_expand(enc_table, ENCODING_COUNT + 1);
-    if (!enc_table->names) {
-        enc_table->names = st_init_strcasetable_with_size(ENCODING_LIST_CAPA);
-    }
+    RB_VM_LOCKING() {
+        enc_table_expand(enc_table, ENCODING_COUNT + 1);
+        if (!enc_table->names) {
+            enc_table->names = st_init_strcasetable_with_size(ENCODING_LIST_CAPA);
+        }
 #define OnigEncodingASCII_8BIT OnigEncodingASCII
 #define ENC_REGISTER(enc) enc_register_at(enc_table, ENCINDEX_##enc, rb_enc_name(&OnigEncoding##enc), &OnigEncoding##enc)
-    ENC_REGISTER(ASCII_8BIT);
-    ENC_REGISTER(UTF_8);
-    ENC_REGISTER(US_ASCII);
-    global_enc_ascii = enc_table->list[ENCINDEX_ASCII_8BIT].enc;
-    global_enc_utf_8 = enc_table->list[ENCINDEX_UTF_8].enc;
-    global_enc_us_ascii = enc_table->list[ENCINDEX_US_ASCII].enc;
+        ENC_REGISTER(ASCII_8BIT);
+        ENC_REGISTER(UTF_8);
+        ENC_REGISTER(US_ASCII);
+        global_enc_ascii = enc_table->list[ENCINDEX_ASCII_8BIT].enc;
+        global_enc_utf_8 = enc_table->list[ENCINDEX_UTF_8].enc;
+        global_enc_us_ascii = enc_table->list[ENCINDEX_US_ASCII].enc;
 #undef ENC_REGISTER
 #undef OnigEncodingASCII_8BIT
 #define ENCDB_REGISTER(name, enc) enc_register_at(enc_table, ENCINDEX_##enc, name, NULL)
-    ENCDB_REGISTER("UTF-16BE", UTF_16BE);
-    ENCDB_REGISTER("UTF-16LE", UTF_16LE);
-    ENCDB_REGISTER("UTF-32BE", UTF_32BE);
-    ENCDB_REGISTER("UTF-32LE", UTF_32LE);
-    ENCDB_REGISTER("UTF-16", UTF_16);
-    ENCDB_REGISTER("UTF-32", UTF_32);
-    ENCDB_REGISTER("UTF8-MAC", UTF8_MAC);
-
-    ENCDB_REGISTER("EUC-JP", EUC_JP);
-    ENCDB_REGISTER("Windows-31J", Windows_31J);
+        ENCDB_REGISTER("UTF-16BE", UTF_16BE);
+        ENCDB_REGISTER("UTF-16LE", UTF_16LE);
+        ENCDB_REGISTER("UTF-32BE", UTF_32BE);
+        ENCDB_REGISTER("UTF-32LE", UTF_32LE);
+        ENCDB_REGISTER("UTF-16", UTF_16);
+        ENCDB_REGISTER("UTF-32", UTF_32);
+        ENCDB_REGISTER("UTF8-MAC", UTF8_MAC);
+
+        ENCDB_REGISTER("EUC-JP", EUC_JP);
+        ENCDB_REGISTER("Windows-31J", Windows_31J);
 #undef ENCDB_REGISTER
-    enc_table->count = ENCINDEX_BUILTIN_MAX;
+        enc_table->count = ENCINDEX_BUILTIN_MAX;
+    }
 }
 
 rb_encoding *
diff --git a/eval_intern.h b/eval_intern.h
@@ -95,7 +95,10 @@ extern int select_large_fdset(int, fd_set *, fd_set *, fd_set *, struct timeval
 
 #include <sys/stat.h>
 
+int ruby_thread_has_gvl_p(void);
+
 #define EC_PUSH_TAG(ec) do { \
+  VM_ASSERT(ruby_thread_has_gvl_p()); \
   rb_execution_context_t * const _ec = (ec); \
   struct rb_vm_tag _tag; \
   _tag.state = TAG_NONE; \
diff --git a/gc/default/default.c b/gc/default/default.c
@@ -2773,7 +2773,7 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)
 
             for (i = 0; i < len; i++) {
                 VALUE recv = RARRAY_AREF(table, i);
-                if (rb_equal(recv, block)) {
+                if (rb_equal(recv, block)) { // TODO: unsafe, can context switch
                     RB_GC_VM_UNLOCK(lev);
                     return recv;
                 }
@@ -2839,8 +2839,8 @@ get_final(long i, void *data)
     return RARRAY_AREF(table, i + 1);
 }
 
-static void
-run_final(rb_objspace_t *objspace, VALUE zombie)
+static int
+run_final(rb_objspace_t *objspace, VALUE zombie, unsigned int lev)
 {
     if (RZOMBIE(zombie)->dfree) {
         RZOMBIE(zombie)->dfree(RZOMBIE(zombie)->data);
@@ -2851,7 +2851,9 @@ run_final(rb_objspace_t *objspace, VALUE zombie)
         FL_UNSET(zombie, FL_FINALIZE);
         st_data_t table;
         if (st_delete(finalizer_table, &key, &table)) {
+            RB_GC_VM_UNLOCK(lev);
             rb_gc_run_obj_finalizer(RARRAY_AREF(table, 0), RARRAY_LEN(table) - 1, get_final, (void *)table);
+            lev = RB_GC_VM_LOCK();
         }
         else {
             rb_bug("FL_FINALIZE flag is set, but finalizers are not found");
@@ -2860,6 +2862,7 @@ run_final(rb_objspace_t *objspace, VALUE zombie)
     else {
         GC_ASSERT(!st_lookup(finalizer_table, key, NULL));
     }
+    return lev;
 }
 
 static void
@@ -2874,7 +2877,7 @@ finalize_list(rb_objspace_t *objspace, VALUE zombie)
 
         int lev = RB_GC_VM_LOCK();
 
-        run_final(objspace, zombie);
+        lev = run_final(objspace, zombie, lev);
         {
             GC_ASSERT(BUILTIN_TYPE(zombie) == T_ZOMBIE);
             GC_ASSERT(page->heap->final_slots_count > 0);
diff --git a/io.c b/io.c
@@ -14432,7 +14432,13 @@ argf_filename(VALUE argf)
 static VALUE
 argf_filename_getter(ID id, VALUE *var)
 {
-    return argf_filename(*var);
+    VALUE filename = Qnil;
+    RB_VM_UNLOCK();
+    {
+        filename = argf_filename(*var);
+    }
+    RB_VM_LOCK();
+    return filename;
 }
 
 /*
diff --git a/ractor.c b/ractor.c
@@ -164,7 +164,7 @@ ractor_status_set(rb_ractor_t *r, enum ractor_status status)
     // check 1
     if (r->status_ != ractor_created) {
         VM_ASSERT(r == GET_RACTOR()); // only self-modification is allowed.
-        ASSERT_vm_locking();
+        VM_ASSERT((rb_multi_ractor_p() && RB_VM_LOCKED_P()) || true);
     }
 
     // check2: transition check. assume it will be vanished on non-debug build.
diff --git a/string.c b/string.c
@@ -12707,7 +12707,9 @@ Init_String(void)
 {
     rb_cString  = rb_define_class("String", rb_cObject);
 
-    rb_concurrent_set_foreach_with_replace(fstring_table_obj, fstring_set_class_i, NULL);
+    RB_VM_LOCKING() {
+        rb_concurrent_set_foreach_with_replace(fstring_table_obj, fstring_set_class_i, NULL);
+    }
 
     rb_include_module(rb_cString, rb_mComparable);
     rb_define_alloc_func(rb_cString, empty_str_alloc);
diff --git a/symbol.c b/symbol.c
@@ -390,7 +390,9 @@ rb_free_global_symbol_table_i(VALUE *sym_ptr, void *data)
 void
 rb_free_global_symbol_table(void)
 {
-    rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_free_global_symbol_table_i, NULL);
+    RB_VM_LOCKING() {
+        rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_free_global_symbol_table_i, NULL);
+    }
 }
 
 WARN_UNUSED_RESULT(static ID lookup_str_id(VALUE str));
diff --git a/thread.c b/thread.c
@@ -1472,6 +1472,7 @@ rb_thread_sleep(int sec)
 static void
 rb_thread_schedule_limits(uint32_t limits_us)
 {
+    VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR());
     if (!rb_thread_alone()) {
         rb_thread_t *th = GET_THREAD();
         RUBY_DEBUG_LOG("us:%u", (unsigned int)limits_us);
diff --git a/thread_pthread.c b/thread_pthread.c
@@ -1025,6 +1025,7 @@ thread_sched_to_waiting_common(struct rb_thread_sched *sched, rb_thread_t *th)
 static void
 thread_sched_to_waiting(struct rb_thread_sched *sched, rb_thread_t *th)
 {
+    VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR()); // never context switch with VM lock held
     thread_sched_lock(sched, th);
     {
         thread_sched_to_waiting_common(sched, th);
diff --git a/transcode.c b/transcode.c
@@ -412,10 +412,11 @@ int rb_require_internal_silent(VALUE fname);
 static const rb_transcoder *
 load_transcoder_entry(transcoder_entry_t *entry)
 {
-    ASSERT_vm_unlocking();
     if (entry->transcoder)
         return entry->transcoder;
 
+    ASSERT_vm_unlocking();
+
     if (entry->lib) {
         const char *const lib = entry->lib;
         const size_t len = strlen(lib);
@@ -1854,7 +1855,13 @@ 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
@@ -986,6 +986,7 @@ rb_gvar_set_entry(struct rb_global_entry *entry, VALUE val)
 {
     struct trace_data trace;
     struct rb_global_variable *var = entry->var;
+    RB_VM_UNLOCK();
 
     (*var->setter)(val, entry->id, var->data);
 
@@ -995,6 +996,7 @@ rb_gvar_set_entry(struct rb_global_entry *entry, VALUE val)
         trace.val = val;
         rb_ensure(trace_ev, (VALUE)&trace, trace_en, (VALUE)var);
     }
+    RB_VM_LOCK();
     return val;
 }
 
diff --git a/vm.c b/vm.c
@@ -1675,6 +1675,7 @@ 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)
 {
+    VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR());
   again:
     switch (vm_block_handler_type(block_handler)) {
       case block_handler_type_iseq:
@@ -1717,6 +1718,7 @@ 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)
 {
+    VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR());
     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_exec.c b/vm_exec.c
@@ -129,6 +129,7 @@ rb_vm_get_insns_address_table(void)
 static VALUE
 vm_exec_core(rb_execution_context_t *ec)
 {
+    VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR());
     register rb_control_frame_t *reg_cfp = ec->cfp;
     rb_thread_t *th;
 
diff --git a/vm_sync.c b/vm_sync.c
@@ -19,19 +19,15 @@ vm_locked(rb_vm_t *vm)
 void
 RUBY_ASSERT_vm_locking(void)
 {
-    if (rb_multi_ractor_p()) {
-        rb_vm_t *vm = GET_VM();
-        VM_ASSERT(vm_locked(vm));
-    }
+    rb_vm_t *vm = GET_VM();
+    VM_ASSERT(vm_locked(vm));
 }
 
 void
 RUBY_ASSERT_vm_unlocking(void)
 {
-    if (rb_multi_ractor_p()) {
-        rb_vm_t *vm = GET_VM();
-        VM_ASSERT(!vm_locked(vm));
-    }
+    rb_vm_t *vm = GET_VM();
+    VM_ASSERT(!vm_locked(vm));
 }
 #endif
 
diff --git a/vm_sync.h b/vm_sync.h
@@ -56,6 +56,12 @@ rb_vm_lock(const char *file, int line)
 
     if (rb_multi_ractor_p()) {
         rb_vm_lock_body(LOCATION_PARAMS);
+    } else {
+#if VM_CHECK_MODE > 0
+        if (rb_current_execution_context(false)) {
+            rb_vm_lock_body(LOCATION_PARAMS);
+        }
+#endif
     }
 }
 
@@ -64,6 +70,12 @@ rb_vm_unlock(const char *file, int line)
 {
     if (rb_multi_ractor_p()) {
         rb_vm_unlock_body(LOCATION_PARAMS);
+    } else {
+#if VM_CHECK_MODE > 0
+        if (rb_current_execution_context(false)) {
+            rb_vm_unlock_body(LOCATION_PARAMS);
+        }
+#endif
     }
 }
 
@@ -74,6 +86,12 @@ rb_vm_lock_enter(unsigned int *lev, const char *file, int line)
 
     if (rb_multi_ractor_p()) {
         rb_vm_lock_enter_body(lev APPEND_LOCATION_PARAMS);
+    } else {
+#if VM_CHECK_MODE > 0
+        if (rb_current_execution_context(false)) {
+            rb_vm_lock_enter_body(lev APPEND_LOCATION_PARAMS);
+        }
+#endif
     }
 }
 
@@ -84,6 +102,12 @@ rb_vm_lock_enter_nb(unsigned int *lev, const char *file, int line)
 
     if (rb_multi_ractor_p()) {
         rb_vm_lock_enter_body_nb(lev APPEND_LOCATION_PARAMS);
+    } else {
+#if VM_CHECK_MODE > 0
+        if (rb_current_execution_context(false)) {
+            rb_vm_lock_enter_body_nb(lev APPEND_LOCATION_PARAMS);
+        }
+#endif
     }
 }
 
@@ -92,6 +116,12 @@ rb_vm_lock_leave_nb(unsigned int *lev, const char *file, int line)
 {
     if (rb_multi_ractor_p()) {
         rb_vm_lock_leave_body_nb(lev APPEND_LOCATION_PARAMS);
+    } else {
+#if VM_CHECK_MODE > 0
+        if (rb_current_execution_context(false)) {
+            rb_vm_lock_leave_body_nb(lev APPEND_LOCATION_PARAMS);
+        }
+#endif
     }
 }
 
@@ -100,6 +130,12 @@ rb_vm_lock_leave(unsigned int *lev, const char *file, int line)
 {
     if (rb_multi_ractor_p()) {
         rb_vm_lock_leave_body(lev APPEND_LOCATION_PARAMS);
+    } else {
+#if VM_CHECK_MODE > 0
+        if (rb_current_execution_context(false)) {
+            rb_vm_lock_leave_body(lev APPEND_LOCATION_PARAMS);
+        }
+#endif
     }
 }
 
diff --git a/yjit/src/yjit.rs b/yjit/src/yjit.rs
@@ -45,6 +45,14 @@ pub extern "C" fn rb_yjit_init(yjit_enabled: bool) {
 
     // If --yjit-disable, yjit_init() will not be called until RubyVM::YJIT.enable.
     if yjit_enabled {
+
+    // Call YJIT hooks before enabling YJIT to avoid compiling the hooks themselves.
+    // Needs to be done without VM lock held because it can context switch.
+    unsafe {
+        let yjit = rb_const_get(rb_cRubyVM, rust_str_to_id("YJIT"));
+        rb_funcall(yjit, rust_str_to_id("call_jit_hooks"), 0);
+    }
+
         yjit_init();
     }
 }
@@ -54,12 +62,6 @@ fn yjit_init() {
     // TODO: need to make sure that command-line options have been
     // initialized by CRuby
 
-    // Call YJIT hooks before enabling YJIT to avoid compiling the hooks themselves
-    unsafe {
-        let yjit = rb_const_get(rb_cRubyVM, rust_str_to_id("YJIT"));
-        rb_funcall(yjit, rust_str_to_id("call_jit_hooks"), 0);
-    }
-
     // Catch panics to avoid UB for unwinding into C frames.
     // See https://doc.rust-lang.org/nomicon/exception-safety.html
     let result = std::panic::catch_unwind(|| {
@@ -192,6 +194,13 @@ pub extern "C" fn rb_yjit_code_gc(_ec: EcPtr, _ruby_self: VALUE) -> VALUE {
 /// Enable YJIT compilation, returning true if YJIT was previously disabled
 #[no_mangle]
 pub extern "C" fn rb_yjit_enable(_ec: EcPtr, _ruby_self: VALUE, gen_stats: VALUE, print_stats: VALUE, gen_log: VALUE, print_log: VALUE, mem_size: VALUE, call_threshold: VALUE) -> VALUE {
+    // Call YJIT hooks before enabling YJIT to avoid compiling the hooks themselves.
+    // Needs to be done without VM lock held because it can context switch.
+    unsafe {
+        let yjit = rb_const_get(rb_cRubyVM, rust_str_to_id("YJIT"));
+        rb_funcall(yjit, rust_str_to_id("call_jit_hooks"), 0);
+    }
+
     with_vm_lock(src_loc!(), || {
 
         if !mem_size.nil_p() {

Original file line number	Diff line number	Diff line change
`@@ -2773,7 +2773,7 @@ rb_gc_impl_define_finalizer(void *objspace_ptr, VALUE obj, VALUE block)`
`2773`	`2773`
`2774`	`2774`	`for (i = 0; i < len; i++) {`
`2775`	`2775`	`VALUE recv = RARRAY_AREF(table, i);`
`2776`		`- if (rb_equal(recv, block)) {`
	`2776`	`+ if (rb_equal(recv, block)) { // TODO: unsafe, can context switch`
`2777`	`2777`	`RB_GC_VM_UNLOCK(lev);`
`2778`	`2778`	`return recv;`
`2779`	`2779`	`}`
`@@ -2839,8 +2839,8 @@ get_final(long i, void *data)`
`2839`	`2839`	`return RARRAY_AREF(table, i + 1);`
`2840`	`2840`	`}`
`2841`	`2841`
`2842`		`-static void`
`2843`		`-run_final(rb_objspace_t *objspace, VALUE zombie)`
	`2842`	`+static int`
	`2843`	`+run_final(rb_objspace_t *objspace, VALUE zombie, unsigned int lev)`
`2844`	`2844`	`{`
`2845`	`2845`	`if (RZOMBIE(zombie)->dfree) {`
`2846`	`2846`	`RZOMBIE(zombie)->dfree(RZOMBIE(zombie)->data);`
`@@ -2851,7 +2851,9 @@ run_final(rb_objspace_t *objspace, VALUE zombie)`
`2851`	`2851`	`FL_UNSET(zombie, FL_FINALIZE);`
`2852`	`2852`	`st_data_t table;`
`2853`	`2853`	`if (st_delete(finalizer_table, &key, &table)) {`
	`2854`	`+ RB_GC_VM_UNLOCK(lev);`
`2854`	`2855`	`rb_gc_run_obj_finalizer(RARRAY_AREF(table, 0), RARRAY_LEN(table) - 1, get_final, (void *)table);`
	`2856`	`+ lev = RB_GC_VM_LOCK();`
`2855`	`2857`	`}`
`2856`	`2858`	`else {`
`2857`	`2859`	`rb_bug("FL_FINALIZE flag is set, but finalizers are not found");`
`@@ -2860,6 +2862,7 @@ run_final(rb_objspace_t *objspace, VALUE zombie)`
`2860`	`2862`	`else {`
`2861`	`2863`	`GC_ASSERT(!st_lookup(finalizer_table, key, NULL));`
`2862`	`2864`	`}`
	`2865`	`+ return lev;`
`2863`	`2866`	`}`
`2864`	`2867`
`2865`	`2868`	`static void`
`@@ -2874,7 +2877,7 @@ finalize_list(rb_objspace_t *objspace, VALUE zombie)`
`2874`	`2877`
`2875`	`2878`	`int lev = RB_GC_VM_LOCK();`
`2876`	`2879`
`2877`		`- run_final(objspace, zombie);`
	`2880`	`+ lev = run_final(objspace, zombie, lev);`
`2878`	`2881`	`{`
`2879`	`2882`	`GC_ASSERT(BUILTIN_TYPE(zombie) == T_ZOMBIE);`
`2880`	`2883`	`GC_ASSERT(page->heap->final_slots_count > 0);`
Original file line number	Diff line number	Diff line change
`@@ -14432,7 +14432,13 @@ argf_filename(VALUE argf)`
`14432`	`14432`	`static VALUE`
`14433`	`14433`	`argf_filename_getter(ID id, VALUE *var)`
`14434`	`14434`	`{`
`14435`		`- return argf_filename(*var);`
	`14435`	`+ VALUE filename = Qnil;`
	`14436`	`+ RB_VM_UNLOCK();`
	`14437`	`+ {`
	`14438`	`+ filename = argf_filename(*var);`
	`14439`	`+ }`
	`14440`	`+ RB_VM_LOCK();`
	`14441`	`+ return filename;`
`14436`	`14442`	`}`
`14437`	`14443`
`14438`	`14444`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ ractor_status_set(rb_ractor_t *r, enum ractor_status status)`
`164`	`164`	`// check 1`
`165`	`165`	`if (r->status_ != ractor_created) {`
`166`	`166`	`VM_ASSERT(r == GET_RACTOR()); // only self-modification is allowed.`
`167`		`- ASSERT_vm_locking();`
	`167`	`+ VM_ASSERT((rb_multi_ractor_p() && RB_VM_LOCKED_P()) \|\| true);`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`// check2: transition check. assume it will be vanished on non-debug build.`
Original file line number	Diff line number	Diff line change
`@@ -12707,7 +12707,9 @@ Init_String(void)`
`12707`	`12707`	`{`
`12708`	`12708`	`rb_cString = rb_define_class("String", rb_cObject);`
`12709`	`12709`
`12710`		`- rb_concurrent_set_foreach_with_replace(fstring_table_obj, fstring_set_class_i, NULL);`
	`12710`	`+ RB_VM_LOCKING() {`
	`12711`	`+ rb_concurrent_set_foreach_with_replace(fstring_table_obj, fstring_set_class_i, NULL);`
	`12712`	`+ }`
`12711`	`12713`
`12712`	`12714`	`rb_include_module(rb_cString, rb_mComparable);`
`12713`	`12715`	`rb_define_alloc_func(rb_cString, empty_str_alloc);`
Original file line number	Diff line number	Diff line change
`@@ -390,7 +390,9 @@ rb_free_global_symbol_table_i(VALUE sym_ptr, void data)`
`390`	`390`	`void`
`391`	`391`	`rb_free_global_symbol_table(void)`
`392`	`392`	`{`
`393`		`- rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_free_global_symbol_table_i, NULL);`
	`393`	`+ RB_VM_LOCKING() {`
	`394`	`+ rb_concurrent_set_foreach_with_replace(ruby_global_symbols.sym_set, rb_free_global_symbol_table_i, NULL);`
	`395`	`+ }`
`394`	`396`	`}`
`395`	`397`
`396`	`398`	`WARN_UNUSED_RESULT(static ID lookup_str_id(VALUE str));`
Original file line number	Diff line number	Diff line change
`@@ -1472,6 +1472,7 @@ rb_thread_sleep(int sec)`
`1472`	`1472`	`static void`
`1473`	`1473`	`rb_thread_schedule_limits(uint32_t limits_us)`
`1474`	`1474`	`{`
	`1475`	`+ VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR());`
`1475`	`1476`	`if (!rb_thread_alone()) {`
`1476`	`1477`	`rb_thread_t *th = GET_THREAD();`
`1477`	`1478`	`RUBY_DEBUG_LOG("us:%u", (unsigned int)limits_us);`
Original file line number	Diff line number	Diff line change
`@@ -1025,6 +1025,7 @@ thread_sched_to_waiting_common(struct rb_thread_sched sched, rb_thread_t th)`
`1025`	`1025`	`static void`
`1026`	`1026`	`thread_sched_to_waiting(struct rb_thread_sched sched, rb_thread_t th)`
`1027`	`1027`	`{`
	`1028`	`+ VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR()); // never context switch with VM lock held`
`1028`	`1029`	`thread_sched_lock(sched, th);`
`1029`	`1030`	`{`
`1030`	`1031`	`thread_sched_to_waiting_common(sched, th);`
Original file line number	Diff line number	Diff line change
`@@ -412,10 +412,11 @@ int rb_require_internal_silent(VALUE fname);`
`412`	`412`	`static const rb_transcoder *`
`413`	`413`	`load_transcoder_entry(transcoder_entry_t *entry)`
`414`	`414`	`{`
`415`		`- ASSERT_vm_unlocking();`
`416`	`415`	`if (entry->transcoder)`
`417`	`416`	`return entry->transcoder;`
`418`	`417`
	`418`	`+ ASSERT_vm_unlocking();`
	`419`	`+`
`419`	`420`	`if (entry->lib) {`
`420`	`421`	`const char *const lib = entry->lib;`
`421`	`422`	`const size_t len = strlen(lib);`
`@@ -1854,7 +1855,13 @@ rb_econv_asciicompat_encoding(const char *ascii_incompat_name)`
`1854`	`1855`	`RB_VM_LOCK_ENTER_LEV(&lev);`
`1855`	`1856`	`}`
`1856`	`1857`	`else {`
	`1858`	`+#if RUBY_DEBUG > 0`
	`1859`	`+ RB_VM_LOCK_LEAVE_LEV(&lev);`
	`1860`	`+#endif`
`1857`	`1861`	`st_foreach(table2, asciicompat_encoding_i, (st_data_t)&data);`
	`1862`	`+#if RUBY_DEBUG > 0`
	`1863`	`+ RB_VM_LOCK_ENTER_LEV(&lev);`
	`1864`	`+#endif`
`1858`	`1865`	`}`
`1859`	`1866`	`}`
`1860`	`1867`