Add lock_file and lock_line to VM lock in debug mode

luke-gruber · luke-gruber · commit 1fa307d7cba2 · 2025-09-11T12:38:00.000-04:00
diff --git a/encoding.c b/encoding.c
@@ -422,6 +422,7 @@ int
 rb_enc_register(const char *name, rb_encoding *encoding)
 {
     int index;
+    bool set_const = false;
 
     GLOBAL_ENC_TABLE_LOCKING(enc_table) {
         index = enc_registered(enc_table, name);
@@ -440,9 +441,12 @@ rb_enc_register(const char *name, rb_encoding *encoding)
         }
         else {
             index = enc_register(enc_table, name, encoding);
-            set_encoding_const(name, rb_enc_from_index(index));
+            set_const = true;
         }
     }
+    if (set_const) {
+        set_encoding_const(name, rb_enc_from_index(index));
+    }
     return index;
 }
 
@@ -473,13 +477,14 @@ rb_enc_registered(const char *name)
 void
 rb_encdb_declare(const char *name)
 {
+    int idx;
     GLOBAL_ENC_TABLE_LOCKING(enc_table) {
-        int idx = enc_registered(enc_table, name);
+        idx = enc_registered(enc_table, name);
         if (idx < 0) {
             idx = enc_register(enc_table, name, 0);
         }
-        set_encoding_const(name, rb_enc_from_index(idx));
     }
+    set_encoding_const(name, rb_enc_from_index(idx));
 }
 
 static void
@@ -538,7 +543,6 @@ enc_replicate(struct enc_table *enc_table, const char *name, rb_encoding *encodi
     idx = enc_register(enc_table, name, encoding);
     if (idx < 0) rb_raise(rb_eArgError, "invalid encoding name: %s", name);
     set_base_encoding(enc_table, idx, encoding);
-    set_encoding_const(name, rb_enc_from_index(idx));
     return idx;
 }
 
@@ -553,7 +557,6 @@ enc_replicate_with_index(struct enc_table *enc_table, const char *name, rb_encod
     }
     if (idx >= 0) {
         set_base_encoding(enc_table, idx, origenc);
-        set_encoding_const(name, rb_enc_from_index(idx));
     }
     else {
         rb_raise(rb_eArgError, "failed to replicate encoding");
@@ -576,6 +579,8 @@ rb_encdb_replicate(const char *name, const char *orig)
         r = enc_replicate_with_index(enc_table, name, rb_enc_from_index(origidx), idx);
     }
 
+    set_encoding_const(name, rb_enc_from_index(r));
+
     return r;
 }
 
@@ -589,6 +594,7 @@ rb_define_dummy_encoding(const char *name)
         rb_encoding *enc = enc_table->list[index].enc;
         ENC_SET_DUMMY((rb_raw_encoding *)enc);
     }
+    set_encoding_const(name, rb_enc_from_index(index));
 
     return index;
 }
@@ -606,6 +612,8 @@ rb_encdb_dummy(const char *name)
         ENC_SET_DUMMY((rb_raw_encoding *)enc);
     }
 
+    set_encoding_const(name, rb_enc_from_index(index));
+
     return index;
 }
 
@@ -672,18 +680,20 @@ enc_alias_internal(struct enc_table *enc_table, const char *alias, int idx)
 }
 
 static int
