io-event 1.16.2 → 1.21.1

data/ext/io/event/selector/selector.c

@@ -8,6 +8,60 @@
 
 static const int DEBUG = 0;
 
+#ifndef RB_NOGVL_PENDING_INTR_FAIL
+static ID handle_interrupt_id;
+static VALUE signal_exception_never = Qnil;
+
+struct IO_Event_Selector_blocking_operation_arguments {
+	void *(*function)(void *);
+	void *data;
+	rb_unblock_function_t *unblock_function;
+	void *unblock_data;
+};
+
+static VALUE IO_Event_Selector_blocking_operation_yield(RB_BLOCK_CALL_FUNC_ARGLIST(yielded_argument, callback_argument)) {
+	struct IO_Event_Selector_blocking_operation_arguments *arguments = (struct IO_Event_Selector_blocking_operation_arguments *)callback_argument;
+	
+	rb_thread_call_without_gvl2(arguments->function, arguments->data, arguments->unblock_function, arguments->unblock_data);
+	
+	return Qnil;
+}
+
+static VALUE IO_Event_Selector_blocking_operation_fallback(VALUE callback_argument) {
+	return rb_block_call(rb_cThread, handle_interrupt_id, 1, &signal_exception_never, IO_Event_Selector_blocking_operation_yield, callback_argument);
+}
+#endif
+
+void IO_Event_Selector_blocking_operation(struct IO_Event_Selector *selector, void *(*function)(void *), void *data, rb_unblock_function_t *unblock_function, void *unblock_data) {
+	int state = 0;
+	selector->blocked = 1;
+	
+#ifdef RB_NOGVL_PENDING_INTR_FAIL
+	rb_nogvl(function, data, unblock_function, unblock_data, RB_NOGVL_INTR_FAIL | RB_NOGVL_PENDING_INTR_FAIL);
+#else
+	// `Thread.handle_interrupt` resets `pending_interrupt_queue_checked` and
+	// raises the VM interrupt flag when its mask is pushed with a non-empty
+	// pending queue. Its C block calls `rb_thread_call_without_gvl2` directly,
+	// without a Ruby safepoint between refreshing the flag and entering
+	// `unblock_function_set`. That function either observes the interrupt or
+	// installs the UBF while holding Ruby's interrupt lock.
+	//
+	// Keep signal exceptions deferred here: this fallback should prevent a
+	// stranded native wait without changing the caller's delivery timing.
+	struct IO_Event_Selector_blocking_operation_arguments arguments = {
+		.function = function,
+		.data = data,
+		.unblock_function = unblock_function,
+		.unblock_data = unblock_data,
+	};
+	rb_protect(IO_Event_Selector_blocking_operation_fallback, (VALUE)&arguments, &state);
+#endif
+	
+	selector->blocked = 0;
+	
+	if (state) rb_jump_tag(state);
+}
+
 #ifndef HAVE_RB_IO_DESCRIPTOR
 static ID id_fileno;
 
@@ -22,7 +76,7 @@ static VALUE rb_Process_Status = Qnil;
 
 VALUE IO_Event_Selector_process_status_wait(rb_pid_t pid, int flags)
 {
-	return rb_funcall(rb_Process_Status, id_wait, 2, PIDT2NUM(pid), INT2NUM(flags | WNOHANG));
+	return rb_funcall(rb_Process_Status, id_wait, 2, PIDT2NUM(pid), INT2NUM(flags));
 }
 #endif
 
@@ -78,7 +132,28 @@ static VALUE IO_Event_Selector_nonblock(VALUE class, VALUE io)
 	return rb_ensure(rb_yield, io, IO_Event_Selector_nonblock_ensure, (VALUE)&arguments);
 }
 
