WIP

ioquatix · ioquatix · commit 122dabce3fdf · 2025-03-02T10:25:59.000+13:00
diff --git a/include/ruby/io.h b/include/ruby/io.h
@@ -674,9 +674,8 @@ VALUE rb_io_check_io(VALUE io);
  * @param[in]  io       An IO.
  * @param[in]  function A function to call.
  * @param[in]  data     Data to pass to the function.
- * @param[in]  flags    Flags (must be 0, reserved for later use).
  */
-VALUE rb_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument, int flags);
+VALUE rb_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument);
 
 /**
  * Queries the tied IO  for writing.  An IO can be  duplexed.  Fine.  The thing
diff --git a/internal/thread.h b/internal/thread.h
@@ -77,7 +77,7 @@ VALUE rb_thread_io_blocking_region(rb_blocking_function_t *func, void *data1, in
 VALUE rb_thread_io_blocking_call(rb_blocking_function_t *func, void *data1, int fd, int events);
 
 // Invoke the given function, with the specified argument, in a way that `IO#close` from another execution context can interrupt it.
-VALUE rb_thread_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument, int flags);
+VALUE rb_thread_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument);
 
 /* thread.c (export) */
 int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
diff --git a/io.c b/io.c
@@ -234,9 +234,15 @@ VALUE rb_io_blocking_region(struct rb_io *io, rb_blocking_function_t *function,
 }
 
 VALUE
-rb_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument, int flags)
+rb_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument)
 {
-    return rb_thread_io_interruptable_operation(self, function, argument, flags);
+    VALUE scheduler = rb_fiber_scheduler_current();
+
+    if (scheduler == Qnil) {
+        return function(argument);
+    } else {
+        return rb_thread_io_interruptable_operation(self, function, argument);
+    }
 }
 
 VALUE
@@ -250,7 +256,7 @@ io_interruptable_operation(VALUE self)
 {
     VALUE block = rb_block_proc();
 
-    return rb_io_interruptable_operation(self, io_interruptable_operation_begin, block, 0);
+    return rb_io_interruptable_operation(self, io_interruptable_operation_begin, block);
 }
 
 struct argf {
diff --git a/thread.c b/thread.c
@@ -1742,7 +1742,7 @@ rb_thread_io_interruptable_operation_ensure(VALUE _argument)
 }
 
 VALUE
-rb_thread_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument, int flags)
+rb_thread_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument)
 {
     struct rb_io *io;
     RB_IO_POINTER(self, io);
@@ -2665,7 +2665,7 @@ rb_ec_reset_raised(rb_execution_context_t *ec)
 int
 rb_notify_fd_close(int fd, struct rb_io_close_wait_list *busy)
 {
-    fprintf(stderr, "rb_notify_fd_close(%d) pid=%d\n", fd, getpid());
+    // fprintf(stderr, "rb_notify_fd_close(%d) pid=%d\n", fd, getpid());
     rb_vm_t *vm = GET_THREAD()->vm;
     struct waiting_fd *wfd = 0, *next;
     ccan_list_head_init(&busy->pending_fd_users);
@@ -2689,7 +2689,7 @@ rb_notify_fd_close(int fd, struct rb_io_close_wait_list *busy)
                 if (th->scheduler != Qnil) {
                     rb_fiber_scheduler_fiber_interrupt(th->scheduler, rb_fiberptr_self(ec->fiber_ptr), error);
                 } else {
-                    fprintf(stderr, "rb_notify_fd_close: Interrupting thread %p\n", (void *)th);
+                    // fprintf(stderr, "rb_notify_fd_close: Interrupting thread %p\n", (void *)th);
                     rb_threadptr_pending_interrupt_enque(th, error);
                     rb_threadptr_interrupt(th);
                 }

Original file line number	Diff line number	Diff line change
`@@ -234,9 +234,15 @@ VALUE rb_io_blocking_region(struct rb_io io, rb_blocking_function_t function,`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`VALUE`
`237`		`-rb_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument, int flags)`
	`237`	`+rb_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument)`
`238`	`238`	`{`
`239`		`- return rb_thread_io_interruptable_operation(self, function, argument, flags);`
	`239`	`+ VALUE scheduler = rb_fiber_scheduler_current();`
	`240`	`+`
	`241`	`+ if (scheduler == Qnil) {`
	`242`	`+ return function(argument);`
	`243`	`+ } else {`
	`244`	`+ return rb_thread_io_interruptable_operation(self, function, argument);`
	`245`	`+ }`
`240`	`246`	`}`
`241`	`247`
`242`	`248`	`VALUE`
`@@ -250,7 +256,7 @@ io_interruptable_operation(VALUE self)`
`250`	`256`	`{`
`251`	`257`	`VALUE block = rb_block_proc();`
`252`	`258`
`253`		`- return rb_io_interruptable_operation(self, io_interruptable_operation_begin, block, 0);`
	`259`	`+ return rb_io_interruptable_operation(self, io_interruptable_operation_begin, block);`
`254`	`260`	`}`
`255`	`261`
`256`	`262`	`struct argf {`
Original file line number	Diff line number	Diff line change
`@@ -1742,7 +1742,7 @@ rb_thread_io_interruptable_operation_ensure(VALUE _argument)`
`1742`	`1742`	`}`
`1743`	`1743`
`1744`	`1744`	`VALUE`
`1745`		`-rb_thread_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument, int flags)`
	`1745`	`+rb_thread_io_interruptable_operation(VALUE self, VALUE(*function)(VALUE), VALUE argument)`
`1746`	`1746`	`{`
`1747`	`1747`	`struct rb_io *io;`
`1748`	`1748`	`RB_IO_POINTER(self, io);`
`@@ -2665,7 +2665,7 @@ rb_ec_reset_raised(rb_execution_context_t *ec)`
`2665`	`2665`	`int`
`2666`	`2666`	`rb_notify_fd_close(int fd, struct rb_io_close_wait_list *busy)`
`2667`	`2667`	`{`
`2668`		`- fprintf(stderr, "rb_notify_fd_close(%d) pid=%d\n", fd, getpid());`
	`2668`	`+ // fprintf(stderr, "rb_notify_fd_close(%d) pid=%d\n", fd, getpid());`
`2669`	`2669`	`rb_vm_t *vm = GET_THREAD()->vm;`
`2670`	`2670`	`struct waiting_fd wfd = 0, next;`
`2671`	`2671`	`ccan_list_head_init(&busy->pending_fd_users);`
`@@ -2689,7 +2689,7 @@ rb_notify_fd_close(int fd, struct rb_io_close_wait_list *busy)`
`2689`	`2689`	`if (th->scheduler != Qnil) {`
`2690`	`2690`	`rb_fiber_scheduler_fiber_interrupt(th->scheduler, rb_fiberptr_self(ec->fiber_ptr), error);`
`2691`	`2691`	`} else {`
`2692`		`- fprintf(stderr, "rb_notify_fd_close: Interrupting thread %p\n", (void *)th);`
	`2692`	`+ // fprintf(stderr, "rb_notify_fd_close: Interrupting thread %p\n", (void *)th);`
`2693`	`2693`	`rb_threadptr_pending_interrupt_enque(th, error);`
`2694`	`2694`	`rb_threadptr_interrupt(th);`
`2695`	`2695`	`}`