-enc_alias(struct enc_table *enc_table, const char *alias, int idx)
+enc_alias(struct enc_table *enc_table, const char *alias, int idx, bool *set_const)
 {
     if (!valid_encoding_name_p(alias)) return -1;
-    if (!enc_alias_internal(enc_table, alias, idx))
-        set_encoding_const(alias, enc_from_index(enc_table, idx));
+    if (!enc_alias_internal(enc_table, alias, idx)) {
+        *set_const = true;
+    }
     return idx;
 }
 
 int
 rb_enc_alias(const char *alias, const char *orig)
 {
     int idx, r;
+    bool set_const = false;
     GLOBAL_ENC_TABLE_LOCKING(enc_table) {
         enc_check_addable(enc_table, alias); // can raise
     }
@@ -692,7 +702,11 @@ rb_enc_alias(const char *alias, const char *orig)
     if (idx < 0) return -1;
 
     GLOBAL_ENC_TABLE_LOCKING(enc_table) {
-        r = enc_alias(enc_table, alias, idx);
+        r = enc_alias(enc_table, alias, idx, &set_const);
+    }
+
+    if (set_const) {
+        set_encoding_const(alias, rb_enc_from_index(idx));
     }
 
     return r;
@@ -702,14 +716,18 @@ int
 rb_encdb_alias(const char *alias, const char *orig)
 {
     int r;
+    bool set_const = false;
 
     GLOBAL_ENC_TABLE_LOCKING(enc_table) {
         int idx = enc_registered(enc_table, orig);
 
         if (idx < 0) {
             idx = enc_register(enc_table, orig, 0);
         }
-        r = enc_alias(enc_table, alias, idx);
+        r = enc_alias(enc_table, alias, idx, &set_const);
+    }
+    if (set_const) {
+        set_encoding_const(alias, rb_enc_from_index(r));
     }
 
     return r;
@@ -1818,6 +1836,7 @@ set_default_internal(VALUE klass, VALUE encoding)
 static void
 set_encoding_const(const char *name, rb_encoding *enc)
 {
+    ASSERT_vm_unlocking();
     VALUE encoding = rb_enc_from_encoding(enc);
     char *s = (char *)name;
     int haslower = 0, hasupper = 0, valid = 0;
diff --git a/thread.c b/thread.c
@@ -1472,7 +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());
+    ASSERT_vm_unlocking();
     if (!rb_thread_alone()) {
         rb_thread_t *th = GET_THREAD();
         RUBY_DEBUG_LOG("us:%u", (unsigned int)limits_us);
@@ -2596,6 +2596,7 @@ rb_threadptr_execute_interrupts(rb_thread_t *th, int blocking_timing)
     int ret = FALSE;
 
     VM_ASSERT(GET_THREAD() == th);
+    ASSERT_vm_unlocking();
 
     if (th->ec->raised_flag) return ret;
 
diff --git a/thread_pthread.c b/thread_pthread.c
@@ -1025,7 +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
+    ASSERT_vm_unlocking();
     thread_sched_lock(sched, th);
     {
         thread_sched_to_waiting_common(sched, th);
diff --git a/variable.c b/variable.c
@@ -3857,6 +3857,7 @@ 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);
     }
diff --git a/vm.c b/vm.c
@@ -1675,7 +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());
+    ASSERT_vm_unlocking();
   again:
     switch (vm_block_handler_type(block_handler)) {
       case block_handler_type_iseq:
@@ -1718,7 +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());
+    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_core.h b/vm_core.h
@@ -675,6 +675,10 @@ typedef struct rb_vm_struct {
             rb_nativethread_lock_t lock;
             struct rb_ractor_struct *lock_owner;
             unsigned int lock_rec;
+#if VM_CHECK_MODE > 0
+            const char *lock_file;
+            int lock_line;
+#endif
 
             // join at exit
             rb_nativethread_cond_t terminate_cond;
@@ -687,7 +691,7 @@ typedef struct rb_vm_struct {
             rb_nativethread_cond_t barrier_complete_cond;
             rb_nativethread_cond_t barrier_release_cond;
 #endif
-        } sync;
+        } sync; // VM lock
 
 #ifdef RUBY_THREAD_PTHREAD_H
         // ractor scheduling
diff --git a/vm_exec.c b/vm_exec.c
@@ -129,7 +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());
+    ASSERT_vm_unlocking();
     register rb_control_frame_t *reg_cfp = ec->cfp;
     rb_thread_t *th;
 
