Autoload encodings on the main ractor

None of the datastructures involved in the require process are
safe to call on a secondary ractor, however when autoloading
encodings, we do so from the current ractor.

So all sorts of corruption can happen when using an autoloaded
encoding for the first time from a secondary ractor.

Author: byroot

encoding.c

@@ -725,38 +725,12 @@ rb_enc_get_from_index(int index)
 
 int rb_require_internal_silent(VALUE fname);
 
-static VALUE
-require_silent_safe(VALUE fname)
-{
-    return INT2NUM(rb_require_internal_silent(fname));
-}
-
-static int
-require_silent_sync(VALUE fname)
-{
-    int state;
-    VALUE retval;
-    RB_VM_LOCKING() {
-        VALUE debug = ruby_debug;
-        VALUE errinfo = rb_errinfo();
-
-        ruby_debug = Qfalse;
-
-        retval = rb_protect(require_silent_safe, fname, &state);
-
-        ruby_debug = debug;
-        rb_set_errinfo(errinfo);
-    }
-    if (state) {
-        rb_jump_tag(state);
-    }
-    return NUM2INT(retval);
-}
-
 static int
 load_encoding(const char *name)
 {
     VALUE enclib = rb_sprintf("enc/%s.so", name);
+    VALUE debug = ruby_debug;
+    VALUE errinfo;
     char *s = RSTRING_PTR(enclib) + 4, *e = RSTRING_END(enclib) - 3;
     int loaded;
     int idx;
@@ -767,7 +741,11 @@ load_encoding(const char *name)
         ++s;
     }
     enclib = rb_fstring(enclib);
