Disable GC during sandwitched frame again

Author: kateinoigakukun

ext/witapi/bindgen/rb-abi-guest.c

@@ -205,6 +205,16 @@ __attribute__((export_name("rb-vm-bugreport: func() -> ()")))
 void __wasm_export_rb_abi_guest_rb_vm_bugreport(void) {
   rb_abi_guest_rb_vm_bugreport();
 }
+__attribute__((export_name("rb-gc-enable: func() -> bool")))
+int32_t __wasm_export_rb_abi_guest_rb_gc_enable(void) {
+  bool ret = rb_abi_guest_rb_gc_enable();
+  return ret;
+}
+__attribute__((export_name("rb-gc-disable: func() -> bool")))
+int32_t __wasm_export_rb_abi_guest_rb_gc_disable(void) {
+  bool ret = rb_abi_guest_rb_gc_disable();
+  return ret;
+}
 __attribute__((export_name("rb-set-should-prohibit-rewind: func(new-value: bool) -> bool")))
 int32_t __wasm_export_rb_abi_guest_rb_set_should_prohibit_rewind(int32_t arg) {
   bool ret = rb_abi_guest_rb_set_should_prohibit_rewind(arg);

ext/witapi/bindgen/rb-abi-guest.h

@@ -68,6 +68,8 @@ extern "C"
   void rb_abi_guest_rb_clear_errinfo(void);
   void rb_abi_guest_rstring_ptr(rb_abi_guest_rb_abi_value_t value, rb_abi_guest_string_t *ret0);
   void rb_abi_guest_rb_vm_bugreport(void);
+  bool rb_abi_guest_rb_gc_enable(void);
+  bool rb_abi_guest_rb_gc_disable(void);
   bool rb_abi_guest_rb_set_should_prohibit_rewind(bool new_value);
   #ifdef __cplusplus
 }

ext/witapi/bindgen/rb-abi-guest.wit

@@ -19,4 +19,7 @@ rstring-ptr: func(value: rb-abi-value) -> string
 
 rb-vm-bugreport: func()
 
+rb-gc-enable: func() -> bool
+rb-gc-disable: func() -> bool
+
 rb-set-should-prohibit-rewind: func(new-value: bool) -> bool

ext/witapi/witapi-core.c

@@ -329,6 +329,15 @@ void rb_vm_bugreport(const void *);
 
 void rb_abi_guest_rb_vm_bugreport(void) { rb_vm_bugreport(NULL); }
 