diff --git a/vm_sync.c b/vm_sync.c
@@ -27,7 +27,14 @@ void
 RUBY_ASSERT_vm_unlocking(void)
 {
     rb_vm_t *vm = GET_VM();
-    VM_ASSERT(!vm_locked(vm));
+    if (vm_locked(vm)) {
+        const char *file = vm->ractor.sync.lock_file;
+        int line = vm->ractor.sync.lock_line;
+        if (file) {
+            fprintf(stderr, "Last locked at %s:%d\n", file, line);
+        }
+        VM_ASSERT(!vm_locked(vm));
+    }
 }
 #endif
 
@@ -75,6 +82,11 @@ vm_lock_enter(rb_ractor_t *cr, rb_vm_t *vm, bool locked, bool no_barrier, unsign
         VM_ASSERT(vm->ractor.sync.lock_owner == NULL);
         VM_ASSERT(vm->ractor.sync.lock_rec == 0);
 
+#if VM_CHECK_MODE > 0
+        vm->ractor.sync.lock_file = file;
+        vm->ractor.sync.lock_line = line;
+#endif
+
         // barrier
         if (vm_need_barrier(no_barrier, cr, vm)) {
             rb_execution_context_t *ec = GET_EC();
diff --git a/vm_sync.h b/vm_sync.h
@@ -4,7 +4,7 @@
 #include "vm_debug.h"
 #include "debug_counter.h"
 
-#if USE_RUBY_DEBUG_LOG
+#if USE_RUBY_DEBUG_LOG || RUBY_DEBUG > 0 || VM_CHECK_MODE > 0
 #define LOCATION_ARGS const char *file, int line
 #define LOCATION_PARAMS file, line
 #define APPEND_LOCATION_ARGS , const char *file, int line
diff --git a/yjit/src/yjit.rs b/yjit/src/yjit.rs
@@ -240,14 +240,13 @@ pub extern "C" fn rb_yjit_enable(_ec: EcPtr, _ruby_self: VALUE, gen_stats: VALUE
 
         yjit_init();
 
-        // Add "+YJIT" to RUBY_DESCRIPTION
-        extern "C" {
-            fn ruby_set_yjit_description();
-        }
-        unsafe { ruby_set_yjit_description(); }
-
-        Qtrue
-    })
+    });
+    // Add "+YJIT" to RUBY_DESCRIPTION
+    extern "C" {
+        fn ruby_set_yjit_description();
+    }
+    unsafe { ruby_set_yjit_description(); }
+    Qtrue
 }
 
 /// Simulate a situation where we are out of executable memory

Original file line number	Diff line number	Diff line change
`@@ -422,6 +422,7 @@ int`
`422`	`422`	`rb_enc_register(const char name, rb_encoding encoding)`
`423`	`423`	`{`
`424`	`424`	`int index;`
	`425`	`+ bool set_const = false;`
`425`	`426`
`426`	`427`	`GLOBAL_ENC_TABLE_LOCKING(enc_table) {`
`427`	`428`	`index = enc_registered(enc_table, name);`
`@@ -440,9 +441,12 @@ rb_enc_register(const char name, rb_encoding encoding)`
`440`	`441`	`}`
`441`	`442`	`else {`
`442`	`443`	`index = enc_register(enc_table, name, encoding);`
`443`		`- set_encoding_const(name, rb_enc_from_index(index));`
	`444`	`+ set_const = true;`
`444`	`445`	`}`
`445`	`446`	`}`
	`447`	`+ if (set_const) {`
	`448`	`+ set_encoding_const(name, rb_enc_from_index(index));`
	`449`	`+ }`
`446`	`450`	`return index;`
`447`	`451`	`}`
`448`	`452`
`@@ -473,13 +477,14 @@ rb_enc_registered(const char *name)`
`473`	`477`	`void`
`474`	`478`	`rb_encdb_declare(const char *name)`
`475`	`479`	`{`
	`480`	`+ int idx;`
`476`	`481`	`GLOBAL_ENC_TABLE_LOCKING(enc_table) {`
`477`		`- int idx = enc_registered(enc_table, name);`
	`482`	`+ idx = enc_registered(enc_table, name);`