+static VALUE rb_IO_Event_Selector = Qnil;
+static ID id_process_wait;
+
+// Wait for a process when the selector cannot do so natively (e.g. `pid <= 0`: any child, or a process group). Delegates to the pure-Ruby `IO::Event::Selector.process_wait`, which performs a blocking wait on a separate thread; joining it is fiber-scheduler aware, so the reactor keeps running.
+VALUE IO_Event_Selector_process_wait(rb_pid_t pid, int flags) {
+	return rb_funcall(rb_IO_Event_Selector, id_process_wait, 2, PIDT2NUM(pid), INT2NUM(flags));
+}
+
 void Init_IO_Event_Selector(VALUE IO_Event_Selector) {
+#ifndef RB_NOGVL_PENDING_INTR_FAIL
+	handle_interrupt_id = rb_intern("handle_interrupt");
+	signal_exception_never = rb_hash_new();
+	rb_hash_aset(signal_exception_never, rb_eSignal, ID2SYM(rb_intern("never")));
+	rb_funcall(signal_exception_never, rb_intern("compare_by_identity"), 0);
+	rb_obj_freeze(signal_exception_never);
+	rb_gc_register_mark_object(signal_exception_never);
+#endif
+	
+	rb_IO_Event_Selector = IO_Event_Selector;
+	rb_gc_register_mark_object(rb_IO_Event_Selector);
+	id_process_wait = rb_intern("process_wait");
+	
 #ifndef HAVE_RB_IO_DESCRIPTOR
 	id_fileno = rb_intern("fileno");
 #endif
@@ -98,6 +173,7 @@ void IO_Event_Selector_initialize(struct IO_Event_Selector *backend, VALUE self,
 	
 	backend->waiting = NULL;
 	backend->ready = NULL;
+	backend->blocked = 0;
 }
 
 VALUE IO_Event_Selector_loop_resume(struct IO_Event_Selector *backend, VALUE fiber, int argc, VALUE *argv) {

data/ext/io/event/selector/selector.h

@@ -40,19 +40,37 @@ static inline int IO_Event_try_again(int error) {
 	return error == EAGAIN || error == EWOULDBLOCK;
 }
 
+static inline int IO_Event_Selector_valid_buffer_range(size_t size, size_t offset, size_t length) {
+	return offset <= size && length <= size - offset;
+}
+
+// Enter a blocking region without the GVL. On Rubies without
+// `RB_NOGVL_PENDING_INTR_FAIL`, refresh pending-interrupt state immediately
+// before releasing the GVL so a signal cannot be stranded in the queue.
+struct IO_Event_Selector;
+void IO_Event_Selector_blocking_operation(struct IO_Event_Selector *selector, void *(*function)(void *), void *data, rb_unblock_function_t *unblock_function, void *unblock_data);
+
 #ifdef HAVE_RB_IO_DESCRIPTOR
 #define IO_Event_Selector_io_descriptor(io) rb_io_descriptor(io)
 #else
 int IO_Event_Selector_io_descriptor(VALUE io);
 #endif
 
-// Reap a process without hanging.
+// Wait for a process to change state. This blocks until the process changes state, unless `WNOHANG` is given in `flags`.
 #ifdef HAVE_RB_PROCESS_STATUS_WAIT
-#define IO_Event_Selector_process_status_wait(pid, flags) rb_process_status_wait(pid, flags | WNOHANG)
+#define IO_Event_Selector_process_status_wait(pid, flags) rb_process_status_wait(pid, flags)
 #else
 VALUE IO_Event_Selector_process_status_wait(rb_pid_t pid, int flags);
 #endif
 
+// Reap a process that is known to have changed state (e.g. after a readiness event), without blocking.
+static inline VALUE IO_Event_Selector_process_status_reap(rb_pid_t pid, int flags) {
+	return IO_Event_Selector_process_status_wait(pid, flags | WNOHANG);
+}
+
+// Wait for a process the selector cannot represent natively (e.g. `pid <= 0`: any child, or a process group), using a fiber-scheduler aware blocking wait on a separate thread.
+VALUE IO_Event_Selector_process_wait(rb_pid_t pid, int flags);
+
 int IO_Event_Selector_nonblock_set(int file_descriptor);
 void IO_Event_Selector_nonblock_restore(int file_descriptor, int flags);
 
@@ -76,6 +94,10 @@ struct IO_Event_Selector {
 	VALUE self;
 	VALUE loop;
 	
+	// Whether the selector is currently blocked in a system call without the GVL.
+	// Used by wakeup() to determine if an interrupt signal is needed.
+	int blocked;
+	
 	// The ready queue is a list of fibers that are ready to be resumed from the event loop fiber.
 	// Append to waiting (front/head of queue).
 	struct IO_Event_Selector_Queue *waiting;