+bool rb_abi_guest_rb_gc_enable(void) {
+  return rb_gc_enable() == Qtrue;
+}
+
+VALUE rb_gc_disable_no_rest(void);
+bool rb_abi_guest_rb_gc_disable(void) {
+  return rb_gc_disable_no_rest() == Qtrue;
+}
+
 bool rb_abi_guest_rb_set_should_prohibit_rewind(bool value) {
   bool old = rb_should_prohibit_rewind;
   rb_should_prohibit_rewind = value;

packages/npm-packages/ruby-wasm-wasi/src/bindgen/rb-abi-guest.d.ts

@@ -80,6 +80,8 @@ export class RbAbiGuest {
   rbClearErrinfo(): void;
   rstringPtr(value: RbAbiValue): string;
   rbVmBugreport(): void;
+  rbGcEnable(): boolean;
+  rbGcDisable(): boolean;
   rbSetShouldProhibitRewind(newValue: boolean): boolean;
 }
 

packages/npm-packages/ruby-wasm-wasi/src/bindgen/rb-abi-guest.js

@@ -161,6 +161,16 @@ export class RbAbiGuest {
   rbVmBugreport() {
     this._exports['rb-vm-bugreport: func() -> ()']();
   }
+  rbGcEnable() {
+    const ret = this._exports['rb-gc-enable: func() -> bool']();
+    const bool0 = ret;
+    return bool0 == 0 ? false : (bool0 == 1 ? true : throw_invalid_bool());
+  }
+  rbGcDisable() {
+    const ret = this._exports['rb-gc-disable: func() -> bool']();
+    const bool0 = ret;
+    return bool0 == 0 ? false : (bool0 == 1 ? true : throw_invalid_bool());
+  }
   rbSetShouldProhibitRewind(arg0) {
     const ret = this._exports['rb-set-should-prohibit-rewind: func(new-value: bool) -> bool'](arg0 ? 1 : 0);
     const bool0 = ret;

packages/npm-packages/ruby-wasm-wasi/src/index.ts

@@ -38,7 +38,7 @@ export class RubyVM {
     // Wrap exported functions from Ruby VM to prohibit nested VM operation
     // if the call stack has sandwitched JS frames like JS -> Ruby -> JS -> Ruby.
     const proxyExports = (exports: RbAbi.RbAbiGuest) => {
-      const excludedMethods: (keyof RbAbi.RbAbiGuest)[] = ["addToImports", "instantiate", "rbSetShouldProhibitRewind"];
+      const excludedMethods: (keyof RbAbi.RbAbiGuest)[] = ["addToImports", "instantiate", "rbSetShouldProhibitRewind", "rbGcDisable", "rbGcEnable"];
       const excluded = ["constructor"].concat(excludedMethods);
       // wrap all methods in RbAbi.RbAbiGuest class
       for (const key of Object.getOwnPropertyNames(RbAbi.RbAbiGuest.prototype)) {
@@ -49,15 +49,18 @@ export class RubyVM {
         if (typeof value === "function") {
           exports[key] = (...args: any[]) => {
             const isNestedVMCall = this.interfaceState.hasJSFrameAfterRbFrame;
-            let oldValue = false;
             if (isNestedVMCall) {
-              oldValue = this.guest.rbSetShouldProhibitRewind(true)
+              const oldShouldProhibitRewind = this.guest.rbSetShouldProhibitRewind(true)
+              const oldIsDisabledGc = this.guest.rbGcDisable()
+              const result = Reflect.apply(value, exports, args)
+              this.guest.rbSetShouldProhibitRewind(oldShouldProhibitRewind)
+              if (!oldIsDisabledGc) {
+                this.guest.rbGcEnable()
+              }
+              return result;
+            } else {
+              return Reflect.apply(value, exports, args)
             }
-            const result = Reflect.apply(value, exports, args)
-            if (isNestedVMCall) {
-              this.guest.rbSetShouldProhibitRewind(oldValue)
-            }
-            return result;
           }
         }
       }

packages/npm-packages/ruby-wasm-wasi/test/gc.test.ts

@@ -83,10 +83,7 @@ describe("GC integration", () => {
     expect(o2.call("hash").toString()).toBe(o3.call("hash").toString());
   });
 
-  // TODO: Stopping GC while having a sandwitched JS frame is one of the options
-  // to make nested eval safe. But there is still a problem with Fiber switching,
-  // so this test is skipped for now.
-  test.skip("stop GC while having a sandwitched JS frame", async () => {
+  test("stop GC while having a sandwitched JS frame", async () => {
     const vm = await initRubyVM();
     const o = vm.eval(`
     require "js"
@@ -101,7 +98,28 @@ describe("GC integration", () => {
     `);
     const wasDisabled = o.call("takeVM", vm.wrap(vm));
     expect(wasDisabled.toJS()).toBe(true);
+    // Ensure that GC is enabled back
     const isNotEnabledBack = vm.eval("GC.enable");
     expect(isNotEnabledBack.toJS()).toBe(false);
+
+    // Re-start pending GC (including the incremental one)
+    vm.eval("GC.start");
+
+    // Disable GC before the nested call
+    vm.eval("GC.disable")
+    const o2 = vm.eval(`
+    JS.eval(<<~JS)
+      return {
+        takeVM(vm) {
+          return vm.eval("GC.disable").toJS();
+        }
+      }
+    JS
+    `);
+    const wasDisabled2 = o2.call("takeVM", vm.wrap(vm));
+    expect(wasDisabled2.toJS()).toBe(true);
+    // Ensure that GC is still disabled because it was disabled before the nested call
+    const isNotEnabledBack2 = vm.eval("GC.enable");
+    expect(isNotEnabledBack2.toJS()).toBe(true);
   });
 });