`478`	`483`	`if (idx < 0) {`
`479`	`484`	`idx = enc_register(enc_table, name, 0);`
`480`	`485`	`}`
`481`		`- set_encoding_const(name, rb_enc_from_index(idx));`
`482`	`486`	`}`
	`487`	`+ set_encoding_const(name, rb_enc_from_index(idx));`
`483`	`488`	`}`
`484`	`489`
`485`	`490`	`static void`
`@@ -538,7 +543,6 @@ enc_replicate(struct enc_table enc_table, const char name, rb_encoding *encodi`
`538`	`543`	`idx = enc_register(enc_table, name, encoding);`
`539`	`544`	`if (idx < 0) rb_raise(rb_eArgError, "invalid encoding name: %s", name);`
`540`	`545`	`set_base_encoding(enc_table, idx, encoding);`
`541`		`- set_encoding_const(name, rb_enc_from_index(idx));`
`542`	`546`	`return idx;`
`543`	`547`	`}`
`544`	`548`
`@@ -553,7 +557,6 @@ enc_replicate_with_index(struct enc_table enc_table, const char name, rb_encod`
`553`	`557`	`}`
`554`	`558`	`if (idx >= 0) {`
`555`	`559`	`set_base_encoding(enc_table, idx, origenc);`
`556`		`- set_encoding_const(name, rb_enc_from_index(idx));`
`557`	`560`	`}`
`558`	`561`	`else {`
`559`	`562`	`rb_raise(rb_eArgError, "failed to replicate encoding");`
`@@ -576,6 +579,8 @@ rb_encdb_replicate(const char name, const char orig)`
`576`	`579`	`r = enc_replicate_with_index(enc_table, name, rb_enc_from_index(origidx), idx);`
`577`	`580`	`}`
`578`	`581`
	`582`	`+ set_encoding_const(name, rb_enc_from_index(r));`
	`583`	`+`
`579`	`584`	`return r;`
`580`	`585`	`}`
`581`	`586`
`@@ -589,6 +594,7 @@ rb_define_dummy_encoding(const char *name)`
`589`	`594`	`rb_encoding *enc = enc_table->list[index].enc;`
`590`	`595`	`ENC_SET_DUMMY((rb_raw_encoding *)enc);`
`591`	`596`	`}`
	`597`	`+ set_encoding_const(name, rb_enc_from_index(index));`
`592`	`598`
`593`	`599`	`return index;`
`594`	`600`	`}`
`@@ -606,6 +612,8 @@ rb_encdb_dummy(const char *name)`
`606`	`612`	`ENC_SET_DUMMY((rb_raw_encoding *)enc);`
`607`	`613`	`}`
`608`	`614`
	`615`	`+ set_encoding_const(name, rb_enc_from_index(index));`
	`616`	`+`
`609`	`617`	`return index;`
`610`	`618`	`}`
`611`	`619`
`@@ -672,18 +680,20 @@ enc_alias_internal(struct enc_table enc_table, const char alias, int idx)`
`672`	`680`	`}`
`673`	`681`
`674`	`682`	`static int`
`675`		`-enc_alias(struct enc_table enc_table, const char alias, int idx)`
	`683`	`+enc_alias(struct enc_table enc_table, const char alias, int idx, bool *set_const)`
`676`	`684`	`{`
`677`	`685`	`if (!valid_encoding_name_p(alias)) return -1;`
`678`		`- if (!enc_alias_internal(enc_table, alias, idx))`
`679`		`- set_encoding_const(alias, enc_from_index(enc_table, idx));`
	`686`	`+ if (!enc_alias_internal(enc_table, alias, idx)) {`
	`687`	`+ *set_const = true;`
	`688`	`+ }`
`680`	`689`	`return idx;`
`681`	`690`	`}`
`682`	`691`
`683`	`692`	`int`
`684`	`693`	`rb_enc_alias(const char alias, const char orig)`
`685`	`694`	`{`
`686`	`695`	`int idx, r;`
	`696`	`+ bool set_const = false;`