-    loaded = require_silent_sync(enclib);
+    ruby_debug = Qfalse;
+    errinfo = rb_errinfo();
+    loaded = rb_require_internal_silent(enclib);
+    ruby_debug = debug;
+    rb_set_errinfo(errinfo);
 
     GLOBAL_ENC_TABLE_LOCKING(enc_table) {
         if (loaded < 0 || 1 < loaded) {
@@ -785,36 +763,47 @@ load_encoding(const char *name)
 }
 
 static int
-enc_autoload_body(struct enc_table *enc_table, rb_encoding *enc)
+enc_autoload_body(rb_encoding *enc)
 {
-    rb_encoding *base = enc_table->list[ENC_TO_ENCINDEX(enc)].base;
+    rb_encoding *base;
+    int i = 0;
+
+    GLOBAL_ENC_TABLE_LOCKING(enc_table) {
+        base = enc_table->list[ENC_TO_ENCINDEX(enc)].base;
+        if (base) {
+            do {
+                if (i >= enc_table->count) {
+                    i = -1;
+                    break;
+                }
+            } while (enc_table->list[i].enc != base && (++i, 1));
+        }
+    }
+
+    if (i == -1) return -1;
 
     if (base) {
-        int i = 0;
-        do {
-            if (i >= enc_table->count) return -1;
-        } while (enc_table->list[i].enc != base && (++i, 1));
         if (rb_enc_autoload_p(base)) {
             if (rb_enc_autoload(base) < 0) return -1;
         }
         i = enc->ruby_encoding_index;
-        enc_register_at(enc_table, i & ENC_INDEX_MASK, rb_enc_name(enc), base);
+
+        GLOBAL_ENC_TABLE_LOCKING(enc_table) {
+            enc_register_at(enc_table, i & ENC_INDEX_MASK, rb_enc_name(enc), base);
+        }
+
         ((rb_raw_encoding *)enc)->ruby_encoding_index = i;
         i &= ENC_INDEX_MASK;
         return i;
     }
-    else {
-        return -2;
-    }
+
+    return -2;
 }
 
 int
 rb_enc_autoload(rb_encoding *enc)
 {
-    int i;
-    GLOBAL_ENC_TABLE_LOCKING(enc_table) {
-        i = enc_autoload_body(enc_table, enc);
-    }
+    int i = enc_autoload_body(enc);
     if (i == -2) {
         i = load_encoding(rb_enc_name(enc));
     }

load.c

@@ -1525,6 +1525,10 @@ require_internal(rb_execution_context_t *ec, VALUE fname, int exception, bool wa
 int
 rb_require_internal_silent(VALUE fname)
 {
+    if (!rb_ractor_main_p()) {
+        return NUM2INT(rb_ractor_require(fname, true));
+    }
+
     rb_execution_context_t *ec = GET_EC();
     return require_internal(ec, fname, 1, false);
 }
@@ -1561,7 +1565,7 @@ rb_require_string_internal(VALUE fname, bool resurrect)
     // main ractor check
     if (!rb_ractor_main_p()) {
         if (resurrect) fname = rb_str_resurrect(fname);
-        return rb_ractor_require(fname);
+        return rb_ractor_require(fname, false);
     }
     else {
         int result = require_internal(ec, fname, 1, RTEST(ruby_verbose));

ractor.c

@@ -2263,6 +2263,8 @@ struct cross_ractor_require {
     // autoload
     VALUE module;
     ID name;
+
+    bool silent;
 };
 
 static void
@@ -2294,7 +2296,14 @@ require_body(VALUE data)
 
     ID require;
     CONST_ID(require, "require");
-    crr->result = rb_funcallv(Qnil, require, 1, &crr->feature);
+
+    if (crr->silent) {
+        int rb_require_internal_silent(VALUE fname);
+        crr->result = INT2NUM(rb_require_internal_silent(crr->feature));
+    }
+    else {
+        crr->result = rb_funcallv(Qnil, require, 1, &crr->feature);
+    }
 
     return Qnil;
 }
@@ -2338,10 +2347,21 @@ ractor_require_protect(VALUE crr_obj, VALUE (*func)(VALUE))
     struct cross_ractor_require *crr;
     TypedData_Get_Struct(crr_obj, struct cross_ractor_require, &cross_ractor_require_data_type, crr);
 
+    VALUE debug, errinfo;
+    if (crr->silent) {
+        debug = ruby_debug;
+        errinfo = rb_errinfo();
+    }
+
     // catch any error
     rb_rescue2(func, (VALUE)crr,
                require_rescue, (VALUE)crr, rb_eException, 0);
 
+    if (crr->silent) {
+        ruby_debug = debug;
+        rb_set_errinfo(errinfo);
+    }
+
     rb_rescue2(require_result_copy_body, (VALUE)crr,
                require_result_copy_resuce, (VALUE)crr, rb_eException, 0);
 
@@ -2357,8 +2377,11 @@ ractor_require_func(void *crr_obj)
 }
 
 VALUE
-rb_ractor_require(VALUE feature)
+rb_ractor_require(VALUE feature, bool silent)
 {
+    // We're about to block on the main ractor, so if we're holding the global lock we'll deadlock.
+    ASSERT_vm_unlocking();
+
     struct cross_ractor_require *crr;
     VALUE crr_obj = TypedData_Make_Struct(0, struct cross_ractor_require, &cross_ractor_require_data_type, crr);
     FL_SET_RAW(crr_obj, RUBY_FL_SHAREABLE);
@@ -2368,6 +2391,7 @@ rb_ractor_require(VALUE feature)
     crr->port = ractor_port_new(GET_RACTOR());
     crr->result = Qundef;
     crr->exception = Qundef;
+    crr->silent = silent;
 
     rb_execution_context_t *ec = GET_EC();
     rb_ractor_t *main_r = GET_VM()->ractor.main_ractor;
@@ -2395,7 +2419,7 @@ rb_ractor_require(VALUE feature)
 static VALUE
 ractor_require(rb_execution_context_t *ec, VALUE self, VALUE feature)
 {
-    return rb_ractor_require(feature);
+    return rb_ractor_require(feature, false);
 }
 
 static VALUE

ractor_core.h

@@ -134,7 +134,7 @@ void rb_ractor_terminate_all(void);
 bool rb_ractor_main_p_(void);
 void rb_ractor_atfork(rb_vm_t *vm, rb_thread_t *th);
 void rb_ractor_terminate_atfork(rb_vm_t *vm, rb_ractor_t *th);
-VALUE rb_ractor_require(VALUE feature);
+VALUE rb_ractor_require(VALUE feature, bool silent);
 VALUE rb_ractor_autoload_load(VALUE space, ID id);
 
 VALUE rb_ractor_ensure_shareable(VALUE obj, VALUE name);