`687`	`697`	`GLOBAL_ENC_TABLE_LOCKING(enc_table) {`
`688`	`698`	`enc_check_addable(enc_table, alias); // can raise`
`689`	`699`	`}`
`@@ -692,7 +702,11 @@ rb_enc_alias(const char alias, const char orig)`
`692`	`702`	`if (idx < 0) return -1;`
`693`	`703`
`694`	`704`	`GLOBAL_ENC_TABLE_LOCKING(enc_table) {`
`695`		`- r = enc_alias(enc_table, alias, idx);`
	`705`	`+ r = enc_alias(enc_table, alias, idx, &set_const);`
	`706`	`+ }`
	`707`	`+`
	`708`	`+ if (set_const) {`
	`709`	`+ set_encoding_const(alias, rb_enc_from_index(idx));`
`696`	`710`	`}`
`697`	`711`
`698`	`712`	`return r;`
`@@ -702,14 +716,18 @@ int`
`702`	`716`	`rb_encdb_alias(const char alias, const char orig)`
`703`	`717`	`{`
`704`	`718`	`int r;`
	`719`	`+ bool set_const = false;`
`705`	`720`
`706`	`721`	`GLOBAL_ENC_TABLE_LOCKING(enc_table) {`
`707`	`722`	`int idx = enc_registered(enc_table, orig);`
`708`	`723`
`709`	`724`	`if (idx < 0) {`
`710`	`725`	`idx = enc_register(enc_table, orig, 0);`
`711`	`726`	`}`
`712`		`- r = enc_alias(enc_table, alias, idx);`
	`727`	`+ r = enc_alias(enc_table, alias, idx, &set_const);`
	`728`	`+ }`
	`729`	`+ if (set_const) {`
	`730`	`+ set_encoding_const(alias, rb_enc_from_index(r));`
`713`	`731`	`}`
`714`	`732`
`715`	`733`	`return r;`
`@@ -1818,6 +1836,7 @@ set_default_internal(VALUE klass, VALUE encoding)`
`1818`	`1836`	`static void`
`1819`	`1837`	`set_encoding_const(const char name, rb_encoding enc)`
`1820`	`1838`	`{`
	`1839`	`+ ASSERT_vm_unlocking();`
`1821`	`1840`	`VALUE encoding = rb_enc_from_encoding(enc);`
`1822`	`1841`	`char s = (char )name;`
`1823`	`1842`	`int haslower = 0, hasupper = 0, valid = 0;`
Original file line number	Diff line number	Diff line change
`@@ -1025,7 +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`	`+ ASSERT_vm_unlocking();`
`1029`	`1029`	`thread_sched_lock(sched, th);`
`1030`	`1030`	`{`
`1031`	`1031`	`thread_sched_to_waiting_common(sched, th);`
Original file line number	Diff line number	Diff line change
`@@ -3857,6 +3857,7 @@ static void`
`3857`	`3857`	`const_added(VALUE klass, ID const_name)`
`3858`	`3858`	`{`
`3859`	`3859`	`if (GET_VM()->running) {`
	`3860`	`+ ASSERT_vm_unlocking();`
`3860`	`3861`	`VALUE name = ID2SYM(const_name);`
`3861`	`3862`	`rb_funcallv(klass, idConst_added, 1, &name);`
`3862`	`3863`	`}`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ rb_vm_get_insns_address_table(void)`
`129`	`129`	`static VALUE`
`130`	`130`	`vm_exec_core(rb_execution_context_t *ec)`
`131`	`131`	`{`
`132`		`- VM_ASSERT(GET_VM()->ractor.sync.lock_owner != GET_RACTOR());`
	`132`	`+ ASSERT_vm_unlocking();`
`133`	`133`	`register rb_control_frame_t *reg_cfp = ec->cfp;`
`134`	`134`	`rb_thread_t *th;`
`135`	`135`